Skip to content

6. Schichtenarchitekturen

6.1. Einführung

Kehren wir zur letzten Version der Anwendung zur Steuerberechnung zurück (Version 3, Kapitel 5). Auf das Wesentliche reduziert, hatte ihr Hauptprogramm folgende Struktur (vereinfachtes Schema):

// creation of an ITax object from a text or JSON file
ITax tax;
try {
    tax = fileName.toLowerCase().endsWith(".json") ? new JsonTax(fileName) : new FileTax(fileName);
} catch (TaxException e) {
    IO.println("The following error occurred: [Code=" + e.getCode() + ", Message=" + e.getMessage() + "]");
    return;
}
// Eingabeschleife
while (true) {
    String parameters = IO.readln("Tax calculation parameters in the format: ...").strip();
    ...
    // die Parameter sind korrekt: Wir berechnen die Steuer
    IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
}

Dieses Programm vereint drei Arten von Verarbeitung, die sich in den meisten Anwendungen finden:

  • das Abrufen von Daten, die in Dateien, Datenbanken usw. gespeichert sind: Zeilen 1–8;
  • die Interaktion mit dem Benutzer: Zeilen 11–12 (Eingabe) und 14 (Ausgabe);
  • die Anwendung eines fachlichen Algorithmus, der Steuerberechnung: Zeile 14. Diese Berechnung wurde bisher von der abstrakten Klasse [AbstractTax] durchgeführt, der Elternklasse von [FileTax] und [JsonTax]: In Version 3 sind Datenlesen und Berechnung noch in einem einzigen Objekt vereint.

Die Erfahrung hat gezeigt, dass die Trennung dieser verschiedenen Verarbeitungen in eigene Klassen die Wartbarkeit der Anwendung verbessert. Die Architektur einer so strukturierten Anwendung sieht wie folgt aus:

Image

Diese Architektur wird „Drei-Schichten-Architektur“ (englisch „three-tier architecture“) genannt. Der Begriff „Tier“ bezeichnet normalerweise einen Teil der Anwendung, der auf einem anderen Rechner läuft. Befinden sich die Teile auf demselben Rechner, spricht man stattdessen von einer „Schichtenarchitektur“:

  • Die Schicht [business] enthält die Geschäftsregeln der Anwendung. In unserem Fall sind das die Regeln zur Berechnung der Steuer eines Steuerzahlers. Diese Schicht benötigt zum Funktionieren Daten:
    • die Steuerstufen, die sich jedes Jahr ändern;
    • die Anzahl der Kinder, den Familienstand des Steuerzahlers und das Jahreseinkommen;
  • die Datenzugriffsschicht oder [dao] (DAO = Data Access Object) liefert Daten, die bereits in Dateien oder Datenbanken gespeichert sind. Dazu gehören, wie in Version 3 der Anwendung, die Steuerstufen;
  • die Benutzeroberflächenschicht oder [ui] (UI = User Interface) liefert die vom Benutzer eingegebenen Daten und zeigt dem Benutzer die Ergebnisse an. Hier betrifft das die Anzahl der Kinder, den Familienstand und das Jahreseinkommen des Steuerzahlers.

Allgemein gilt:

  • Die Schicht [dao] übernimmt den Zugriff auf persistente Daten (Dateien, Datenbanken) oder nicht persistente Daten (Netzwerk, Sensoren usw.);
  • die Schicht [ui] übernimmt die Interaktion mit dem Benutzer, sofern es einen gibt;
  • die drei Schichten werden durch den Einsatz von Schnittstellen voneinander unabhängig gemacht.

Wir greifen die Anwendung [Tax], die wir bereits mehrfach untersucht haben, erneut auf, um ihr eine Schichtenarchitektur zu geben. Zunächst müssen wir die Schnittstellen der verschiedenen Schichten der Anwendung definieren.

6.2. Die Schnittstellen der [Tax]-Anwendung

Denken Sie daran: Eine Schnittstelle definiert eine Menge von Methodensignaturen. Klassen, die die Schnittstelle implementieren, liefern die Implementierung dieser Methoden.

Kehren wir zur Schichtenarchitektur unserer Anwendung zurück:

Image

In dieser Art von Architektur geht die Initiative häufig vom Benutzer aus. Der Benutzer stellt in [1] eine Anfrage und erhält in [8] eine Antwort. Dies nennt man den Request-Response-Zyklus. Nehmen wir als Beispiel die Berechnung der Steuer eines Steuerzahlers. Dazu sind mehrere Schritte erforderlich:

  • Die Schicht [ui] fragt den Benutzer nach Familienstand, Anzahl der Kinder und Jahresgehalt. Das ist die oben beschriebene Operation [1];
  • danach bittet die Schicht [ui] die Schicht [business] um die Berechnung der Steuer. Dazu übermittelt sie dieser Schicht die vom Benutzer erhaltenen Daten. Das ist die Operation [2];
  • Die Schicht [business] benötigt für ihre Aufgabe bestimmte Informationen: die Steuerstufen. Sie fordert diese über den Weg [3, 4, 5, 6] bei der Schicht [dao] an: [3] ist die ursprüngliche Anfrage und [6] die Antwort auf diese Anfrage;
  • Mit allen benötigten Daten berechnet die Schicht [business] die Steuer;
  • Die Schicht [business] kann nun die in [2] gestellte Anfrage der Schicht [ui] beantworten. Das ist der Weg [7];
  • Die Schicht [ui] formatiert dieses Ergebnis und präsentiert es dem Benutzer. Das ist der Weg [8];
  • Man könnte sich vorstellen, dass der Benutzer Steuersimulationen durchführt und sie speichern möchte. Dazu würde er denselben Weg [1-8] nutzen.

Wie diese Beschreibung zeigt, nutzt eine Schicht die Ressourcen der Schicht zu ihrer Rechten, niemals die der Schicht zu ihrer Linken. Betrachten wir zwei benachbarte Schichten:

Image

Die Schicht [A] stellt Anfragen an die Schicht [B]. In den einfachsten Fällen wird eine Schicht durch eine einzige Klasse implementiert. Eine Anwendung entwickelt sich jedoch im Laufe der Zeit weiter, und die Schicht [B] kann nacheinander verschiedene Implementierungsklassen haben: [B1], [B2] und so weiter. Ist die Schicht [B] die Schicht [dao], kann sie eine erste Implementierung [B1] haben, die Daten aus einer Datei bezieht. Einige Jahre später möchte man diese Daten vielleicht in einer Datenbank speichern: Dann legt man eine zweite Implementierungsklasse [B2] an. Wenn die Schicht [A] in der ursprünglichen Anwendung direkt mit der Klasse [B1] gearbeitet hätte, wären wir gezwungen, den Code der Schicht [A] teilweise neu zu schreiben. Nehmen wir zum Beispiel an, wir hätten in der Schicht [A] etwa Folgendes geschrieben:

1
2
3
B1 b1 = new B1(...);
...
b1.getData(...);
  • Zeile 1: Eine Instanz der Klasse [B1] wird erzeugt;
  • Zeile 3: Von dieser Instanz werden Daten angefordert.

Hat die neue Implementierungsklasse [B2] Methoden mit derselben Signatur wie die Klasse [B1], müssen Sie alle Vorkommen von [B1] in [B2] ändern. Das ist der günstigste Fall, und er ist ziemlich unwahrscheinlich, wenn man nicht auf diese Signaturen geachtet hat. In der Praxis haben die Klassen [B1] und [B2] häufig unterschiedliche Methodensignaturen, sodass ein erheblicher Teil der Schicht [A] neu geschrieben werden muss.

Dieses Problem lässt sich abmildern, indem man zwischen die Schichten [A] und [B] eine Schnittstelle einfügt. Dadurch werden die Methodensignaturen, die die Schicht [B] der Schicht [A] zur Verfügung stellt, in einer Schnittstelle festgeschrieben. Das vorherige Schema wird zum folgenden:

Image

Die Schicht [A] kommuniziert nicht mehr direkt mit der Schicht [B], sondern mit deren Schnittstelle [IB]. Im Code der Schicht [A] erscheint die Implementierungsklasse [Bi] der Schicht [B] nun nur noch ein einziges Mal, nämlich wenn das Objekt erzeugt wird, das die Schnittstelle [IB] implementiert. Danach wird die Schnittstelle [IB] verwendet, nicht ihre Implementierungsklasse. Der vorherige Code wird zu:

1
2
3
IB ib = new B1(...);
...
ib.getData(...);
  • Zeile 1: Eine Instanz von *[ib] , die die Schnittstelle *[IB] implementiert, wird durch Instanziierung der Klasse *[B1]* erzeugt;
  • Zeile 3: Von der Instanz [ib] werden Daten angefordert.

Wenn wir nun die Implementierung [B1] der Schicht [B] durch eine Implementierung [B2] ersetzen und beide Implementierungen dieselbe Schnittstelle [IB] einhalten, muss nur Zeile 1 der Schicht [A] geändert werden. Das ist ein großer Vorteil, der allein schon den systematischen Einsatz von Schnittstellen zwischen zwei Schichten rechtfertigt.

Wir können noch weiter gehen und die Schicht [A] völlig unabhängig von der Schicht [B] machen. Im obigen Code ist Zeile 1 ein Problem, weil sie den Klassennamen [B1] fest einkodiert. Idealerweise sollte die Schicht [A] eine Implementierung der Schnittstelle [IB] erhalten, ohne einen Klassennamen angeben zu müssen. Das entspräche dem obigen Schema: Die Schicht [A] arbeitet gegen die Schnittstelle [IB], und es gibt keinen Grund, warum sie den Namen der Klasse kennen müsste, die diese Schnittstelle implementiert.

Genau das ermöglicht Dependency Injection (DI). Die vorherige Architektur entwickelt sich wie folgt weiter:

Image

Eine übergreifende Komponente, der Dependency-Injection-Container, erzeugt die Objekte, die die Schichten implementieren, und verbindet sie miteinander: Er übergibt der Schicht [A] eine Referenz auf das Objekt, das die Schicht [B] implementiert. Der Code der Schicht [A] hat dann folgende Form:

// the layer [A] receives the layer [B] through its constructor
public class A {
    private final IB ib;

    public A(IB ib) {
        this.ib = ib;
    }

    public void work() {
        ...
        ib.getData(...);
    }
}
  • Zeilen 5–7: Die Schicht [A] erhält über ihren Konstruktor eine Instanz [ib], die die Schnittstelle [IB] implementiert. Nicht die Schicht [A] erzeugt sie, sondern der Container;
  • Zeile 11: Von der Instanz [ib] werden Daten angefordert.

Die Implementierungsklasse [B1] taucht im Code der Schicht [A] nirgends mehr auf. Wird die Implementierung [B1] durch eine neue Implementierung [B2] ersetzt, ändert sich im Code der Schicht [A] nichts: Es ändert sich nur die eine Stelle in der Anwendung, an der dem Container mitgeteilt wird, welche Klasse [IB] implementiert. Diese Stelle kann den Namen der zu verwendenden Implementierung sogar aus einer Konfigurationsdatei lesen.

In der Java-Welt wurde Dependency Injection Anfang der 2000er-Jahre durch das Framework Spring populär, dessen Konfiguration damals in XML-Dateien geschrieben wurde. Das Spring Framework, mittlerweile in Version 7, bleibt der Branchenstandard; es bildet die Grundlage von Spring Boot, das wir in Kapitel 13, „Webservices“, verwenden werden. Seinen Container nutzen wir in Version 5 der Anwendung (es gibt andere, etwa CDI, den Jakarta-EE-Standard, oder Google Guice). Die Kombination aus „Java-Schnittstellen + Dependency Injection“ verbessert die Wartbarkeit der Anwendung erheblich, weil die Schichten voneinander unabhängig werden.

Kehren wir zur Schichtenarchitektur unserer Anwendung zurück. In einfachen Fällen können wir bei der Schicht [business] beginnen, um die Schnittstellen der Anwendung zu entdecken. Zum Funktionieren benötigt die Anwendung Daten:

  • die bereits in Dateien, Datenbanken oder über das Netzwerk verfügbar sind. Diese Daten liefert die Schicht [dao];
  • die noch nicht verfügbar sind. In diesem Fall liefert sie die Schicht [ui], die sie vom Benutzer einholt.

Welche Schnittstelle muss die Schicht [dao] der Schicht [business] bieten? Die Schicht [dao] muss der Schicht [business] die Steuerstufen liefern. In unserer Anwendung verwendet die Schicht [dao] vorhandene Daten, erzeugt aber keine neuen. Ihre Schnittstelle kann wie folgt aussehen:

package dao;

import entities.TaxBracket;
import java.util.List;

// die Schnittstelle der [dao]-Schicht
public interface ITaxDao {

    // die Steuerstufen
    List<TaxBracket> getTaxBrackets();
}
  • Zeile 1: Die Schnittstelle befindet sich im Paket [dao]. Die Datei [ITaxDao.java] muss sich daher, wie wir sehen werden, in einem Ordner mit dem Namen [dao] befinden;
  • Zeile 10: Die Schnittstelle [ITaxDao] definiert die Methode [getTaxBrackets], die der Schicht [business] die Steuerstufen liefert. Java kennt keine Properties: Schreibgeschützte Daten werden gemäß der JavaBeans-Konvention über die Methode [getXxx] bereitgestellt. Die Steuerstufen werden als Liste [List<TaxBracket>] und nicht als Array zurückgegeben: Wie wir sehen werden, liefern die Implementierungen eine unveränderliche Liste, während die Elemente eines Arrays vom Empfänger stets geändert werden können;
  • Zeile 3: importiert den Typ [TaxBracket], der im Paket [entities] definiert ist:
1
2
3
4
5
6
7
package entities;

import java.math.BigDecimal;

// eine Steuerstufe: ein Record, also eine nicht veränderbare Klasse
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

Eine Steuerstufe wird durch einen Record (Java 16) dargestellt: eine unveränderliche Klasse, für die der Compiler den Konstruktor (anhand der Komponenten, die in Klammern hinter dem Typnamen deklariert sind), die Felder [private final], die Zugriffsmethoden [limit()], [coeffR()] und [coeffN()] sowie die Methoden [equals], [hashCode], und [toString] erzeugt. Wir schreiben [new TaxBracket(limit, coeffR, coeffN)] , um eine Steuerstufe zu erzeugen. Die drei Komponenten sind vom Typ [BigDecimal], der Java-Klasse für exakte Dezimalzahlen: Ein [double] kann 0.068 oder 291.09 nicht exakt darstellen. Da ein *[BigDecimal] selbst unveränderlich ist, kann eine Steuerstufe nach ihrer Erzeugung nicht mehr geändert werden. Eine klassische JavaBean-Klasse mit [setXxx]-Methoden hätte dies erlaubt; wir werden sehen, dass diese Einschränkung einen Seiteneffekt einer älteren Art der Implementierung der Schicht [business]* beseitigt.

Welche Schnittstelle sollte die Schicht [business] der Schicht [ui] bieten? Sehen wir uns die Interaktionen zwischen diesen beiden Schichten noch einmal an:

  • Die Schicht [ui] fragt den Benutzer nach Familienstand, Anzahl der Kinder und Jahresgehalt. Das ist die Operation [1] im Schema;
  • Danach bittet die Schicht [ui] die Schicht [business] um die Berechnung der Steuer. Dazu übermittelt sie der Schicht [business] die vom Benutzer erhaltenen Daten. Das ist die Operation [2].

Die Schnittstelle der Schicht [business] könnte wie folgt aussehen:

1
2
3
4
5
6
7
package business;

// die Schnittstelle der [business]-Schicht
public interface ITaxBusiness {

    int calculateTax(boolean married, int nbChildren, int salary);
}
  • Zeile 1: Alles, was zur Schicht [business] gehört, wird im Paket [business] abgelegt;
  • Zeile 6: Die Schnittstelle [ITaxBusiness] definiert nur eine Methode, die die Steuer eines Steuerzahlers anhand seines Familienstands, der Anzahl seiner Kinder und seines Jahresgehalts berechnet. Die Methoden einer Schnittstelle sind implizit öffentlich und abstrakt: Man muss [public abstract] nicht schreiben.

Wir untersuchen nun eine erste Implementierung dieser Schichtenarchitektur.

6.3. Beispielanwendung – Version 4

6.3.1. Das Projekt

Version 4 ist ein Programm aus mehreren Quelldateien, das keine externen Bibliotheken verwendet. Wir führen es mit dem Java-Quellcode-Launcher aus, ohne ein Maven-Projekt anzulegen. Jede Schicht belegt einen eigenen Ordner:

TaxV4/
  Main.java                  integration of the layers
  TaxData.txt                the tax brackets
  TaxDataInvalid.txt         an incorrect brackets file
  entities/
    TaxBracket.java
    ErrorCode.java
    TaxException.java
  dao/
    ITaxDao.java
    HardwiredTax.java
    FileTax.java
  business/
    ITaxBusiness.java
    TaxBusiness.java
  ui/
    Dialog.java
  • Der Ordner [entities] enthält die schichtübergreifenden Typen für die Schichten [ui], [business], und [dao]: den Record [TaxBracket], die Ausnahme [TaxException], und die Enumeration [ErrorCode] ihrer Fehlercodes;
  • der Ordner [dao] enthält die Schnittstelle und die Klassen der Schicht [dao]. Wir verwenden zwei Implementierungen der Schnittstelle [ITaxDao]: die Klasse [HardwiredTax], deren Daten fest einkodiert sind (Version 2), und die Klasse [FileTax], die Daten aus einer Textdatei liest (Version 3). Das Lesen einer JSON-Datei, die andere Option aus Version 3, behandeln wir in Version 5;
  • der Ordner [business] enthält die Schnittstelle und die Klasse der Schicht [business];
  • der Ordner [ui] enthält die Klasse der Schicht [ui];
  • die Datei [Main.java] erzeugt die Schichten und verbindet sie miteinander;
  • die Datei [TaxData.txt] enthält die Steuerstufen, die von der Implementierung [FileTax] der Schicht [dao] gelesen werden.

Anders als in anderen Sprachen kommt es hier auf die Ordnernamen an: In Java liegt eine Klasse des Pakets [dao] in einem Ordner namens [dao], eine Klasse im Paket [tax.dao] in einem Ordner [tax/dao], und diese Ordner beziehen sich auf das Quellverzeichnis (Source Root). So finden der Compiler und die virtuelle Maschine die Klassen anhand ihrer vollqualifizierten Namen.

Die Datei [Main.java] ist eine kompakte Quelldatei: Sie hat keine Paketdeklaration und gehört daher zum unbenannten Paket im Quellverzeichnis. Ab Java 22 (Launcher für Programme aus mehreren Dateien, JEP 458) genügt der Befehl [java Main.java], eingegeben im Ordner [TaxV4], um das Programm auszuführen: Der Quellcode-Launcher kompiliert [Main.java] im Arbeitsspeicher, und sobald er auf eine Klasse aus einer anderen Datei stößt, zum Beispiel [dao.FileTax], sucht er die Datei [dao/FileTax.java] ausgehend vom Verzeichnis von [Main.java] und kompiliert sie ihrerseits. Es wird keine Datei mit der Endung [.class] auf die Festplatte geschrieben. Eine Klasse im unbenannten Paket kann Klassen aus anderen Paketen verwenden, umgekehrt ist das nicht möglich: Keine Klasse kann [Main] importieren. Deshalb wird nur das Hauptprogramm dort abgelegt.

Eine IDE öffnet diesen Ordner unverändert und führt [Main.java] ohne besondere Konfiguration aus. Sobald das Programm externe Bibliotheken benötigt (Jackson, Spring), wechseln wir in Version 5 zu einem Maven-Projekt.

6.3.2. Komponenten der Anwendung

Image

Typen, die mehrere Schichten durchziehen, bezeichnen wir als Entitäten. Es sind in der Regel die Klassen, die die Daten der Schicht [dao] kapseln. Diese Entitäten reichen typischerweise bis in die Schicht [ui] hinauf. Die Entitäten der Anwendung sind der bereits vorgestellte Record [TaxBracket] und die Ausnahme [TaxException] samt ihrer Enumeration von Fehlercodes:

package entities;

import java.util.StringJoiner;

// die Fehlercodes der [dao]-Schicht: Jeder entspricht einem Bit, daher können sie kombiniert werden
public enum ErrorCode {
    ACCESS, LINE, FIELD1, FIELD2, FIELD3;

    // das Bit des Codes: 1 für ACCESS, 2 für LINE, 4 für FIELD1, 8 für FIELD2, 16 für FIELD3
    public int bit() {
        return 1 << ordinal();
    }

    // die Namen der in einer Kombination von Bits enthaltenen Codes, zum Beispiel "FIELD2, FIELD3" für 24
    public static String names(int code) {
        StringJoiner names = new StringJoiner(", ");
        for (ErrorCode c : values()) {
            if ((code & c.bit()) != 0) {
                names.add(c.name());
            }
        }
        return names.toString();
    }
}
  • Zeile 6: eine Enumeration ([enum]). In Java sind die Werte einer Enumeration Objekte, nämlich eindeutige Instanzen der Klasse [ErrorCode], und eine Enumeration kann Methoden haben;
  • Zeile 7: die fünf Fehlercodes. Die Methode [ordinal()], von der Klasse [Enum] geerbt, liefert die Position des Werts in der Liste: 0 für [ACCESS], 4 für [FIELD3];
  • Zeilen 10–12: Jedem Code ist ein Bit zugeordnet, das durch eine Linksverschiebung gewonnen wird: [1 << ordinal()] ergibt 1, 2, 4, 8 und 16. Diese Zweierpotenzen lassen sich mit dem Operator [|] kombinieren: Der Code [FIELD2.bit() | FIELD3.bit()] (8 + 16 = 24) bedeutet, dass die Felder 2 und 3 einer Zeile fehlerhaft sind. In Version 3 war der Wert jedes Codes ausdrücklich angegeben ([ACCESS(1)], [LINE(2)] …) und eine Kombination wurde in eine Menge [EnumSet] entschlüsselt; die Berechnung des Bits anhand der Position macht diese Werte hier überflüssig. Der Fehlercode der Ausnahme bleibt eine einfache Ganzzahl, die alle Implementierungen der Schicht [dao] verwenden können;
  • Zeilen 15–23: Die statische Methode [names] liefert die Namen der in einer Bitkombination enthaltenen Codes: „FIELD2, FIELD3“ für 24. Die vom Compiler erzeugte Methode [values()] liefert das Array der Werte der Enumeration; [code & c.bit()] ist ungleich null, wenn das zum Code [c] gehörende Bit in [code] gesetzt ist; [name()] liefert den Namen des Werts. Ein [StringJoiner] (Java 8) verkettet Zeichenketten und trennt sie durch das Trennzeichen, das seinem Konstruktor übergeben wurde.
package entities;

import java.io.Serial;

// die von der [dao]-Schicht ausgelöste Exception
// sie leitet von RuntimeException ab: Es ist eine ungeprüfte Exception
public class TaxException extends RuntimeException {

    // Version der Klasse für die Serialisierung (eine Exception ist serialisierbar)
    @Serial
    private static final long serialVersionUID = 1L;

    // Fehlercode (eine Kombination von ErrorCode-Bits)
    private final int code;

    // Konstruktoren
    public TaxException(String message, int code) {
        this(message, null, code);
    }

    public TaxException(String message, Throwable cause, int code) {
        super(message, cause);
        this.code = code;
    }

    // der Fehlercode
    public int getCode() {
        return code;
    }
}
  • Zeile 7: Eine anwendungsspezifische Ausnahme wird von der Klasse [RuntimeException] abgeleitet; sie ist eine ungeprüfte Ausnahme (unchecked). Die Methoden, die sie auslösen, müssen sie nicht in einer [throws]-Klausel deklarieren, und ihre Aufrufer müssen sie nicht abfangen. Das ist das übliche Vorgehen für Fehler, die eine Schicht an eine andere Schicht meldet;
  • Zeilen 10–11: Eine Ausnahme ist serialisierbar (die Klasse [Throwable] implementiert die Schnittstelle [Serializable]). Das Feld [serialVersionUID] gibt die Version der Klasse für die Serialisierung an; fehlt es, gibt der Compiler bei Verwendung der Option [-Xlint:all] eine Warnung aus. Die Annotation [@Serial] (Java 14) ermöglicht es dem Compiler, die Deklaration dieses Felds zu überprüfen;
  • Zeile 14: der Fehlercode, eine Ganzzahl, die Bits von [ErrorCode] kombiniert. Das Feld ist [final]: Es wird im Konstruktor initialisiert und kann danach nicht mehr geändert werden;
  • Zeilen 17–24: zwei Konstruktoren, einer mit einer Meldung und einem Code, der andere zusätzlich mit der ursprünglichen Ausnahme (der Ursache), die über die Methode [getCause()] zugänglich sein wird. Der erste ruft den zweiten auf ([this(...)]), der den Konstruktor der Elternklasse [RuntimeException] aufruft ([super(...)]);
  • Zeilen 27–29: die Zugriffsmethode für den Fehlercode.

In dieser Version löst nur die Klasse [FileTax] der Schicht [dao] die [TaxException] aus.

6.3.3. Die [dao]-Schicht

Rufen wir uns die Schnittstelle der Schicht [dao] in Erinnerung:

package dao;

import entities.TaxBracket;
import java.util.List;

// die Schnittstelle der [dao]-Schicht
public interface ITaxDao {

    // die Steuerstufen
    List<TaxBracket> getTaxBrackets();
}

Wir implementieren diese Schnittstelle auf zwei verschiedene Arten. Zunächst mit der Klasse [HardwiredTax]:

package dao;

import entities.TaxBracket;
import java.math.BigDecimal;
import java.util.List;

// eine [dao]-Schicht, deren Daten im Code „fest verdrahtet" sind
public class HardwiredTax implements ITaxDao {

    // Steuerstufen (Steuertarif 2004 auf Einkommen 2003): eine nicht veränderbare Liste
    private final List<TaxBracket> taxBrackets = List.of(
            bracket("4962", "0", "0"),
            bracket("8382", "0.068", "291.09"),
            bracket("14753", "0.191", "1322.92"),
            bracket("23888", "0.283", "2668.39"),
            bracket("38868", "0.374", "4846.98"),
            bracket("47932", "0.426", "6883.66"),
            bracket("0", "0.481", "9505.54"));

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }

    // eine aus Zeichenketten aufgebaute Stufe: Die BigDecimal-Werte sind exakt
    private static TaxBracket bracket(String limit, String coeffR, String coeffN) {
        return new TaxBracket(new BigDecimal(limit), new BigDecimal(coeffR), new BigDecimal(coeffN));
    }
}
  • Zeile 8: Die Klasse [HardwiredTax] implementiert ([implements]) die Schnittstelle [ITaxDao];
  • Zeilen 11–18: die Steuerstufen. [List.of] (Java 9) erzeugt eine schreibgeschützte Liste: Ihre Methoden [add], [set] oder [remove] lösen eine [UnsupportedOperationException] aus. Das Feld wird in seiner Deklaration initialisiert;
  • Zeilen 20–23: die Implementierung der Schnittstellenmethode. Die Annotation [@Override] weist den Compiler an zu prüfen, dass die Methode eine Methode der Schnittstelle korrekt implementiert: Ein Tippfehler im Namen würde zu einem Kompilierfehler führen;
  • Zeilen 26–28: eine private Methode, die aus drei Zeichenketten eine Steuerstufe erzeugt. Ein aus einer Zeichenkette erzeugter [BigDecimal] ist exakt: [new BigDecimal("0.068")] ist genau 0,068, während [new BigDecimal(0.068)] den Wert 0,0680000000000000049… ergäbe, den nächstliegenden [double]-Wert zu 0,068.

Die Schnittstelle [ITaxDao] wird auch von der Klasse [FileTax] implementiert, die Steuerstufen aus einer Textdatei liest. Die Datei [TaxData.txt] sieht wie folgt aus:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

Jede Zeile beschreibt eine Steuerstufe im Format [limit:coeffR:coeffN]. Die Zahlen werden unabhängig von der Systemsprache mit Dezimalpunkt geschrieben; so ist die Datei auf allen Rechnern lesbar. Die Werte stammen aus der Steuertabelle von 2004 für die Einkommen des Jahres 2003 und wurden unverändert übernommen: Es handelt sich um eine Übung. Die Klasse [FileTax] lautet wie folgt:

package dao;

import static entities.ErrorCode.ACCESS;
import static entities.ErrorCode.FIELD1;
import static entities.ErrorCode.FIELD2;
import static entities.ErrorCode.FIELD3;
import static entities.ErrorCode.LINE;

import entities.TaxException;
import entities.TaxBracket;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;

// eine [dao]-Schicht, die die Steuerstufen aus einer Textdatei liest
// eine Zeile pro Stufe: limit:coeffR:coeffN (Dezimalpunkt)
public class FileTax implements ITaxDao {

    // Datendatei, relativ zum aktuellen Ordner
    private final String fileName;

    // Steuerstufen
    private final List<TaxBracket> taxBrackets;

    // Konstruktor
    public FileTax(String fileName) {
        // wir speichern den Namen der Datei
        this.fileName = fileName;
        // die gelesenen Stufen
        List<TaxBracket> brackets = new ArrayList<>();
        // Lesen der Datei Zeile für Zeile
        int lineNumber = 0;
        try {
            Path path = Path.of(fileName);
            if (!Files.exists(path)) {
                throw new NoSuchFileException(fileName, null, "The file [" + fileName + "] does not exist");
            }
            for (String lineRead : Files.readAllLines(path)) {
                lineNumber++;
                // leere Zeilen werden ignoriert
                String line = lineRead.strip();
                if (line.isEmpty()) {
                    continue;
                }
                // in drei durch : getrennte Felder zerlegte Zeile
                String[] fields = line.split("\\s*:\\s*");
                int code = 0;
                BigDecimal limit = null, coeffR = null, coeffN = null;
                if (fields.length != 3) {
                    code = LINE.bit();
                } else {
                    // Umwandlungen der 3 Felder: Jeder Fehler fügt seine Bits zum Code hinzu
                    limit = parse(fields[0]);
                    coeffR = parse(fields[1]);
                    coeffN = parse(fields[2]);
                    if (limit == null) code |= FIELD1.bit();
                    if (coeffR == null) code |= FIELD2.bit();
                    if (coeffN == null) code |= FIELD3.bit();
                }
                // Fehler?
                if (code != 0) {
                    throw new TaxException("Line no. " + lineNumber + " is incorrect: [" + line + "]", code);
                }
                // wir speichern die neue Steuerstufe
                brackets.add(new TaxBracket(limit, coeffR, coeffN));
            }
        } catch (IOException e) {
            // Dateizugriffsfehler: Er wird in eine TaxException verpackt
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS.bit());
        }
        // wir geben eine nicht veränderbare Kopie der Liste zurück
        taxBrackets = List.copyOf(brackets);
    }

    public String getFileName() {
        return fileName;
    }

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }

    // eine mit Ziffern und einem Dezimalpunkt geschriebene positive oder null betragende Zahl; null, wenn fehlerhaft
    private static BigDecimal parse(String field) {
        return field.matches("\\d+(\\.\\d+)?") ? new BigDecimal(field) : null;
    }
}
  • Zeilen 3–7: Der statische Import ([import static], Java 5) erlaubt es, die statischen Member einer Klasse ohne vorangestellten Klassennamen zu verwenden. Die Werte einer Enumeration sind statische Member: Wir schreiben [FIELD1] statt [ErrorCode.FIELD1];
  • Zeile 21: Die Klasse [FileTax] implementiert die Schnittstelle [ITaxDao];
  • Zeilen 24, 27: der Dateiname und die gelesenen Segmente. Diese [final]-Felder werden nur einmal initialisiert, und zwar im Konstruktor (Zeilen 32 und 76). Sie werden von den Methoden in den Zeilen 79–86 zurückgegeben; [getTaxBrackets] ist die Schnittstellenmethode;
  • Zeile 30: Der Konstruktor erhält den Namen der Datei mit den Steuerstufen;
  • Zeile 34: Die gelesenen Steuerstufen werden in einer Liste vom Typ [ArrayList] gesammelt;
  • Zeile 38: [Path.of] (Java 11) erzeugt den Dateipfad. Ein relativer Pfad bezieht sich auf das aktuelle Verzeichnis, also das Verzeichnis, in dem der Befehl [java] eingegeben wurde;
  • Zeilen 39–41: Existiert die Datei nicht, wird eine [NoSuchFileException] (aus dem Paket [java.nio.file]) mit einer aussagekräftigen Meldung ausgelöst. Ihr Konstruktor mit drei Parametern erhält den Dateinamen, den Namen einer möglichen zweiten Datei (hier [null]) und den Grund des Fehlers. Ohne diesen Test würde [Files.readAllLines] selbst eine [NoSuchFileException] auslösen, deren Meldung nur aus dem Dateinamen bestünde;
  • Zeile 42: [Files.readAllLines] liest die gesamte Datei in UTF-8 und liefert eine Liste ihrer Zeilen. Die Methode öffnet und schließt die Datei selbst. Bei einer großen Datei wäre es besser, sie fortlaufend mit [Files.lines] oder [BufferedReader] zu lesen;
  • Zeile 45: [strip()] (Java 11) entfernt führende und nachgestellte Leerzeichen;
  • Zeile 50: Die Zeile wird mit [split] zerlegt, dessen Parameter ein regulärer Ausdruck ist: Das Trennzeichen ist ein Doppelpunkt, der optional von Leerzeichen umgeben ist ([\s*] steht für null oder mehr Leerzeichen). In einer Java-Zeichenkette wird der Backslash verdoppelt;
  • Zeilen 53–54: Eine Zeile, die nicht drei Felder hat, ist ungültig;
  • Zeilen 57–62: Umwandlung der drei Felder. Jedes fehlerhafte Feld fügt dem Fehlercode mit dem Operator [|=] ein Bit hinzu;
  • Zeilen 65–67: Eine ungültige Zeile löst eine [TaxException] aus, deren Meldung die Zeilennummer und den Inhalt angibt. Diese Ausnahme ist keine [IOException]: Sie wird in Zeile 71 nicht abgefangen und unverändert an den Aufrufer weitergegeben;
  • Zeile 69: Die gelesene Stufe wird der Liste hinzugefügt;
  • Zeilen 71–74: Alle E/A-Fehler stammen von [IOException]: Datei nicht gefunden ([NoSuchFileException]), unzureichende Berechtigungen ([AccessDeniedException]), Datei nicht in UTF-8 ([MalformedInputException]) usw. Der Fehler wird in eine [TaxException] mit dem Code [ACCESS] verpackt; die ursprüngliche Ausnahme bleibt als Ursache erhalten;
  • Zeile 76: [List.copyOf] (Java 10) liefert eine schreibgeschützte Kopie der Liste;
  • Zeilen 89–91: Umwandlung eines Felds in [BigDecimal]. Die Methode [matches] prüft, ob die gesamte Zeichenkette dem regulären Ausdruck [\d+(\.\d+)?] entspricht: eine oder mehrere Ziffern, optional gefolgt von einem Punkt und weiteren Ziffern. „0,191“ wird also abgelehnt, ebenso jede negative Zahl. Der Konstruktor [BigDecimal(String)] ist von der Sprache des Benutzers unabhängig: Er erwartet immer einen Dezimalpunkt. Im Fehlerfall liefert die Methode [null] zurück.

6.3.4. Die [business]-Schicht

Rufen wir uns die Schnittstelle dieser Schicht in Erinnerung:

1
2
3
4
5
6
7
package business;

// die Schnittstelle der [business]-Schicht
public interface ITaxBusiness {

    int calculateTax(boolean married, int nbChildren, int salary);
}

Ihre Implementierung [TaxBusiness] sieht wie folgt aus:

package business;

import dao.ITaxDao;
import entities.TaxBracket;
import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

// die [business]-Schicht erhält die [dao]-Schicht über ihren Konstruktor
public class TaxBusiness implements ITaxBusiness {

    // die Steuerstufen, einmal für alle Mal bei der [dao]-Schicht angefordert
    private final List<TaxBracket> brackets;

    // Konstruktor
    public TaxBusiness(ITaxDao dao) {
        brackets = dao.getTaxBrackets();
    }

    // Steuerberechnung
    @Override
    public int calculateTax(boolean married, int nbChildren, int salary) {
        // Prüfung der Parameter
        if (nbChildren < 0) {
            throw new IllegalArgumentException("nbChildren (" + nbChildren + ") must be positive or zero");
        }
        if (salary < 0) {
            throw new IllegalArgumentException("salary (" + salary + ") must be positive or zero");
        }
        // Anzahl der Anteile
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // zu versteuerndes Einkommen und Familienquotient
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal qf = income.divide(shares, MathContext.DECIMAL128);
        // die Stufe: die erste, deren Grenze größer oder gleich QF ist,
        // die letzte, falls keine passt (ihre Grenze wird nicht verwendet)
        TaxBracket bracket = brackets.getLast();
        for (int i = 0; i < brackets.size() - 1; i++) {
            if (qf.compareTo(brackets.get(i).limit()) <= 0) {
                bracket = brackets.get(i);
                break;
            }
        }
        // Steuer (ganzzahliger Anteil)
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • Zeile 10: Die Klasse [TaxBusiness] implementiert die Schnittstelle [ITaxBusiness]. Die Schicht [business] muss mit der Schicht [dao] zusammenarbeiten: Sie erhält daher über ihren Konstruktor (Zeile 16) eine Referenz auf das Objekt, das die Schnittstelle [ITaxDao] implementiert;
  • Zeilen 13, 16–18: Bei der Konstruktion des Objekts fordert die Schicht [business] die Steuerstufen einmalig bei der Schicht [dao] an und speichert sie in einem [final]-Feld. Beachten Sie, dass die Schicht [business] die Schicht [dao] nur über deren Schnittstelle [ITaxDao] kennt: Sie weiß nicht, ob die Steuerstufen aus dem Code, aus einer Datei oder später aus einer Datenbank stammen;
  • Zeilen 24–29: Die Schicht [business] vertraut ihren Aufrufern nicht. Ein falscher Parameter löst eine [IllegalArgumentException] aus, die ungeprüfte Ausnahme, die Java für diesen Fall vorsieht, mit einer Meldung, die den Parameter benennt;
  • Zeilen 31–35: die Anzahl der Anteile. Ein [BigDecimal] hat keine arithmetischen Operatoren: Stattdessen werden seine Methoden [add], [subtract], [multiply], und [divide] verwendet. Da er unveränderlich ist, liefert jede Operation ein neues Objekt, daher die Schreibweise [shares = shares.add(...)]. Die Division durch [BigDecimal.TWO] (eine mit Java 19 hinzugekommene Konstante) ist exakt: 3 Kinder ergeben 1,5 Anteile;
  • Zeilen 37–38: das zu versteuernde Einkommen und der Familienquotient. Die Division durch die Anzahl der Anteile kann unendlich viele Dezimalstellen ergeben (etwa bei einer Division durch 3): Ohne Angabe einer Genauigkeit würde [divide] dann eine [ArithmeticException] auslösen. [MathContext.DECIMAL128] begrenzt das Ergebnis auf 34 signifikante Stellen;
  • Zeilen 41–47: Wir suchen die erste Stufe, deren Grenzwert größer oder gleich dem Familienquotienten ist. Die [BigDecimal]-Werte werden mit [compareTo] verglichen, das eine negative Zahl, null oder eine positive Zahl liefert: [qf.compareTo(limit) <= 0] bedeutet [qf <= limit]. Die letzte Stufe, [brackets.getLast()] (Java 21), wird verwendet, wenn keine der anderen zutrifft: Ihr Grenzwert (0) wird nicht benutzt;
  • Zeile 49: die Steuer. [intValue()] liefert den ganzzahligen Anteil des Ergebnisses.

Ein früher verbreitetes Vorgehen bestand darin, die Grenze der letzten Stufe zu ändern (etwa [brackets[brackets.length - 1].setLimit(qf + 1)]), bevor gesucht wurde, damit die Suchschleife immer anhält. Diese Anweisung veränderte das von der Schicht [dao] gelieferte Array: ein Seiteneffekt auf Daten, die alle Schichten gemeinsam nutzen. Wir könnten sie hier nicht mehr schreiben, denn eine [TaxBracket] ist unveränderlich, ebenso wie die Liste, die sie enthält. Moderner Code nimmt einfach die letzte Stufe, wenn keine Grenze passt, ohne die empfangenen Daten zu verändern.

6.3.5. Die [ui]-Schicht

In den Versionen 2 und 3 war die Benutzeroberfläche im Hauptprogramm geschrieben, im Anschluss an die Erzeugung des Berechnungsobjekts. Der einzige Unterschied bestand darin, wie dieses Objekt erzeugt wurde. Wir isolieren diese Interaktion nun in einer Klasse der Schicht [ui], die die Schicht [business] nur über ihre Schnittstelle kennt:

package ui;

import business.ITaxBusiness;

// der Konsolendialog mit dem Benutzer: Er kennt nur die Schnittstelle der [business]-Schicht
public final class Dialog {

    // bei fehlerhafter Eingabe angezeigte Hilfe
    private static final String SYNTAX = """
            syntax: Married NbChildren Salary
            Married: y for married, n for not married
            NbChildren: number of children
            Salary: annual salary in euros""";

    // Hilfsklasse: keine Instanz
    private Dialog() {
    }

    // Dialogschleife: Eingabe der Parameter, Berechnung, Anzeige
    public static void run(ITaxBusiness business) {
        while (true) {
            // wir fragen nach den Parametern der Steuerberechnung
            String input = IO.readln("Tax calculation parameters in the format: "
                    + "Married (y/n) NbChildren Salary, or nothing to stop: ");
            String parameters = input == null ? "" : input.strip();
            // etwas zu tun?
            if (parameters.isEmpty()) {
                break;
            }
            // Prüfung der Anzahl der Parameter
            String[] fields = parameters.split("\\s+");
            if (fields.length != 3) {
                IO.println(SYNTAX);
                continue;
            }
            // verheiratet
            String married = fields[0].toLowerCase();
            if (!married.equals("y") && !married.equals("n")) {
                IO.println(SYNTAX + "\nIncorrect Married argument: type y or n");
                continue;
            }
            // Anzahl der Kinder
            int nbChildren = integer(fields[1]);
            if (nbChildren < 0) {
                IO.println(SYNTAX + "\nIncorrect NbChildren argument: type a positive or zero integer");
                continue;
            }
            // salary
            int salary = integer(fields[2]);
            if (salary < 0) {
                IO.println(SYNTAX + "\nIncorrect Salary argument: type a positive or zero integer");
                continue;
            }
            // die Parameter sind korrekt: Wir fordern die Berechnung bei der [business]-Schicht an
            IO.println("Tax=" + business.calculateTax(married.equals("y"), nbChildren, salary) + " euros");
        }
    }

    // eine positive oder null betragende ganze Zahl, -1, wenn die Zeichenkette keine ist
    private static int integer(String field) {
        try {
            return Integer.parseInt(field);
        } catch (NumberFormatException e) {
            return -1;
        }
    }
}
  • Zeile 6: Die Klasse [Dialog] hat keinen eigenen Zustand und enthält nur statische Member. Java kennt keine statischen Klassen auf oberster Ebene: Wir deklarieren die Klasse als [final] (sie kann nicht abgeleitet werden) und geben ihr einen privaten Konstruktor (Zeilen 16–17), der verhindert, dass Instanzen erzeugt werden;
  • Zeilen 9–13: Die Hilfemeldung ist ein Textblock (Java 15), der durch drei Anführungszeichen begrenzt wird. Er kann sich über mehrere Zeilen erstrecken; die gemeinsame Einrückung der Zeilen wird entfernt. Da die schließenden Anführungszeichen am Ende der letzten Zeile stehen, endet der Text nicht mit einem Zeilenumbruch;
  • Zeile 20: Die Methode [run] erhält die Schicht [business] in Form ihrer Schnittstelle [ITaxBusiness]. Sie weiß nichts über die Klasse, die sie implementiert, und nichts über die Schicht [dao];
  • Zeilen 23–25: [IO.readln] (Java 25) gibt seinen Parameter aus und liest dann eine Zeile von der Tastatur. Am Ende des Eingabestroms liefert es [null] zurück; Zeile 25 ersetzt dann [null] durch die leere Zeichenkette: Ein Signal für das Stromende beendet den Dialog genauso wie eine leere Zeile;
  • Zeile 31: Die eingegebene Zeile wird an Leerzeichen zerlegt; der reguläre Ausdruck [\s+] (ein oder mehrere Leerzeichen) ignoriert mehrfache Leerzeichen;
  • Zeilen 37–38: Die Zeichenketten werden mit [equals] verglichen, niemals mit [==], das Referenzen vergleicht;
  • Zeilen 43–53: Die Anzahl der Kinder und das Gehalt müssen positive Ganzzahlen oder null sein. Die Methode [integer] (Zeilen 60–66) liefert -1, wenn das Feld keine Ganzzahl ist: [Integer.parseInt] löst dann eine [NumberFormatException] aus, die abgefangen wird. Eine negative Zahl und eine fehlerhafte Eingabe werden so durch dieselbe Prüfung abgelehnt;
  • Zeile 55: Die Parameter sind korrekt: Die Berechnung wird von der Schicht [business] angefordert.

6.3.6. Integration der Schichten

Es bleibt, die Schichten zu erzeugen und miteinander zu verbinden. Das ist die Aufgabe des Hauptprogramms [Main.java]:

import dao.FileTax;
import dao.HardwiredTax;
import dao.ITaxDao;
import entities.ErrorCode;
import entities.TaxException;
import business.ITaxBusiness;
import business.TaxBusiness;
import ui.Dialog;

// Integration der Schichten: Dies ist die einzige Stelle, an der die Implementierungsklassen genannt werden
// Argument: "hardwired" für HardwiredTax,
// andernfalls der Name der von FileTax gelesenen Datei (standardmäßig TaxData.txt)
void main(String[] args) {
    String source = args.length > 0 ? args[0] : "TaxData.txt";
    ITaxBusiness business;
    try {
        // Erzeugung der [dao]-Schicht
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // Erzeugung der [business]-Schicht, die die [dao]-Schicht erhält
        business = new TaxBusiness(dao);
    } catch (TaxException e) {
        // Anzeige des Fehlers und Beenden des Programms mit Exit-Code 1
        String origin = e.getCause() == null ? "" : ", original exception: " + e.getCause().getMessage();
        IO.println("The following error occurred: [Code=" + ErrorCode.names(e.getCode())
                + ", Message=" + e.getMessage() + origin + "]");
        System.exit(1);
        return;
    }

    // die [ui]-Schicht: der Dialog mit dem Benutzer
    Dialog.run(business);
}
  • Zeilen 1–8: Eine kompakte Quelldatei (Java 25) hat keine Klassendeklaration, darf aber Importe enthalten. Der Compiler legt ihren Inhalt in einer impliziten Klasse ab;
  • Zeile 13: Die Methode [main] erhält die Kommandozeilenargumente im Array [args]. Das Argument wählt die Implementierung der Schicht [dao] aus: [hardwired] für die Klasse [HardwiredTax]; andernfalls der Name der Datei, die von der Klasse [FileTax] gelesen wird, standardmäßig [TaxData.txt] ;
  • Zeile 18: Erzeugung der Schicht [dao]. Dies ist die einzige Stelle im Programm, an der die Klassen [HardwiredTax] und [FileTax] genannt werden;
  • Zeile 20: Erzeugung der Schicht [business], die die Schicht [dao] erhält;
  • Zeilen 21–28: Die Erzeugung der Schicht [dao] kann die Erzeugung einer [TaxException] auslösen. Der Fehler wird dann zusammen mit der Meldung der ursprünglichen Ausnahme (falls vorhanden) angezeigt, und das Programm endet mit dem Exit-Code 1 ([System.exit(1)]). Der Fehlercode wird mit der Methode [ErrorCode.names] im Klartext angezeigt. Die [return]-Anweisung in Zeile 27 wird nie ausgeführt, aber der Compiler weiß nicht, dass [System.exit] die Kontrolle nicht zurückgibt: Ohne sie würde er melden, dass die Variable [business] in Zeile 31 möglicherweise nicht initialisiert ist;
  • Zeile 31: Die Schichten sind bereit: Die Schicht [ui] interagiert mit dem Benutzer.

6.3.7. Ausführungen

Im Ordner [TaxV4] mit der Datei [TaxData.txt] (Implementierung [FileTax]) und beim Testen der Eingabevalidierung:

> java Main.java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 3 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: x 2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -2 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000€
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect Salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit der Implementierung [HardwiredTax]:

1
2
3
4
5
6
> java Main.java hardwired
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit einer Datei, die nicht existiert:

> java Main.java TaxDataMissing.txt
The following error occurred: [Code=ACCESS, Message=Error while reading the file TaxDataMissing.txt, original exception: TaxDataMissing.txt: The file [TaxDataMissing.txt] does not exist]

Der Fehlercode lautet [ACCESS], und die Meldung der ursprünglichen Ausnahme, [NoSuchFileException], wird angezeigt: Sie besteht aus dem Dateinamen, gefolgt vom Grund, der bei ihrer Erzeugung angegeben wurde.

Mit der folgenden Datei [TaxDataInvalid.txt], in der Zeile 3 Dezimalkommas enthält:

1
2
3
4
4962:0:0
8382:0.068:291.09
14753:0,191:1322,92
23888:0.283:2668.39

ist das Ergebnis:

> java Main.java TaxDataInvalid.txt
The following error occurred: [Code=FIELD2, FIELD3, Message=Line no. 3 is incorrect: [14753:0,191:1322,92]]

Die Felder 2 und 3 von Zeile 3 sind fehlerhaft: Der Fehlercode kombiniert die Bits von [FIELD2] und [FIELD3], und die Methode [ErrorCode.names] zeigt ihn als „FIELD2, FIELD3“ an.

6.3.8. Fazit

Die Schichtenarchitektur und der Einsatz von Schnittstellen haben unserer Anwendung eine gewisse Flexibilität verschafft. Das zeigt sich daran, wie das Hauptprogramm die Schichten [dao] und [business] erzeugt:

1
2
3
4
        // Erzeugung der [dao]-Schicht
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // Erzeugung der [business]-Schicht, die die [dao]-Schicht erhält
        business = new TaxBusiness(dao);

Ein Wechsel der Implementierung der Schicht [dao] betrifft nur Zeile 2. Sobald die Schichten erzeugt sind, ist der Code der Schicht [ui] in beiden Fällen derselbe: Die Schicht [business] wird dort über ihre Schnittstelle [ITaxBusiness] angesprochen, nicht über ihre Implementierungsklasse.

Dieselbe Flexibilität zeigt sich in der Schicht [business]: Sie wird anhand einer Referenz auf die Schnittstelle der Schicht [dao] aufgebaut. Ein Wechsel der Implementierung der Letzteren hat daher keine Auswirkungen auf die Schicht [business]. Deshalb konnte unsere einzige Klasse [TaxBusiness] ohne Änderung mit zwei verschiedenen Implementierungen der Schicht [dao] arbeiten.

6.4. Beispielanwendung – Version 5

Image

Diese neue Version baut auf der vorherigen auf und enthält folgende Änderungen:

  • Die Schichten [dao] und [business] werden jeweils in einem Maven-Modul abgelegt, das eine Bibliothek (eine JAR-Datei) erzeugt, und mit dem Unit-Test-Framework JUnit getestet;
  • Die Schicht [dao] enthält nun eine dritte Implementierung, [JsonTax], die Steuerstufen mit der Bibliothek Jackson aus einer JSON-Datei liest;
  • Die Integration der Schichten übernimmt der Dependency-Injection-Container von Spring, und die Implementierung der Schicht [dao] wird aus einer Konfigurationsdatei ausgewählt.

In großen Projekten arbeiten mehrere Entwickler an derselben Anwendung. Schichtenarchitekturen erleichtern diese Arbeitsweise: Da die Schichten über klar definierte Schnittstellen miteinander kommunizieren, muss sich ein Entwickler, der an einer Schicht arbeitet, nicht um die Arbeit anderer Entwickler an anderen Schichten kümmern. Es genügt, dass alle die Schnittstellen einhalten.

Um also die Schicht [business] zu testen, benötigt der Entwickler eine Implementierung der Schicht [dao]. Solange diese Implementierung nicht fertig ist, kann er eine Attrappe (Dummy) der Schicht [dao] verwenden, sofern sie die Schnittstelle [ITaxDao] einhält. Das ist ein weiterer Vorteil der Schichtenarchitektur: Eine Verzögerung bei der Schicht [dao] verhindert nicht, dass die Schicht [business] getestet wird. Die Mock-Implementierung hat außerdem den Vorteil, viel einfacher einzurichten zu sein als die echte Schicht [dao], die möglicherweise ein DBMS, Netzwerkverbindungen usw. erfordert.

Sobald die Schicht [dao] fertiggestellt und getestet ist, wird sie den Entwicklern der Schicht [business] als Bibliothek (eine in einem Maven-Repository veröffentlichte JAR-Datei) bereitgestellt und nicht als zu kopierender Quellcode. Letztlich wird die Anwendung als Hauptprogramm (das der Schicht [ui]) und Klassenbibliotheken (die anderen Schichten) ausgeliefert.

6.4.1. Das Maven-Projekt TaxV5

Version 5 ist ein Maven-Projekt mit mehreren Modulen: Ein übergeordnetes Projekt, das selbst nichts erzeugt, enthält drei Module, eines je Schicht. Die Tests bilden kein eigenes Projekt: Die Maven-Konvention legt die Tests eines Moduls in dessen Ordner [src/test/java] ab. Sie werden von Maven kompiliert und ausgeführt, sind aber nicht Teil der JAR-Datei des Moduls. Daraus ergibt sich die folgende Verzeichnisstruktur:

TaxV5/
  pom.xml                          parent project
  tax-dao/                         module: entities and [dao] layer (jar)
    pom.xml
    TaxData.txt
    TaxData.json
    TaxDataInvalid.txt             an incorrect brackets file, for the tests
    src/main/java/tax/entities/
      TaxBracket.java
      TaxException.java
    src/main/java/tax/dao/
      ITaxDao.java
      HardwiredTax.java
      FileTax.java
      JsonTax.java
    src/test/java/tax/dao/
      DaoTests.java                JUnit tests
      TrialDao.java                trial program
  tax-business/                    module: [business] layer (jar)
    pom.xml
    src/main/java/tax/business/
      ITaxBusiness.java
      TaxBusiness.java
    src/test/java/tax/business/
      BusinessTests.java           JUnit tests
      TrialBusiness.java           trial program
  tax-ui/                          module: [ui] layer and integration of the layers
    pom.xml
    tax.properties                 configuration files
    tax-json.properties
    tax-hardwired.properties
    tax-error.properties
    TaxData.txt
    TaxData.json
    src/main/java/tax/ui/
      Dialog.java
      Main.java
      TaxConfig.java
      MainConfig.java

Den Paketen wird nun [tax] vorangestellt: [tax.entities], [tax.dao], [tax.business], [tax.ui]. Die Module [tax-dao] und [tax-business] werden nämlich von anderen Projekten wiederverwendet (Kapitel 10 bis 13), und zwei Bibliotheken, die dasselbe Programm verwendet, dürfen nicht zwei Klassen mit demselben vollqualifizierten Namen definieren. In professionellen Projekten werden den Paketen die umgekehrten Domänennamen der Organisation vorangestellt ([org.springframework], [tools.jackson] …), was eindeutige Namen sicherstellt.

Die Datei [pom.xml] des übergeordneten Projekts sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<!-- Elternprojekt der Anwendung [Tax], Version 5: ein Maven-Modul pro Schicht -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.tax</groupId>
    <artifactId>tax-v5</artifactId>
    <version>5.0</version>
    <packaging>pom</packaging>

    <!-- die Module, in der Reihenfolge ihrer Abhängigkeiten -->
    <modules>
        <module>tax-dao</module>
        <module>tax-business</module>
        <module>tax-ui</module>
    </modules>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- die Versionen der Bibliotheken, allen Modulen gemeinsam -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-dao</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-business</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>tools.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>3.1.5</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>7.0.9</version>
            </dependency>
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter</artifactId>
                <version>6.0.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- JUnit für die Tests aller Module -->
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.15.0</version>
                    <configuration>
                        <!-- behält die Namen der Methodenparameter im kompilierten Code bei -->
                        <parameters>true</parameters>
                        <compilerArgs>
                            <arg>-Xlint:all</arg>
                        </compilerArgs>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>3.5.6</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.5.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
  • Zeilen 8–11: die Angaben des übergeordneten Projekts: Gruppe [examples.tax], Name [tax-v5], Version [5.0]. Der Packaging-Typ [pom] zeigt an, dass das Projekt keine JAR-Datei erzeugt: Es fasst lediglich Module zusammen und wendet eine gemeinsame Konfiguration auf sie an;
  • Zeilen 14–18: die Module, d. h. die Unterordner, von denen jeder ein Maven-Projekt enthält. Ein im Ordner [TaxV5] eingegebener Maven-Befehl gilt für alle Module, und zwar in der Reihenfolge, die ihre Abhängigkeiten vorgeben: [tax-dao], dann [tax-business], dann [tax-ui];
  • Zeilen 20–23: die Eigenschaften, die die Module erben: Java 25 und Quelldateien in UTF-8;
  • Zeilen 26–54: Der Abschnitt [dependencyManagement] legt die Versionen der Abhängigkeiten fest, ohne sie den Modulen hinzuzufügen. Ein Modul, das eine Abhängigkeit benötigt, deklariert sie ohne Version; so sind alle Versionen an einer einzigen Stelle gebündelt. Er umfasst die Anwendungsmodule selbst (Zeilen 28–37), Jackson 3 (Zeilen 38–42), den Spring-Container (Zeilen 43–47) und JUnit (Zeilen 48–52);
  • Zeilen 57–63: Der Abschnitt [dependencies] des übergeordneten Projekts fügt allen Modulen seine Abhängigkeiten hinzu: hier JUnit mit dem Gültigkeitsbereich (Scope) [test]. Eine Abhängigkeit mit dem Scope [test] wird nur zum Kompilieren und Ausführen von Tests verwendet: Sie ist nicht in den Abhängigkeiten der erzeugten Bibliothek enthalten;
  • Zeilen 66–91: Der Abschnitt [pluginManagement] legt entsprechend Version und Konfiguration der Maven-Plugins für alle Module fest: den Compiler (mit der Option [-Xlint:all], Zeilen 75–77), Surefire, das die Tests ausführt ([mvn test]), und exec, das ein Programm ausführt ([mvn exec:java]). Zeile 74 weist den Compiler an, die Namen der Methodenparameter im kompilierten Code zu erhalten: JUnit nutzt sie, um parametrisierte Tests anzuzeigen, wie wir sehen werden.

Die Anwendung wird mit dem folgenden Befehl erstellt, der im Ordner [TaxV5] eingegeben wird:

> mvn install

Für jedes Modul führt Maven die Phasen seines Lebenszyklus in folgender Reihenfolge aus: Kompilierung ([compile]), Kompilierung und Ausführung der Tests ([test]), Erzeugung der JAR-Datei im Ordner [target] des Moduls ([package]) und schließlich die Installation ([install]). Schlägt ein Test fehl, bricht der Build ab. Die Phase [install] kopiert die JAR-Datei und die Datei [pom.xml] jedes Moduls in das lokale Maven-Repository des Benutzers, den Ordner [~/.m2/repository]: Dort liegt zum Beispiel die Datei [examples/tax/tax-dao/5.0/tax-dao-5.0.jar]. Maven durchsucht dieses lokale Repository nach Abhängigkeiten, bevor es sie von Maven Central herunterlädt. Dieses lokale Repository erfüllt zwei Zwecke:

  • Ein Maven-Befehl, der im Ordner eines Moduls eingegeben wird, zum Beispiel [mvn exec:java] im Ordner [tax-ui], findet die Module, von denen dieses Modul abhängt, im lokalen Repository;
  • Die Anwendungen in den Kapiteln 10 bis 13 deklarieren in ihren Dateien [pom.xml] Abhängigkeiten von [examples.tax:tax-dao:5.0], [examples.tax:tax-business:5.0] und, für die Klasse [Dialog], von [examples.tax:tax-ui:5.0]: Sie verwenden so die Schichten aus Version 5 wieder, ohne den Quellcode zu kopieren, genau wie sie Jackson oder Spring verwenden würden.

Nach jeder Änderung an einem Modul müssen Sie daher [mvn install] erneut ausführen, damit die anderen Projekte die neue Version sehen. Die Option [-DskipTests] überspringt die Ausführung der Tests, und die Option [-q] („quiet“) beschränkt die Ausgabe von Maven auf Fehler.

Öffnen Sie in der IDE ein Projekt, das von diesen Modulen abhängt, bevor Version 5 installiert ist, sucht Maven sie vergeblich in Maven Central, und die IDE meldet nicht aufgelöste Abhängigkeiten, in IntelliJ IDEA zum Beispiel „Unresolved dependency: 'examples.tax:tax-dao:jar:5.0'“. Maven merkt sich diesen Fehlschlag: Es legt im Ordner jedes Moduls im lokalen Repository Dateien namens [*.lastUpdated] ab ([%USERPROFILE%\.m2\repository\examples\tax\tax-dao\5.0] usw.), und der Fehler kann nach dem Build mit [mvn install] weiter bestehen. Die Lösung:

  • Installieren Sie Version 5 ([mvn install] im Ordner [TaxV5] oder in IntelliJ über das Panel „Maven“ / [tax-v5] / „Lifecycle“ / [install]);
  • löschen Sie die Dateien [*.lastUpdated] in den Ordnern [tax-dao/5.0], [tax-business/5.0] und [tax-ui/5.0] des lokalen Repositorys, ohne die Dateien [.jar] und [.pom] anzutasten;
  • synchronisieren Sie die Projekte neu (über die Schaltfläche „Sync All Maven Projects“ im Panel „Maven“) und leeren Sie, falls der Fehler bestehen bleibt, die Caches von IntelliJ („File / Invalidate Caches… / Invalidate and Restart“).

Um festzustellen, ob das Problem von Maven oder von der IDE herrührt, geben Sie [mvn compile] im Projektordner ein, der von Version 5 abhängt: Antwortet Maven mit „BUILD SUCCESS“, sind die Abhängigkeiten korrekt, und nur die IDE muss neu synchronisiert werden.

6.4.2. Die [dao]-Schicht

Das Modul [tax-dao] enthält die Schicht [dao] und die Entitäten der Anwendung. Seine Datei [pom.xml] sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- das Elternprojekt liefert die gemeinsamen Versionen und die gemeinsame Konfiguration -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-dao</artifactId>

    <dependencies>
        <!-- Jackson zum Lesen der JSON-Datei -->
        <dependency>
            <groupId>tools.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
    </dependencies>

</project>
  • Zeilen 8–12: das übergeordnete Projekt. Das Modul erbt von ihm Gruppe und Version; nur sein Name wird angegeben (Zeile 14). Seine Koordinaten lauten daher [examples.tax:tax-dao:5.0];
  • Zeilen 18–21: die Abhängigkeit von Jackson, ohne Version: Diese wird vom übergeordneten Projekt bestimmt. JUnit wird vom übergeordneten Projekt geerbt.

Die Entitäten

Der Record [TaxBracket] entspricht dem aus Version 4 (Paket [tax.entities]). Die Enumeration [ErrorCode] entfällt: [TaxException] ist somit allen Implementierungen der Schicht [dao] gemeinsam, ohne an die Codes einer einzelnen von ihnen gebunden zu sein:

package tax.entities;

import java.io.Serial;

// die Exception der Anwendung [Tax], unabhängig von der Schicht, die sie auslöst
// sie leitet von RuntimeException ab: Es ist eine ungeprüfte Exception
public class TaxException extends RuntimeException {

    // Version der Klasse für die Serialisierung (eine Exception ist serialisierbar)
    @Serial
    private static final long serialVersionUID = 1L;

    // Fehlercode
    private final int code;

    // Konstruktoren
    public TaxException(String message) {
        this(message, null, 0);
    }

    public TaxException(String message, Throwable cause) {
        this(message, cause, 0);
    }

    public TaxException(String message, int code) {
        this(message, null, code);
    }

    public TaxException(String message, Throwable cause, int code) {
        super(message, cause);
        this.code = code;
    }

    // der Fehlercode
    public int getCode() {
        return code;
    }
}
  • Zeile 14: Der Fehlercode bleibt eine einfache Ganzzahl: Jede Implementierung der Schicht [dao] definiert ihre eigenen Codes;
  • Zeilen 17–32: vier Konstruktoren, mit oder ohne Ursache, mit oder ohne Code. Alle rufen den letzten auf. Ohne Code ist dieser 0.

Die [FileTax]-Implementierung

Die Schnittstelle [ITaxDao] und die Klasse [HardwiredTax] sind die aus Version 4. Die Klasse [FileTax] unterscheidet sich nur in der Schreibweise ihrer Fehlercodes:

// eine [dao]-Schicht, die die Steuerstufen aus einer Textdatei liest
// eine Zeile pro Stufe: limit:coeffR:coeffN (Dezimalpunkt)
public class FileTax implements ITaxDao {

    // für diese Implementierung spezifische Fehlercodes: Zweierpotenzen, die kombiniert werden können
    public static final int ACCESS = 1, LINE = 2, FIELD1 = 4, FIELD2 = 8, FIELD3 = 16;

    // Datendatei, relativ zum aktuellen Ordner
    private final String fileName;

    // Steuerstufen
    private final List<TaxBracket> taxBrackets;
  • Zeile 6: Die Fehlercodes, die sich zuvor in der Enumeration [ErrorCode] im Entitätenpaket befanden, sind zu Konstanten in der Klasse [FileTax] geworden: Es handelt sich nämlich um Codes, die für diese Implementierung der Schnittstelle [ITaxDao] spezifisch sind ([JsonTax] hat eigene). In Java ist eine Konstante ein Feld [static final], dessen Name üblicherweise in Großbuchstaben geschrieben wird. Mehrere Felder desselben Typs können in derselben Anweisung deklariert werden. Konstanten werden innerhalb der Klasse als [FIELD1] und außerhalb der Klasse als [FileTax.FIELD1] geschrieben. Die statischen Importe aus Version 4 sind nicht mehr nötig.

Weiter unten im Konstruktor:

                String[] fields = line.split("\\s*:\\s*");
                int code = 0;
                BigDecimal limit = null, coeffR = null, coeffN = null;
                if (fields.length != 3) {
                    code = LINE;
                } else {
                    // Umwandlungen der 3 Felder: Jeder Fehler fügt seinen Code hinzu
                    limit = parse(fields[0]);
                    coeffR = parse(fields[1]);
                    coeffN = parse(fields[2]);
                    if (limit == null) code |= FIELD1;
                    if (coeffR == null) code |= FIELD2;
                    if (coeffN == null) code |= FIELD3;
                }
                // Fehler?
                if (code != 0) {
                    throw new TaxException("Line no. " + lineNumber + " is incorrect: [" + line + "]", code);
                }
                // wir speichern die neue Steuerstufe
                brackets.add(new TaxBracket(limit, coeffR, coeffN));
            }
        } catch (IOException e) {
            // Dateizugriffsfehler: Er wird in eine TaxException verpackt
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS);
        }
  • Zeilen 4–14: Die Codes sind Ganzzahlen, die direkt mit dem Operator [|=] kombiniert werden;
  • Zeilen 17, 24: Die Fehler werden zusammen mit ihren Codes in eine [TaxException] verpackt.

Die [JsonTax]-Implementierung

Wie Version 3 aus Kapitel 5 liest die dritte Implementierung der Schicht [dao] die Steuerstufen mit der Bibliothek Jackson aus einer JSON-Datei. Die Datei [TaxData.json] sieht wie folgt aus:

1
2
3
4
5
6
7
8
9
[
  { "limit": 4962, "coeffR": 0, "coeffN": 0 },
  { "limit": 8382, "coeffR": 0.068, "coeffN": 291.09 },
  { "limit": 14753, "coeffR": 0.191, "coeffN": 1322.92 },
  { "limit": 23888, "coeffR": 0.283, "coeffN": 2668.39 },
  { "limit": 38868, "coeffR": 0.374, "coeffN": 4846.98 },
  { "limit": 47932, "coeffR": 0.426, "coeffN": 6883.66 },
  { "limit": 0, "coeffR": 0.481, "coeffN": 9505.54 }
]

Die Klasse [JsonTax] sieht wie folgt aus:

package tax.dao;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.util.List;
import tools.jackson.core.JacksonException;
import tools.jackson.databind.json.JsonMapper;

// eine [dao]-Schicht, die die Steuerstufen aus einer JSON-Datei liest
public class JsonTax implements ITaxDao {

    // für diese Implementierung spezifische Fehlercodes
    public static final int ACCESS = 1, FORMAT = 2;

    // Datendatei, relativ zum aktuellen Ordner
    private final String fileName;

    // Steuerstufen
    private final List<TaxBracket> taxBrackets;

    // Konstruktor
    public JsonTax(String fileName) {
        this.fileName = fileName;
        String json;
        try {
            Path path = Path.of(fileName);
            if (!Files.exists(path)) {
                throw new NoSuchFileException(fileName, null, "The file [" + fileName + "] does not exist");
            }
            json = Files.readString(path);
        } catch (IOException e) {
            throw new TaxException("Error while reading the file " + fileName, e, ACCESS);
        }
        try {
            // Deserialisierung des JSON-Arrays in ein Array von TaxBracket-Records
            TaxBracket[] brackets = JsonMapper.builder().build().readValue(json, TaxBracket[].class);
            if (brackets == null) {
                throw new TaxException("the file does not contain an array");
            }
            taxBrackets = List.of(brackets);
        } catch (JacksonException | TaxException e) {
            throw new TaxException("The file " + fileName
                    + " is not a valid JSON file of tax brackets", e, FORMAT);
        }
    }

    public String getFileName() {
        return fileName;
    }

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }
}
  • Zeile 17: Fehlercodes für diese Implementierung: Dateizugriffsfehler oder fehlerhafter Inhalt;
  • Zeilen 29–37: Die Datei wird mit [Files.readString] (Java 11) vollständig in eine Zeichenkette gelesen, mit derselben E/A-Fehlerbehandlung wie in [FileTax];
  • Zeile 40: Die JSON-Zeichenkette wird in ein Array [TaxBracket[]] umgewandelt. In Jackson 3, dessen Pakete mit [tools.jackson] beginnen, ist das [JsonMapper]-Objekt, das die Umwandlung durchführt, unveränderlich: Es wird mit Hilfe eines Zwischenobjekts, des „Builders“, erzeugt ([JsonMapper.builder()...build()]). Seine Methode [readValue] erhält den JSON-Text und die Klasse des zu erzeugenden Objekts, hier [TaxBracket[].class]. Jackson weiß, wie ein Record erzeugt wird: Es ordnet die JSON-Namen ([limit], [coeffR], [coeffN]) den Komponenten des Records zu und ruft dessen Konstruktor auf. Die Zahlen werden direkt in [BigDecimal], den Typ der Komponente, gelesen, ohne den Umweg über [double]: Sie sind daher exakt;
  • Zeilen 41–43: [readValue] liefert [null] , wenn die Datei das JSON-Literal [null] enthält; in diesem Fall wird eine Ausnahme ausgelöst;
  • Zeile 44: Das Array wird zu einer unveränderlichen Liste;
  • Zeilen 45–48: Eine Datei, die kein JSON-Array von Steuerstufen ist, löst eine [JacksonException] aus. In Jackson 3 ist diese Ausnahme von [RuntimeException] abgeleitet: Sie ist eine ungeprüfte Ausnahme. Der [catch]-Block fängt zwei Arten von Ausnahmen ab („Multi-Catch“, Java 7) und verpackt sie in eine [TaxException] vom Typ [FORMAT].

Ein Testprogramm

Bevor wir automatisierte Tests schreiben, führen wir einen ersten visuellen Test der Schicht [dao] durch. Das Programm [TrialDao] zeigt die Steuerstufen an, die von den drei Implementierungen geliefert werden. Wir haben es in den Test-Quellen des Moduls abgelegt ([src/test/java]): Es wird nicht in die JAR-Datei der Schicht [dao] aufgenommen:

package tax.dao;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.util.List;

// Testprogramm: die von den drei Implementierungen der [dao]-Schicht gelieferten Steuerstufen
public class TrialDao {

    public static void main(String[] args) {
        try {
            List<ITaxDao> daos = List.of(
                    new HardwiredTax(), new FileTax("TaxData.txt"), new JsonTax("TaxData.json"));
            for (ITaxDao dao : daos) {
                IO.println("--- " + dao.getClass().getSimpleName());
                for (TaxBracket bracket : dao.getTaxBrackets()) {
                    IO.println(bracket);
                }
            }
        } catch (TaxException e) {
            // Anzeige des Fehlers
            String origin = e.getCause() == null ? ""
                    : ", original exception: " + e.getCause().getMessage();
            IO.println("The following error occurred: [Code=" + e.getCode()
                    + ", Message=" + e.getMessage() + origin + "]");
        }
    }
}
  • Zeile 10: Die Methode [main]. Ab Java 25 müsste sie nicht mehr öffentlich sein und keine Programmargumente mehr annehmen; in Maven-Projekten behalten wir ihre klassische Form [public static void main(String[] args)] bei, die von allen Werkzeugen erkannt wird (Plugin [exec-maven-plugin], IDE);
  • Zeilen 12–13: eine Liste der drei Implementierungen der Schnittstelle [ITaxDao];
  • Zeile 15: [getClass()] liefert die tatsächliche Klasse des Objekts, deren Name (ohne Paket) [getSimpleName()] ist;
  • Zeile 17: [IO.println] zeigt die Steuerstufe mit ihrer Methode [toString] an, die der Compiler für einen Record erzeugt;
  • Zeilen 20–26: Behandelt eine mögliche [TaxException].

Das Programm läuft im Ordner [tax-dao]. Die Phase [test-compile] kompiliert den Hauptquellcode und den Testquellcode; der Parameter [exec.mainClass] gibt die auszuführende Klasse an, und [exec.classpathScope=test] weist das exec-Plugin an, die Testklassen und die Abhängigkeiten mit dem Scope [test] zu verwenden:

> mvn -q test-compile exec:java -Dexec.mainClass=tax.dao.TrialDao -Dexec.classpathScope=test
--- HardwiredTax
TaxBracket[limit=4962, coeffR=0, coeffN=0]
TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
TaxBracket[limit=14753, coeffR=0.191, coeffN=1322.92]
TaxBracket[limit=23888, coeffR=0.283, coeffN=2668.39]
TaxBracket[limit=38868, coeffR=0.374, coeffN=4846.98]
TaxBracket[limit=47932, coeffR=0.426, coeffN=6883.66]
TaxBracket[limit=0, coeffR=0.481, coeffN=9505.54]
--- FileTax
TaxBracket[limit=4962, coeffR=0, coeffN=0]
TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
TaxBracket[limit=14753, coeffR=0.191, coeffN=1322.92]
TaxBracket[limit=23888, coeffR=0.283, coeffN=2668.39]
TaxBracket[limit=38868, coeffR=0.374, coeffN=4846.98]
TaxBracket[limit=47932, coeffR=0.426, coeffN=6883.66]
TaxBracket[limit=0, coeffR=0.481, coeffN=9505.54]
--- JsonTax
TaxBracket[limit=4962, coeffR=0, coeffN=0]
TaxBracket[limit=8382, coeffR=0.068, coeffN=291.09]
TaxBracket[limit=14753, coeffR=0.191, coeffN=1322.92]
TaxBracket[limit=23888, coeffR=0.283, coeffN=2668.39]
TaxBracket[limit=38868, coeffR=0.374, coeffN=4846.98]
TaxBracket[limit=47932, coeffR=0.426, coeffN=6883.66]
TaxBracket[limit=0, coeffR=0.481, coeffN=9505.54]

Alle drei Implementierungen liefern dieselben Stufen. Die Methode [toString] eines [BigDecimal] schreibt unabhängig von der Sprache des Benutzers stets einen Dezimalpunkt.

6.4.3. Die [business]-Schicht

Die Datei [pom.xml] im Modul [tax-business] sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- das Elternprojekt liefert die gemeinsamen Versionen und die gemeinsame Konfiguration -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-business</artifactId>

    <dependencies>
        <!-- die [business]-Schicht verwendet die [dao]-Schicht -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-dao</artifactId>
        </dependency>
    </dependencies>

</project>
  • Zeilen 18–21: Die Schicht [business] verwendet die Schicht [dao]. Im Ordner [TaxV5] baut Maven [tax-dao] vor [tax-business]; im Ordner [tax-business] findet es [tax-dao] im lokalen Repository, wo [mvn install] es abgelegt hat. Abhängigkeiten sind transitiv: Das Modul erhält auch Jackson, von dem [tax-dao] abhängt.

Die Schnittstelle [ITaxBusiness] und die Klasse [TaxBusiness] sind die aus Version 4 (Paket [tax.business]). Das Testprogramm [TrialBusiness], das sich in den Test-Quellen des Moduls befindet, führt einige Steuerberechnungen durch:

package tax.business;

import tax.dao.FileTax;
import tax.entities.TaxException;

// Testprogramm: einige Steuerberechnungen mit der [dao]-Schicht FileTax
public class TrialBusiness {

    public static void main(String[] args) {
        try {
            // die Stufendatei ist die des Moduls tax-dao (Pfad relativ zum aktuellen Ordner)
            ITaxBusiness business = new TaxBusiness(new FileTax("../tax-dao/TaxData.txt"));
            IO.println("Tax(true,2,60000)=" + business.calculateTax(true, 2, 60000) + " euros");
            IO.println("Tax(false,3,60000)=" + business.calculateTax(false, 3, 60000) + " euros");
            IO.println("Tax(false,3,6000)=" + business.calculateTax(false, 3, 6000) + " euros");
            IO.println("Tax(false,3,600000)=" + business.calculateTax(false, 3, 600000) + " euros");
        } catch (TaxException e) {
            // Anzeige des Fehlers
            String origin = e.getCause() == null ? ""
                    : ", original exception: " + e.getCause().getMessage();
            IO.println("The following error occurred: [Code=" + e.getCode()
                    + ", Message=" + e.getMessage() + origin + "]");
        }
    }
}
  • Zeile 12: Erzeugung der Schichten [dao] und [business]. Die Schicht [dao] wird durch die Klasse [FileTax] implementiert. Da das Programm im Ordner [tax-business] läuft, verweist der relative Pfad [../tax-dao/TaxData.txt] auf die Datendatei des Moduls [tax-dao];
  • Zeilen 13–16: wiederholte Aufrufe der einzigen Methode der Schnittstelle [ITaxBusiness].

Ergebnisse im Ordner [tax-business]:

1
2
3
4
5
> mvn -q test-compile exec:java -Dexec.mainClass=tax.business.TrialBusiness -Dexec.classpathScope=test
Tax(true,2,60000)=4282 euros
Tax(false,3,60000)=4282 euros
Tax(false,3,6000)=0 euros
Tax(false,3,600000)=179275 euros

Ein Ehepaar mit 2 Kindern und eine alleinstehende Person mit 3 Kindern haben dieselbe Anzahl von Anteilen (3): Ihre Steuern sind gleich.

6.4.4. Unit-Tests mit JUnit

6.4.4.1. Das Prinzip

Die bisherigen Tests beruhten auf visueller Kontrolle: Wir haben geprüft, ob der Bildschirm die erwarteten Ergebnisse anzeigt. Dieses Vorgehen ist bei vielen Tests unpraktisch: Menschen ermüden, und ihre Fähigkeit, Ergebnisse zu prüfen, lässt im Laufe des Tages nach. Die Tests müssen daher automatisiert sein und ohne menschliches Eingreifen ablaufen.

Eine Anwendung entwickelt sich im Laufe der Zeit weiter. Bei jeder Änderung muss überprüft werden, dass sie sich nicht „zurückentwickelt“, das heißt, dass sie weiterhin die Funktionstests besteht, die bei ihrer ursprünglichen Entwicklung durchgeführt wurden. Diese Tests heißen Regressionstests. Eine mittelgroße Anwendung kann Hunderte von Tests erfordern: Tatsächlich wird jede Methode jeder Klasse der Anwendung getestet. Man spricht dann von Unit-Tests.

Zur Automatisierung dieser Tests wurden Frameworks entwickelt. In Java ist das führende Framework JUnit, das Ende der 1990er-Jahre von Kent Beck und Erich Gamma geschaffen wurde. Wir verwenden Version 6, die Ende 2025 erschienen ist (hier Version 6.0.3); ihre API, die im Paket [org.junit.jupiter.api] enthaltene, ist Version 5 von JUnit, auch JUnit Jupiter genannt (TestNG ist ein weiteres Framework nach demselben Prinzip). Die Tests werden mit dem Befehl [mvn test] von der Kommandozeile aus ausgeführt: So lassen sie sich automatisch starten, zum Beispiel bei jeder Übertragung von Codeänderungen an einen Continuous-Integration-Server. Auch die IDEs (IntelliJ IDEA, VS Code mit dem Extension Pack for Java) führen diese Tests aus und zeigen ihre Ergebnisse in einer Baumstruktur an.

6.4.4.2. Ein erstes Beispiel

Betrachten wir das Prinzip der JUnit-Tests anhand eines Beispiels. Das Maven-Projekt [DemoTests] enthält nur Tests, die im Ordner [src/test/java/demotests] liegen. Seine Datei [pom.xml] sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.architectures</groupId>
    <artifactId>demo-tests</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- JUnit Jupiter: die Test-API und die Engine, die die Tests ausführt -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>6.0.3</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <parameters>true</parameters>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn test: Das Surefire-Plugin führt die Tests aus -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
        </plugins>
    </build>
</project>
  • Zeilen 18–23: Das Projekt verwendet das Artefakt [junit-jupiter], das die Test-API (die Annotationen und die Klasse [Assertions]), die Unterstützung für parametrisierte Tests und die Engine enthält, die die Tests findet und ausführt. Sein Scope ist [test];
  • Zeile 33: Der Compiler behält die Namen der Methodenparameter bei, die JUnit für parametrisierte Tests anzeigt;
  • Zeilen 40–44: das Surefire-Plugin, das die Tests in der Phase [test] von Maven ausführt.

Die Testklasse [Tests1] sieht wie folgt aus:

package demotests;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

// eine Testklasse
class Tests1 {

    // die getestete Methode
    private static int sum(int a, int b) {
        return a + b;
    }

    // Konstruktor
    Tests1() {
        IO.println("constructor");
    }

    // wird vor jedem Test ausgeführt
    @BeforeEach
    void before() {
        IO.println("before");
    }

    // wird nach jedem Test ausgeführt
    @AfterEach
    void after() {
        IO.println("after");
    }

    // ein Test, der erfolgreich ist
    @Test
    void t1() {
        IO.println("test1");
        assertEquals(4, sum(2, 2));
    }

    // ein Test, der fehlschlägt
    @Test
    void t2() {
        IO.println("test2");
        assertEquals(5, sum(2, 2), "2 + 2 is not equal to 5");
    }
}
  • Zeile 3: Die Prüfmethoden, die Assertions, sind statische Methoden der Klasse [Assertions]. Sie werden per statischem Import importiert, sodass wir [assertEquals(...)] statt [Assertions.assertEquals(...)] schreiben können;
  • Zeile 10: Eine Testklasse ist eine gewöhnliche Klasse ohne Annotationen. Weder sie noch ihre Methoden müssen public sein: Paketsichtbarkeit genügt;
  • Zeilen 13–15: die zu testende Methode. In einem realen Projekt befände sie sich im Hauptquellcode des Projekts ([src/main/java]);
  • Zeilen 18–20: der Konstruktor. Er dient nur dazu, eine Meldung auf dem Bildschirm auszugeben: Wir möchten sehen, wann er ausgeführt wird;
  • Zeile 23: Die Annotation [@BeforeEach] kennzeichnet eine Methode, die vor jedem Test ausgeführt wird;
  • Zeile 29: Die Annotation [@AfterEach] kennzeichnet eine Methode, die nach jedem Test ausgeführt wird;
  • Zeile 35: Die Annotation [@Test] kennzeichnet eine Testmethode. Eine Testmethode gibt nichts zurück, ist nicht private und hat – bis auf eine Ausnahme, die wir noch besprechen – keine Parameter;
  • Zeile 38: Die Methode [assertEquals(expected, actual)] prüft, ob der erhaltene Wert dem erwarteten Wert entspricht. Ist das nicht der Fall, löst sie eine Exception vom Typ [AssertionFailedError] aus und der Test schlägt fehl. Hier muss die Zusicherung erfüllt sein;
  • Zeile 45: Diese Zusicherung muss fehlschlagen. Der dritte Parameter ist die Meldung, die im Fehlerfall angezeigt wird: In JUnit ist die Meldung bei den Zusicherungen immer der letzte Parameter.

Wir führen die Tests mit dem Befehl [mvn test] im Projektordner aus. Unten sehen Sie einen Screenshot des JUnit-Konsolenstarters, der die Tests als Baumstruktur anzeigt; [mvn test] führt dieselben Tests aus, und die IDE zeigt denselben Baum an. Den Aufrufstapel haben wir gekürzt (Zeilen [...]):

> mvn test
constructor
before
test1
after
constructor
before
test2
after
╷
└─ JUnit Jupiter ✔
   ├─ Tests2 ✔
   │  ├─ t3() ✔
   │  ├─ t4() ✔
   │  ├─ t5() ✔
   │  ├─ t6() ✔
   │  ├─ t7(int, int, int) ✔
   │  │  ├─ [1] a=1, b=1, sum=2 ✔
   │  │  ├─ [2] a=2, b=3, sum=5 ✔
   │  │  └─ [3] a=-1, b=1, sum=0 ✔
   │  └─ t8(int) ✔
   │     ├─ [1] n=2 ✔
   │     ├─ [2] n=4 ✔
   │     └─ [3] n=6 ✔
   └─ Tests1 ✔
      ├─ t1() ✔
      └─ t2() ✘ 2 + 2 is not equal to 5 ==> expected: <5> but was: <4>

Failures (1):
  JUnit Jupiter:Tests1:t2()
    MethodSource [className = 'demotests.Tests1', methodName = 't2', methodParameterTypes = '']
    => org.opentest4j.AssertionFailedError: 2 + 2 is not equal to 5 ==> expected: <5> but was: <4>
...
       demotests.Tests1.t2(Tests1.java:45)
...
Test run finished after 1350 ms
...
[        12 tests found           ]
[         0 tests skipped         ]
[        12 tests started         ]
[         0 tests aborted         ]
[        11 tests successful      ]
[         1 tests failed          ]
  • Zeilen 2–5: die Ausgabe des Tests [t1]: Zuerst wurde der Konstruktor ausgeführt, danach die Methode [before], der Test und schließlich die Methode [after]. Der Konsolenstarter zeigt die Testausgabe während der Ausführung an, noch vor dem zusammenfassenden Baum;
  • Zeilen 6–9: Ausgabe für den Test [t2]. Beachten Sie, dass der Konstruktor erneut ausgeführt wurde: JUnit erzeugt für jeden Test eine neue Instanz der Testklasse. Die Tests sind somit voneinander unabhängig: Ein Test kann nicht durch den Zustand beeinflusst werden, den ein anderer Test hinterlassen hat (die Annotation [@TestInstance(Lifecycle.PER_CLASS)] verlangt dagegen eine einzige Instanz für alle Tests der Klasse);
  • Zeilen 11–27: der Testbaum: die JUnit-Jupiter-Engine, die Testklassen und dann deren Tests. Das Symbol ✔ steht für einen bestandenen, das Symbol ✘ für einen fehlgeschlagenen Test. Die Tests der Klasse [Tests2], die weiter unten gezeigt wird, wurden alle bestanden; JUnit hat sie vor denen der Klasse [Tests1] ausgeführt. Die Ausführungsreihenfolge von Klassen und Methoden ist reproduzierbar, aber bewusst nicht offensichtlich: Tests dürfen nicht von ihrer Ausführungsreihenfolge abhängen;
  • Zeile 27: Der Test [t2] ist fehlgeschlagen. Die Fehlermeldung enthält die an [assertEquals] übergebene Meldung, den erwarteten und den tatsächlichen Wert. Die Meldungen von JUnit sind auf Englisch;
  • Zeilen 29–34: Details zum Fehler: die von der Zusicherung ausgelöste Exception [AssertionFailedError] und der Aufrufstapel zum Zeitpunkt des Fehlers, der auf die fehlerhafte Zeile verweist, nämlich Zeile 45 der Datei [Tests1.java];
  • Zeilen 38–43: die Zusammenfassung: 12 Tests, von denen 11 bestanden wurden und 1 fehlschlug. Der Befehl [mvn test] endet dann mit einem Build-Fehler („BUILD FAILURE“) und einem Exit-Code ungleich null, sodass ein Skript den Fehlschlag erkennen kann.

Um nur eine Teilmenge der Tests auszuführen, verwenden Sie den Parameter [test] des Surefire-Plugins: [mvn test -Dtest=Tests2] führt nur die Tests der Klasse [Tests2] aus, während [mvn test -Dtest=Tests1#t1] nur den Test [t1] ausführt. Beachten Sie schließlich die Annotationen [@BeforeAll] und [@AfterAll], die statische Methoden kennzeichnen, die nur einmal ausgeführt werden – vor dem ersten und nach dem letzten Test der Klasse –, sowie die Annotation [@DisplayName], die einem Test einen aussagekräftigeren Namen gibt als den seiner Methode. Standardmäßig führt JUnit die Tests nacheinander aus; eine parallele Ausführung lässt sich in einer Konfigurationsdatei [junit-platform.properties] anfordern.

6.4.4.3. Weitere Zusicherungen

Die Klasse [Assertions] besitzt viele Methoden. Die Klasse [Tests2] stellt einige davon vor:

package demotests;

import static org.junit.jupiter.api.Assertions.assertAll;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertIterableEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;

// einige weitere JUnit-Assertions
class Tests2 {

    // Wahrheitswerte, null, Referenzen
    @Test
    void t3() {
        boolean isTrue = 1 < 2, isFalse = 1 > 2;
        assertTrue(isTrue);
        assertFalse(isFalse);
        Object obj1 = new Object(), obj2 = null, obj3 = obj1;
        assertNotNull(obj1);
        assertNull(obj2);
        assertSame(obj1, obj3);
        assertNotSame(obj1, new Object());
    }

    // reelle Zahlen: Gleichheit innerhalb eines Deltas
    @Test
    void t4() {
        double d1 = 0.1 + 0.2, d2 = 0.3;
        assertNotEquals(d2, d1);
        assertEquals(d2, d1, 1e-6);
    }

    // Zeichenketten und Collections: Alle Assertions werden geprüft, auch wenn eine davon fehlschlägt
    @Test
    void t5() {
        String message = "Line no. 3 is incorrect";
        List<Integer> numbers = List.of(1, 2, 3);
        assertAll(
                () -> assertTrue(message.startsWith("Line")),
                () -> assertTrue(message.contains("incorrect")),
                () -> assertEquals(3, numbers.size()),
                () -> assertTrue(numbers.contains(2)),
                () -> assertIterableEquals(List.of(1, 2, 3), numbers));
    }

    // Exceptions: Der Test ist erfolgreich, wenn die erwartete Exception ausgelöst wird
    @Test
    void t6() {
        List<Integer> numbers = List.of(1, 2, 3);
        assertThrows(IndexOutOfBoundsException.class, () -> numbers.get(3));
        NumberFormatException e =
                assertThrowsExactly(NumberFormatException.class, () -> Integer.parseInt("x"));
        assertNotNull(e.getMessage());
    }

    // ein parametrisierter Test: eine Ausführung pro Wertezeile
    @ParameterizedTest
    @CsvSource({"1, 1, 2", "2, 3, 5", "-1, 1, 0"})
    void t7(int a, int b, int sum) {
        assertEquals(sum, a + b);
    }

    // ein parametrisierter Test mit einem einzigen Parameter: eine Ausführung pro Wert
    @ParameterizedTest
    @ValueSource(ints = {2, 4, 6})
    void t8(int n) {
        assertEquals(0, n % 2);
    }
}
  • Zeilen 29–30: prüfen, ob ein boolescher Ausdruck wahr oder falsch ist;
  • Zeilen 32–33: prüfen, ob eine Referenz nicht null oder null ist;
  • Zeilen 34–35: prüfen, ob zwei Referenzen auf dasselbe Objekt verweisen;
  • Zeilen 41–43: Berechnungen mit den reellen Zahlen vom Typ [double] sind näherungsweise: [0.1 + 0.2] ist nicht exakt gleich [0.3]. Wir vergleichen daher zwei reelle Zahlen mit einer gewissen Fehlertoleranz, hier einem Millionstel;
  • Zeilen 51–56: JUnit hat keine speziellen Zusicherungen für Zeichenketten: Wir verwenden [assertTrue], um das Ergebnis der Methoden [startsWith] oder [contains] zu überprüfen. [assertIterableEquals] prüft, ob zwei Collections dieselben Elemente in derselben Reihenfolge enthalten. Diese Zusicherungen werden mit [assertAll] gebündelt, das Lambda-Ausdrücke [() -> ...] entgegennimmt (Kapitel 7): Alle Zusicherungen werden ausgeführt, auch wenn eine davon fehlschlägt, und die Fehler werden gemeinsam gemeldet. Ohne [assertAll] beendet der erste Fehler den Test. Die Bibliothek AssertJ, die oft zusammen mit JUnit verwendet wird, bietet ausgefeiltere Zusicherungen, die in der Form [assertThat(message).startsWith("Line")] geschrieben werden;
  • Zeilen 63–65: [assertThrows(Type.class, action)] führt die Aktion – einen Lambda-Ausdruck – aus und prüft, ob sie eine Exception vom Typ [Type] oder eines abgeleiteten Typs auslöst. Hier löst die Methode [get] der mit [List.of] erzeugten Liste eine [ArrayIndexOutOfBoundsException] aus, eine von [IndexOutOfBoundsException] abgeleitete Klasse: Die Zusicherung ist erfüllt. [assertThrowsExactly], verlangt dagegen eine Exception genau vom Typ [Type]. Beide Methoden geben die ausgelöste Exception zurück, sodass sich anschließend ihre Eigenschaften überprüfen lassen (Zeile 66);
  • Zeilen 70–74: ein parametrisierter Test. Die Annotation [@ParameterizedTest] ersetzt [@Test]; die Methode hat Parameter, und die Annotation [@CsvSource] liefert Wertesätze, je eine Zeichenkette pro Satz, wobei die Werte durch Kommas getrennt sind. JUnit konvertiert sie in den Typ der Parameter. Der Test wird einmal pro Wertesatz ausgeführt: Das zeigen die Zeilen 18–20 der vorherigen Ergebnisse;
  • Zeilen 77–81: Für einen Test mit einem einzigen Parameter liefert die Annotation [@ValueSource] direkt die Liste der Werte ([ints], [strings], [doubles] …).

Fassen wir die wichtigsten Methoden der Klasse [Assertions] zusammen:

Methode
Prüft, dass
[assertEquals(expected, actual)]
die beiden Werte gleich sind (Methode [equals])
[assertEquals(real1, real2, delta)]
die beiden reellen Zahlen bis auf ein Delta gleich sind
[assertNotEquals(v1, v2)]
die beiden Werte verschieden sind
[assertSame(o1, o2)], [assertNotSame(o1, o2)]
die beiden Referenzen auf dasselbe Objekt verweisen (bzw. nicht)
[assertNull(o)], [assertNotNull(o)]
die Referenz null ist (bzw. nicht)
[assertTrue(b)], [assertFalse(b)]
der boolesche Ausdruck wahr (bzw. falsch) ist
[assertInstanceOf(Type.class, o)]
das Objekt vom Typ [Type] oder von einem abgeleiteten Typ ist
[assertArrayEquals(t1, t2)]
beide Arrays dieselben Elemente in derselben Reihenfolge enthalten
[assertIterableEquals(c1, c2)]
beide Collections dieselben Elemente in derselben Reihenfolge enthalten
[assertAll(action1, action2, ...)]
alle Zusicherungen der Aktionen erfüllt sind (Fehler werden gemeinsam gemeldet)
[assertThrows(Type.class, action)]
die Aktion eine Exception vom Typ [Type] oder von einem abgeleiteten Typ auslöst
[assertThrowsExactly(Type.class, action)]
die Aktion eine Exception genau vom Typ [Type] auslöst
[fail(message)]
(schlägt immer fehl)

Alle diese Methoden akzeptieren einen optionalen letzten Parameter: die Meldung, die im Fehlerfall angezeigt wird.

6.4.4.4. Die [dao]-Schicht testen

Kehren wir zur Anwendung [Tax] zurück. Die Klasse [DaoTests], die die Schicht [dao] testet, befindet sich im Ordner [src/test/java/tax/dao] des Moduls [tax-dao]. Sie gehört demselben Paket an wie die getesteten Klassen, was ihr Zugriff auf deren paketsichtbare Member gibt. Die Datei [pom.xml] des Moduls muss nicht geändert werden: JUnit wird vom übergeordneten Projekt geerbt. Die fehlerhafte Datendatei [TaxDataInvalid.txt] liegt im Ordner des Moduls: Dies ist während der Testausführung das aktuelle Verzeichnis.

package tax.dao;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.jupiter.api.Assertions.assertTrue;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.math.BigDecimal;
import java.nio.file.NoSuchFileException;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

// Tests der [dao]-Schicht
class DaoTests {

    // Factory einer [dao]-Schicht aus dem Namen ihrer Klasse
    private static ITaxDao createDao(String implementation) {
        return switch (implementation) {
            case "HardwiredTax" -> new HardwiredTax();
            case "FileTax" -> new FileTax("TaxData.txt");
            case "JsonTax" -> new JsonTax("TaxData.json");
            default -> throw new IllegalArgumentException("unknown implementation: " + implementation);
        };
    }

    // derselbe Test für die drei Implementierungen
    @ParameterizedTest
    @ValueSource(strings = {"HardwiredTax", "FileTax", "JsonTax"})
    void taxBrackets(String implementation) {
        List<TaxBracket> brackets = createDao(implementation).getTaxBrackets();
        // einige Prüfungen: compareTo ignoriert die Skalierung von BigDecimal (0.191 und 0.1910 sind gleich)
        assertEquals(7, brackets.size());
        assertEquals(0, new BigDecimal("14753").compareTo(brackets.get(2).limit()));
        assertEquals(0, new BigDecimal("0.191").compareTo(brackets.get(2).coeffR()));
        assertEquals(0, new BigDecimal("1322.92").compareTo(brackets.get(2).coeffN()));
    }

    // die drei Implementierungen liefern dieselben Stufen
    @Test
    void sameBrackets() {
        List<TaxBracket> reference = new HardwiredTax().getTaxBrackets();
        assertEquals(reference, new FileTax("TaxData.txt").getTaxBrackets());
        assertEquals(reference, new JsonTax("TaxData.json").getTaxBrackets());
    }

    // fehlende Datei
    @Test
    void missingFile() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new FileTax("TaxDataMissing.txt"));
        assertEquals(FileTax.ACCESS, e.getCode());
        assertInstanceOf(NoSuchFileException.class, e.getCause());
    }

    // Datei, deren Zeile 3 fehlerhaft ist (Dezimalkommas)
    @Test
    void incorrectLine() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new FileTax("TaxDataInvalid.txt"));
        assertEquals(FileTax.FIELD2 | FileTax.FIELD3, e.getCode());
        assertTrue(e.getMessage().startsWith("Line no. 3"));
    }

    // fehlende JSON-Datei
    @Test
    void missingJsonFile() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new JsonTax("TaxDataMissing.json"));
        assertEquals(JsonTax.ACCESS, e.getCode());
    }
}
  • Zeilen 21–28: eine Methode, die anhand ihres Klassennamens eine Schicht namens [dao] erzeugt, und zwar mit einem Ausdruck [switch] (Java 14): Jeder [case] liefert nach dem Pfeil [->] den Wert des Ausdrucks;
  • Zeilen 31–40: Derselbe Test wird mithilfe der Annotation [@ValueSource] für alle drei Implementierungen durchgeführt. Er prüft, dass es 7 Steuerstufen gibt, und kontrolliert den Wert der Stufe Nr. 2 (der dritten). Die Werte vom Typ [BigDecimal] werden mit [compareTo] statt mit [equals] verglichen: Die Methode [equals] eines [BigDecimal] berücksichtigt die Anzahl der geschriebenen Nachkommastellen (seine Skalierung, „scale“) und behandelt 0.191 und 0.1910 als verschieden, während [compareTo] nur die Werte vergleicht;
  • Zeilen 44–48: Alle drei Implementierungen liefern exakt dieselben Bereiche. [assertEquals] vergleicht die Listen mit deren eigener Methode [equals], die die Elemente einzeln vergleicht; die vom Compiler generierte Methode [equals] eines Records vergleicht dessen Komponenten. Der Vergleich gelingt, weil alle drei Quellen die Zahlen auf dieselbe Weise schreiben;
  • Zeilen 52–57: Eine fehlende Datei löst eine [TaxException] mit dem Code [ACCESS] aus, die eine [NoSuchFileException] kapselt. [assertInstanceOf] prüft den Typ der Ursache;
  • Zeilen 61–66: Die Datei [TaxDataInvalid.txt] löst eine [TaxException] aus, deren Code die Bits von [FIELD2] and [FIELD3] kombiniert und deren Meldung mit „Line no. 3“ beginnt;
  • Zeilen 70–74: dieselbe Überprüfung für die Implementierung [JsonTax].

6.4.4.5. Tests für die [business]-Schicht

Die Klasse [BusinessTests] im Modul [tax-business] testet die Schicht [business]:

package tax.business;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;

import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.entities.TaxBracket;
import java.math.BigDecimal;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

// Tests der [business]-Schicht
class BusinessTests {

    // die [dao]-Schicht und die getestete [business]-Schicht: JUnit erzeugt pro Test eine Instanz der Klasse
    private final HardwiredTax dao = new HardwiredTax();
    private final ITaxBusiness business = new TaxBusiness(dao);

    // Berechnungen mit bekanntem Ergebnis
    @ParameterizedTest
    @CsvSource({
        "true, 2, 60000, 4282",
        "false, 3, 60000, 4282",
        "true, 3, 60000, 2959",
        "false, 0, 60000, 11519",
        "false, 3, 6000, 0",
        "false, 3, 600000, 179275"
    })
    void calculateTax(boolean married, int nbChildren, int salary, int tax) {
        assertEquals(tax, business.calculateTax(married, nbChildren, salary));
    }

    // die Berechnung verändert die von der [dao]-Schicht gelieferten Stufen nicht
    @Test
    void unchangedBrackets() {
        List<TaxBracket> before = List.copyOf(dao.getTaxBrackets());
        business.calculateTax(true, 2, 600000);
        assertEquals(before, dao.getTaxBrackets());
    }

    // negative Parameter werden abgelehnt
    @Test
    void negativeParameters() {
        assertThrowsExactly(IllegalArgumentException.class, () -> business.calculateTax(true, -1, 60000));
        assertThrowsExactly(IllegalArgumentException.class, () -> business.calculateTax(true, 2, -60000));
    }

    // die [business]-Schicht, getestet mit einer Fake-[dao]-Schicht: eine einzige Stufe, eine Steuer von 10 %
    // ITaxDao hat nur eine Methode: Ein Lambda-Ausdruck genügt, um sie zu implementieren
    @Test
    void withFakeDao() {
        ITaxDao fakeDao =
                () -> List.of(new TaxBracket(BigDecimal.ZERO, new BigDecimal("0.1"), BigDecimal.ZERO));
        ITaxBusiness fakeBusiness = new TaxBusiness(fakeDao);
        // zu versteuerndes Einkommen = 0.72 x 100000 = 72000; Steuer = 10 % von 72000
        assertEquals(7200, fakeBusiness.calculateTax(false, 0, 100000));
    }
}
  • Zeilen 19–20: Die getestete Schicht [business] baut auf der [dao]-Schicht [HardwiredTax] auf, die von keinen Dateien abhängen. Die Felder werden bei der Erzeugung des Objekts initialisiert; da JUnit für jeden Test eine neue Instanz der Klasse erzeugt, hat jeder Test brandneue Schichten;
  • Zeilen 23–34: Berechnungen, deren Ergebnisse bekannt sind und die von [@CsvSource] geliefert werden. Dies sind die Kontrollwerte der Anwendung, die bereits mit früheren Versionen ermittelt wurden: Sie müssen in allen künftigen Versionen korrekt bleiben. Die Zeichenketten [true] und [false] werden in [boolean] konvertiert;
  • Zeilen 38–42: Die Steuerberechnung verändert die von der Schicht [dao] gelieferten Steuerstufen nicht. Die Steuerstufen werden vor einer Berechnung gespeichert, die die letzte Stufe verwendet, und anschließend verglichen. Da die Liste bereits schreibgeschützt ist, [List.copyOf] gibt dieselbe Liste zurück, und jeder Versuch, sie über die Schicht [business] zu verändern, würde eine [UnsupportedOperationException] auslösen, die den Test ebenfalls scheitern ließe. Der Test hält den oben beschriebenen früheren Fehler fest: Würde ihn jemand wieder einführen, würde dieser Test ihn melden;
  • Zeilen 46–49: negative Parameter werden abgelehnt;
  • Zeilen 55–56: eine Attrappen-Schicht [dao], wie sie der Entwickler der Schicht [business] verwenden würde, bevor die eigentliche Schicht [dao] fertig ist: eine einzige Steuerstufe, eine Steuer von 10 % auf das zu versteuernde Einkommen. Da die Schnittstelle [ITaxDao] nur eine abstrakte Methode hat, ist sie eine funktionale Schnittstelle: Ein Lambda-Ausdruck genügt, um sie zu implementieren, ohne eine Klasse zu schreiben. Lambda-Ausdrücke werden in Kapitel 7 behandelt;
  • Zeilen 57–59: Die Schicht [business] arbeitet mit der Attrappen-Schicht [dao]. Die Schicht [business] wird so unabhängig von den tatsächlichen Implementierungen der Schicht [dao] für sich getestet.

6.4.4.6. Die Tests ausführen

Der Befehl [mvn test] führt im Ordner [TaxV5] eingegeben die Tests aller Module aus; im Ordner eines Moduls eingegeben, führt er nur die Tests dieses Moduls aus. Hier ist der Testbaum für das Modul [tax-dao] (wir haben nur die Testergebnisse aufgenommen):

> mvn -q test
╷
└─ JUnit Jupiter ✔
   └─ DaoTests ✔
      ├─ taxBrackets(String) ✔
      │  ├─ [1] implementation=HardwiredTax ✔
      │  ├─ [2] implementation=FileTax ✔
      │  └─ [3] implementation=JsonTax ✔
      ├─ missingJsonFile() ✔
      ├─ missingFile() ✔
      ├─ sameBrackets() ✔
      └─ incorrectLine() ✔
...
[         7 tests found           ]
[         0 tests skipped         ]
[         7 tests started         ]
[         0 tests aborted         ]
[         7 tests successful      ]
[         0 tests failed          ]

und der Testbaum für das Modul [tax-business]:

> mvn -q test
╷
└─ JUnit Jupiter ✔
   └─ BusinessTests ✔
      ├─ withFakeDao() ✔
      ├─ negativeParameters() ✔
      ├─ unchangedBrackets() ✔
      └─ calculateTax(boolean, int, int, int) ✔
         ├─ [1] married=true, nbChildren=2, salary=60000, tax=4282 ✔
         ├─ [2] married=false, nbChildren=3, salary=60000, tax=4282 ✔
         ├─ [3] married=true, nbChildren=3, salary=60000, tax=2959 ✔
         ├─ [4] married=false, nbChildren=0, salary=60000, tax=11519 ✔
         ├─ [5] married=false, nbChildren=3, salary=6000, tax=0 ✔
         └─ [6] married=false, nbChildren=3, salary=600000, tax=179275 ✔
...
[         9 tests found           ]
[         0 tests skipped         ]
[         9 tests started         ]
[         0 tests aborted         ]
[         9 tests successful      ]
[         0 tests failed          ]

Alle 16 Tests wurden bestanden: Jeder Wertesatz eines parametrisierten Tests zählt als ein Test, und JUnit zeigt sie zusammen mit den Namen und Werten ihrer Parameter an (diese Namen sind über die Compiler-Option [parameters] verfügbar). Wir betrachten die Schichten [dao] und [business] nun als funktionsfähig. Die von [mvn package] oder [mvn install] erzeugten JAR-Dateien enthalten nur den Code der Schichten: Die Testklassen, die im Ordner [target/test-classes] kompiliert werden, sind nicht enthalten. Beachten Sie schließlich, dass [mvn install] die Tests vor der Installation der Module ausführt: Eine Regression verhindert die Installation einer neuen Version der Schichten.

6.4.5. Die [ui]-Schicht

Die Datei [pom.xml] des Moduls [tax-ui] sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- das Elternprojekt liefert die gemeinsamen Versionen und die gemeinsame Konfiguration -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v5</artifactId>
        <version>5.0</version>
    </parent>

    <artifactId>tax-ui</artifactId>

    <dependencies>
        <!-- die [ui]-Schicht verwendet die beiden anderen Schichten -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
        </dependency>
        <!-- der Spring-Container für Dependency Injection -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- mvn exec:java führt die Hauptklasse aus -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>tax.ui.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • Zeilen 18–21: Die Schicht [ui] verwendet die Schicht [business] und, transitiv, die Schicht [dao];
  • Zeilen 23–26: der Spring-Container für Dependency Injection, das Artefakt [spring-context], das die weiteren benötigten Spring-Module mitbringt ([spring-core], [spring-beans] …);
  • Zeilen 32–38: das Exec-Plugin, dessen Version vom übergeordneten Projekt festgelegt wird. Der Befehl [mvn exec:java] führt die Klasse [tax.ui.Main] aus.

Die Klasse [Dialog] ist die aus Version 4 (Paket [tax.ui]), ergänzt um eine Methode, die eine Exception und alle von ihr gekapselten Exceptions anzeigt:

    // Anzeige einer Exception und aller Exceptions, die sie verpackt
    public static void displayError(Throwable exception) {
        String separator = "-".repeat(40);
        IO.println("Exception chain:\n" + separator);
        for (Throwable e = exception; e != null; e = e.getCause()) {
            IO.println(e.getClass().getName() + ": " + e.getMessage());
            IO.println(separator);
        }
    }
}
  • Zeile 3: eine Zeichenkette aus 40 Strichen, erzeugt mit der Methode [repeat] (Java 11);
  • Zeile 5: Die Schleife durchläuft die Kette der Exceptions: Jede Exception ermöglicht über ihre Methode [getCause()] den Zugriff auf die Exception, die sie kapselt, bis hinunter zur letzten, deren Ursache [null] ist. Der Parameter hat den Typ [Throwable], die Oberklasse aller Exceptions;
  • Zeile 6: Für jede Exception werden der vollständige Name ihrer Klasse (einschließlich des Pakets) und ihre Meldung angezeigt.

Die Klasse [Dialog] ist public: Künftige Versionen der Anwendung, die auf die Schicht [dao] umsteigen, können die Schicht [ui] wiederverwenden, indem sie vom Modul [tax-ui] abhängen und [Dialog.run(business)] aufrufen.

6.4.6. Schichten per Dependency Injection integrieren

In Version 4 erzeugte das Hauptprogramm die Schichten [dao] und [business] unter Nennung ihrer Implementierungsklassen:

1
2
3
        ITaxDao dao = source.equals("hardwired") ? new HardwiredTax() : new FileTax(source);
        // Erzeugung der [business]-Schicht, die die [dao]-Schicht erhält
        business = new TaxBusiness(dao);

Abgesehen von diesen Zeilen ändert sich nichts an der Anwendung, wenn sich die Implementierung einer Schicht ändert, denn jede Schicht kommuniziert mit der nächsten über eine Schnittstelle. Wir können die Unabhängigkeit der Schichten noch weiter treiben, indem wir ihre Erzeugung einem Dependency-Injection-Container anvertrauen und die Wahl der Implementierung der Schicht [dao] in eine Konfigurationsdatei verlagern. Um die Implementierung dieser Schicht zu wechseln, genügt es dann, diese Datei zu ändern, ohne die Anwendung neu zu kompilieren.

Image

Im obigen Beispiel startet das Hauptprogramm der Schicht [ui] den Spring-Container, [0]. Der Spring-Container erzeugt die Schichten [dao] und [1], dann die Schichten [business] und [2], denen er die Schicht [dao] übergibt. Schließlich fordert die Schicht [ui] die Schicht [business] vom Container an und erhält eine Referenz darauf: [3].

6.4.6.1. Die Konfigurationsdatei

Die Wahl der Implementierung der Schicht [dao] wird in der Datei [tax.properties] im Ordner [tax-ui] festgelegt:

1
2
3
# Konfiguration der Anwendung [Tax]: Implementierung der [dao]-Schicht
dao.implementation=FileTax
dao.file=TaxData.txt
  • Zeile 1: ein Kommentar, der mit dem Zeichen [#] beginnt;
  • Zeile 2: die Klasse, die die Schicht [dao] implementiert: [HardwiredTax], [FileTax], oder [JsonTax];
  • Zeile 3: die Datendatei, für Implementierungen, die eine lesen.

Eine „Properties“-Datei ist das traditionelle Konfigurationsformat von Java: eine Eigenschaft pro Zeile in der Form [key=value], gelesen von der Klasse [java.util.Properties]. Schlüssel erhalten oft ein Präfix, um Gruppen zu bilden, wie hier das Präfix [dao.]. Das Modul enthält drei weitere Konfigurationsdateien, die das Programm verwendet, wenn ihre Namen als Argumente übergeben werden:

1
2
3
tax-json.properties      : dao.implementation=JsonTax, dao.file=TaxData.json
tax-hardwired.properties : dao.implementation=HardwiredTax
tax-error.properties     : dao.implementation=FileTax, dao.file=TaxDataMissing.txt

Die Dateien [TaxData.txt] und [TaxData.json] wurden in den Ordner [tax-ui] kopiert: Ihre Pfade sind relativ zum aktuellen Ordner, und [mvn exec:java] führt das Programm im Ordner des Moduls aus.

6.4.6.2. Das Hauptprogramm

Das Hauptprogramm [Main] des Moduls [tax-ui] sieht wie folgt aus:

package tax.ui;

import tax.dao.FileTax;
import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.dao.JsonTax;
import tax.entities.TaxException;
import tax.business.ITaxBusiness;
import tax.business.TaxBusiness;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import org.springframework.context.support.GenericApplicationContext;

// Integration der Schichten durch den Spring-Container GenericApplicationContext
public class Main {

    public static void main(String[] args) {
        // die Konfigurationsdatei: standardmäßig tax.properties oder die als Argument übergebene
        String configFile = args.length > 0 ? args[0] : "tax.properties";

        // Integration der Schichten
        ITaxBusiness business;
        try {
            // Lesen der Konfiguration im aktuellen Ordner
            Properties config = new Properties();
            try (Reader reader = Files.newBufferedReader(Path.of(configFile))) {
                config.load(reader);
            }
            String implementation = config.getProperty("dao.implementation", "HardwiredTax");
            String file = config.getProperty("dao.file", "");

            // der Spring-Container: Die Schichten werden darin registriert
            GenericApplicationContext context = new GenericApplicationContext();
            // die [dao]-Schicht: Die Implementierung wird durch die Konfiguration gewählt
            context.registerBean(ITaxDao.class, () -> switch (implementation) {
                case "HardwiredTax" -> new HardwiredTax();
                case "FileTax" -> new FileTax(file);
                case "JsonTax" -> new JsonTax(file);
                default -> throw new TaxException(
                        "Unknown implementation [" + implementation + "] of the [dao] layer");
            });
            // die [business]-Schicht: Der Container übergibt die [dao]-Schicht an ihren Konstruktor
            context.registerBean(TaxBusiness.class);

            // Start des Containers: Er erzeugt die [dao]-Schicht, dann die [business]-Schicht
            context.refresh();
            business = context.getBean(ITaxBusiness.class);
        } catch (IOException | RuntimeException e) {
            // Anzeige des Fehlers und Beenden des Programms
            Dialog.displayError(e);
            System.exit(1);
            return;
        }

        // der Dialog mit dem Benutzer
        Dialog.run(business);
    }
}
  • Zeile 20: die Methode [main] einer gewöhnlichen Klasse in ihrer Standardform [public static void main(String[] args)];
  • Zeile 22: der Name der Konfigurationsdatei: standardmäßig [tax.properties] oder die als Argument übergebene Datei;
  • Zeilen 28–31: das Lesen der Konfiguration. [Files.newBufferedReader] öffnet die Datei in UTF-8; die Anweisung [try] mit einer Ressource (Java 7) schließt sie am Ende des Blocks, auch wenn eine Exception auftritt. [Properties.load] liest die Zeilen der Form [key=value]. Eine fehlende Datei löst eine [NoSuchFileException] aus, die in Zeile 51 abgefangen wird;
  • Zeilen 32–33: [getProperty] liefert den Wert eines Schlüssels oder den als zweiten Parameter angegebenen Standardwert, falls der Schlüssel nicht existiert;
  • Zeile 36: der Spring-Container. Spring bezeichnet ein vom Container erzeugtes und verwaltetes Objekt als „Bean“ und den Container selbst als „Application Context“. [GenericApplicationContext] ist ein Container, der programmgesteuert konfiguriert wird;
  • Zeilen 38–44: die Registrierung der Schicht [dao]. [registerBean(ITaxDao.class, supplier)] gibt an, dass die Bean vom Typ [ITaxDao] vom „Supplier“ erzeugt wird, einem parameterlosen Lambda-Ausdruck, der das Objekt zurückgibt. Die Bean ist ein Singleton, der Standard-Scope von Spring: Sie wird nur einmal erzeugt, und alle Anforderungen liefern dasselbe Objekt; es gibt in der Anwendung nur eine Schicht [dao]. Der Supplier wählt die Klasse anhand der Konfiguration mit einem Ausdruck [switch] aus. Eine unbekannte Implementierung führt zu einer [TaxException];
  • Zeile 46: die Registrierung der Schicht [business]: Der Container erzeugt das Objekt [TaxBusiness] selbst. Dazu untersucht er den Konstruktor der Klasse [TaxBusiness], sieht, dass dieser ein [ITaxDao] erwartet, und übergibt ihm die oben registrierte Bean dieses Typs: Das ist Dependency Injection, hier über den Konstruktor. Die Schicht [dao] ist eine Abhängigkeit der Schicht [business];
  • Zeile 49: [refresh()] startet den Container. Spring erzeugt dann alle Singleton-Beans in der Reihenfolge ihrer Registrierung: zuerst die Schicht [dao], dann die Schicht [business]. Ein Fehler bei der Erzeugung tritt daher in dieser Zeile auf;
  • Zeile 50: Beim Container wird eine Bean vom Typ [ITaxBusiness] angefordert. Der Container findet die Bean [TaxBusiness], die diese Schnittstelle implementiert. [getBean] löst eine Exception aus, wenn keine Bean diesen Typ hat oder wenn mehrere ihn haben. Beachten Sie, dass die Schicht [ui] die Schicht [business] erhält, ohne die Klasse zu nennen, die sie implementiert;
  • Zeilen 51–56: Jeder Fehler beim Lesen der Konfiguration ([IOException]) oder beim Erzeugen der Schichten ([RuntimeException]: Auch Spring-Exceptions sind ungeprüft) wird zusammen mit dem Stacktrace der Exception angezeigt, und das Programm wird beendet;
  • Zeile 59: Interaktion mit dem Benutzer, identisch mit der in Version 4.

Frühe Versionen von Spring lasen die vollständigen Namen der zu instanziierenden Klassen aus einer XML-Datei und erzeugten sie per Reflection. Wir haben uns stattdessen dafür entschieden, die möglichen Implementierungen im Supplier zu definieren: Die Konfigurationsdatei wählt lediglich unter ihnen aus, und der Compiler prüft, ob die Klassen existieren und über die erforderlichen Konstruktoren verfügen. In beiden Fällen nennt der Code der Schichten [ui] und [business] niemals die Klasse, die die Schicht [dao] implementiert. Bemerkenswert ist auch, dass die Klassen der Schichten nichts von Spring wissen: Keine von ihnen importiert Spring-Klassen, nur das Hauptprogramm tut dies.

6.4.6.3. Ausführungen

Im Ordner [tax-ui], nach einem [mvn install] im Ordner [TaxV5], mit der Datei [tax.properties] (Implementierung [FileTax]):

1
2
3
4
5
6
7
8
> mvn -q exec:java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit der Implementierung [JsonTax]:

1
2
3
4
> mvn -q exec:java -Dexec.args="tax-json.properties"
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Mit der Implementierung [HardwiredTax]:

1
2
3
4
> mvn -q exec:java -Dexec.args="tax-hardwired.properties"
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Wir haben die Implementierung der Schicht [dao] gewechselt, ohne eine einzige Codezeile zu ändern oder die Anwendung neu zu kompilieren.

Mit der Datei [tax-error.properties], die auf eine nicht vorhandene Datendatei verweist:

> mvn -q exec:java -Dexec.args="tax-error.properties"
Oct 03, 2026 7:01:28 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: Error while reading the file TaxDataMissing.txt
----------------------------------------
java.nio.file.NoSuchFileException: TaxDataMissing.txt: The file [TaxDataMissing.txt] does not exist
----------------------------------------
  • Zeilen 2–3: Bevor Spring die Exception weiterreicht, schreibt es eine Warnung in sein Protokoll. Da das Projekt keine Logging-Bibliothek enthält, wird dieses Protokoll vom Standard-Logging-Mechanismus des JDK ([java.util.logging]) verarbeitet, der das Datum, die auslösende Klasse, die Stufe der Meldung und die Meldung selbst in die Fehlerausgabe schreibt;
  • Zeile 10: die ursprüngliche Exception vom Typ [NoSuchFileException], ausgelöst von der Klasse [FileTax];
  • Zeile 8: Die Schicht [dao] hat sie in eine [TaxException] gekapselt;
  • Zeile 6: Spring selbst hat die Exception [TaxException] in eine [BeanCreationException]-Exception gekapselt, deren Meldung die Bean benennt, die nicht erzeugt werden konnte: die vom Typ [ITaxDao]. Diese Exception wurde über den Aufruf von [refresh] bis zum Hauptprogramm weitergereicht.

Die wichtigste Erkenntnis aus dieser Kette ist, dass oft die tiefste Exception – die zuletzt angezeigte – die aussagekräftigste ist.

6.4.6.4. Eine Variante: Konfiguration über eine annotierte Klasse

Spring-Anwendungen beschreiben ihre Beans üblicherweise in einer annotierten Konfigurationsklasse. Das Modul [tax-ui] enthält dafür ein Beispiel, die Klasse [TaxConfig]:

package tax.ui;

import tax.dao.FileTax;
import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.dao.JsonTax;
import tax.entities.TaxException;
import tax.business.ITaxBusiness;
import tax.business.TaxBusiness;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

// die als annotierte Java-Klasse geschriebene Konfiguration des Spring-Containers
@Configuration
// die Eigenschaften der Datei tax.properties im aktuellen Ordner sind über ${...} zugänglich
@PropertySource("file:tax.properties")
public class TaxConfig {

    // die [dao]-Schicht: Die Implementierung wird durch die Konfiguration gewählt
    @Bean
    ITaxDao dao(@Value("${dao.implementation}") String implementation,
            @Value("${dao.file:}") String file) {
        return switch (implementation) {
            case "HardwiredTax" -> new HardwiredTax();
            case "FileTax" -> new FileTax(file);
            case "JsonTax" -> new JsonTax(file);
            default -> throw new TaxException(
                    "Unknown implementation [" + implementation + "] of the [dao] layer");
        };
    }

    // die [business]-Schicht: Spring übergibt der Methode die von der Methode dao erzeugte [dao]-Schicht
    @Bean
    ITaxBusiness business(ITaxDao dao) {
        return new TaxBusiness(dao);
    }
}
  • Zeile 16: Die Annotation [@Configuration] gibt an, dass die Klasse Beans beschreibt;
  • Zeile 18: Die Annotation [@PropertySource] weist Spring an, die Datei [tax.properties] selbst zu lesen. Das Präfix [file:] verweist auf eine Datei im Dateisystem, relativ zum aktuellen Verzeichnis; das Präfix [classpath:] würde auf eine Ressource in der JAR-Datei verweisen;
  • Zeilen 22–32: Eine mit [@Bean] annotierte Methode erzeugt eine Bean, deren Name der der Methode ([dao]) ist und deren Typ ihrem Rückgabetyp entspricht. Spring ruft die Methode auf und liefert ihre Parameter. Die Annotation [@Value] fordert den Wert einer Eigenschaft an: [${dao.implementation}] ist der Wert des Schlüssels [dao.implementation], und [${dao.file:}] ist der Wert des Schlüssels [dao.file], wobei die leere Zeichenkette (nach dem Doppelpunkt) als Standardwert dient;
  • Zeilen 35–38: die Bean der Schicht [business]. Die Methode erwartet ein [ITaxDao]: Spring übergibt ihr die von der Methode [dao] erzeugte Bean. Diesmal handelt es sich um eine Injektion über einen Methodenparameter. Damit eine Singleton-Bean nur einmal erzeugt wird, leitet Spring zur Laufzeit eine Unterklasse der Konfigurationsklasse ab, die ihre [@Bean]-Methoden überschreibt: Daher dürfen weder die Klasse noch diese Methoden als [final] oder [private] deklariert werden.

Das Hauptprogramm [MainConfig] verwendet diese Konfiguration:

package tax.ui;

import tax.business.ITaxBusiness;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

// Integration der Schichten durch den Spring-Container, konfiguriert durch die Klasse TaxConfig
public class MainConfig {

    public static void main(String[] args) {
        // Erzeugung und Start des Containers; er wird am Ende des try-Blocks geschlossen
        try (var context = new AnnotationConfigApplicationContext(TaxConfig.class)) {
            // die [business]-Schicht und der Dialog mit dem Benutzer
            ITaxBusiness business = context.getBean(ITaxBusiness.class);
            Dialog.run(business);
        } catch (RuntimeException e) {
            // Anzeige des Fehlers und Beenden des Programms
            Dialog.displayError(e);
            System.exit(1);
        }
    }
}
  • Zeile 11: [AnnotationConfigApplicationContext] ist ein Container, der durch annotierte Klassen konfiguriert wird. Sein Konstruktor registriert die von der Klasse [TaxConfig] beschriebenen Beans und startet den Container. Der Container implementiert die Schnittstelle [AutoCloseable]: Die Ressource in [try] schließt ihn am Ende des Blocks, wodurch die Beans freigegeben werden. Das Schlüsselwort [var] (Java 10) erlaubt es dem Compiler, den Typ der Variablen abzuleiten;
  • Zeile 13: Die Schicht [business] wird wie zuvor bezogen;
  • Zeilen 15–19: Fehlerbehandlung.

Ergebnisse:

1
2
3
4
> mvn -q exec:java -Dexec.mainClass=tax.ui.MainConfig
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

Bei einer fehlerhaften Konfiguration hat die Exception-Kette nun eine zusätzliche Ebene: Spring meldet das Scheitern der Methode [dao] über eine [BeanInstantiationException]-Exception, die in die [BeanCreationException]-Exception gekapselt wird. Spring kann die zu instanziierenden Klassen auch automatisch entdecken: Mit der Annotation [@ComponentScan] auf der Konfigurationsklasse erzeugt es für jede Klasse eines Pakets, die mit [@Component] (oder [@Service], [@Repository]) annotiert ist, eine Bean. Hier haben wir das nicht getan, da dafür die Klassen der Schichten hätten annotiert werden müssen, wodurch sie von Spring abhängig geworden wären. Spring Boot in Kapitel 13 nutzt diesen Mechanismus intensiv.

Allein die Dependency Injection verdient ein eigenes Kapitel. Wir haben nur das Wesentliche verwendet: Beans registrieren ([registerBean], [@Bean]), den Container starten ([refresh]) und eine Bean beziehen ([getBean]). Der Container kann auch für jede Anforderung ein neues Objekt erzeugen (Scope [prototype]) oder ein Objekt pro (HTTP-)Anfrage bzw. pro Sitzung in einer Webanwendung (Scopes [request] und [session]). Mehr zu diesem Thema finden Sie in der Spring-Dokumentation: The IoC Container.

6.5. Fazit

Dieses Kapitel hat der Anwendung [Tax] die Architektur gegeben, die sie bis zum Ende des Kurses behalten wird:

  • eine Schicht [dao], die die Steuerstufen über die Schnittstelle [ITaxDao] bereitstellt;
  • eine Schicht [business], die die Steuer berechnet und mit der Schicht [dao] nur über deren Schnittstelle interagiert;
  • eine Schicht [ui], die mit dem Benutzer interagiert und die Schicht [business] nur über deren Schnittstelle [ITaxBusiness] kennt;
  • ein Hauptprogramm – das einzige, das die Implementierungsklassen kennt –, das die Schichten erzeugt und verbindet, hier mithilfe des Dependency-Injection-Containers von Spring und einer Konfigurationsdatei;
  • automatisierte Unit-Tests, die jede Schicht unabhängig von den anderen überprüfen und die Regressionsfreiheit der Anwendung sicherstellen.

Die Vorteile dieser Architektur zeigen sich in den folgenden Kapiteln in vollem Umfang, in denen die Module [tax-dao], [tax-business] und [tax-ui] aus Version 5 – von [mvn install] im lokalen Maven-Repository installiert – unverändert als Maven-Abhängigkeiten wiederverwendet werden:

  • Version 6 (Kapitel 10, „Datenbankzugriff mit JDBC“): Eine neue Implementierung der Schicht [dao] liest die Steuerstufen aus einer MySQL-Datenbank. Die Schichten [business] und [ui] bleiben unverändert;
  • Version 7 (Kapitel 11, „Hibernate“): Eine weitere Implementierung der Schicht [dao] verwendet die ORM-Schicht Hibernate, um auf dieselbe Datenbank zuzugreifen;
  • Version 8 (Kapitel 12, „Internetprogrammierung“): Die Schicht [business] wird auf einem TCP-Server installiert, der Steuern für entfernte Clients berechnet, deren Schicht [ui] aus Version 5 stammt; die Schichten sind somit auf mehrere Rechner verteilt, womit der ursprüngliche Sinn des Begriffs „Tier“ wiederhergestellt wird;
  • Version 9 (Kapitel 13, „Webservices“): Die Schicht [business] wird von einem mit Spring Boot geschriebenen REST/JSON-Webservice bereitgestellt, dessen Konsolenclient die Klasse [HttpClient] des JDK verwendet.

Jedes Mal beschränkt sich die Arbeit darauf, die neue Schicht zu schreiben und das Programm anzupassen, das die Schichten integriert: Genau darin besteht der Sinn einer Schichtenarchitektur.