Skip to content

6. Schichtenarchitekturen

6.1. Einführung

Greifen wir die neueste Version der Anwendung zur Steuerberechnung noch einmal auf (Version 3, Kapitel 5). Auf das Wesentliche reduziert, hatte ihr Hauptprogramm folgende Struktur (vereinfachtes Schema):

// Erstellung eines ITax-Objekts; die Klasse hängt von der Dateiendung ab
val tax: ITax = try {
    when (fileName.substringAfterLast('.').lowercase()) {
        "json" -> JsonTax(fileName)
        else -> FileTax(fileName)
    }
} catch (e: TaxException) {
    println("The following error occurred: [Code=${ErrorCode.decode(e.code)}, ...]")
    exitProcess(1)
}
// Eingabeschleife
while (true) {
    print("Tax calculation parameters in the format: ...")
    val parameters = readlnOrNull()?.trim() ?: ""
    ...
    // die Parameter sind korrekt: wir berechnen die Steuer
    println("Tax=${tax.calculate(married == "y", nbChildren, salary)} euros")
}

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

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

Die Praxis hat gezeigt, dass die Trennung dieser Verarbeitungsschritte in eigene Klassen die Wartbarkeit einer Anwendung verbessert. Die Architektur einer so aufgebauten Anwendung sieht wie folgt aus:

Image

Diese Architektur wird als „Drei-Tier-Architektur“ bezeichnet. 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. Für unsere Anwendung sind dies die Regeln zur Berechnung der Steuer eines Steuerpflichtigen. Diese Schicht benötigt zum Funktionieren Daten:
    • die Steuerstufen, die sich jedes Jahr ändern;
    • die Anzahl der Kinder, den Familienstand des Steuerpflichtigen und das Jahreseinkommen;
  • die Datenzugriffsschicht oder [dao] (DAO = Data Access Object) liefert bereits in Dateien oder Datenbanken gespeicherte Daten. Dazu gehören die Steuerstufen, wie in Version 3 der Anwendung;
  • die Benutzeroberflächenschicht oder [ui] (UI = User Interface) liefert die vom Benutzer eingegebenen Daten und zeigt dem Benutzer die Ergebnisse an. Das betrifft hier die Anzahl der Kinder, den Familienstand und das Jahreseinkommen des Steuerpflichtigen.

Allgemein gilt:

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

Wir greifen die Anwendung [Tax], die wir bereits mehrfach betrachtet 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

Eine Schnittstelle definiert eine Menge von Funktionssignaturen und Eigenschaften. Die Klassen, die die Schnittstelle implementieren, stellen deren Implementierung bereit.

Kehren wir zur Schichtenarchitektur unserer Anwendung zurück:

Image

Bei dieser Art von Architektur geht die Initiative oft vom Benutzer aus. Der Benutzer stellt in [1] eine Anfrage und erhält in [8] eine Antwort. Man spricht vom Anfrage-Antwort-Zyklus. Nehmen wir als Beispiel die Berechnung der Steuer eines Steuerpflichtigen. Dazu sind mehrere Schritte nötig:

  • Die Schicht [ui] fragt den Benutzer nach Familienstand, Anzahl der Kinder und Jahresgehalt. Dies 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. Dies ist die Operation [2];
  • Die Schicht [business] benötigt für ihre Aufgabe bestimmte Informationen: die Steuerstufen. Sie fordert diese Informationen von der Schicht [dao] über den Weg [3, 4, 5, 6] an: [3] ist die ursprüngliche Anfrage, und [6] ist die Antwort auf diese Anfrage;
  • Mit allen benötigten Daten berechnet die Schicht [business] die Steuer;
  • Die Schicht [business] kann nun die in [2] von der Schicht [ui] gestellte Anfrage beantworten. Dies ist der Weg [7];
  • die Schicht [ui] formatiert dieses Ergebnis und präsentiert es anschließend dem Benutzer. Dies ist der Weg [8];
  • Man könnte sich vorstellen, dass der Benutzer Steuersimulationen durchführt und speichern möchte. Dafür würde er denselben Weg, [1-8], nehmen.

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] richtet Anfragen an die Schicht [B]. In den einfachsten Fällen wird eine Schicht durch eine einzige Klasse implementiert. Eine Anwendung entwickelt sich jedoch im Lauf der Zeit weiter, und die Schicht [B] kann nacheinander verschiedene Implementierungsklassen haben: [B1], [B2] usw. Ist die Schicht [B] die Schicht [dao], kann sie eine erste Implementierung haben, [B1], die Daten aus einer Datei abruft. Einige Jahre später möchte man diese Daten vielleicht in einer Datenbank speichern: In diesem Fall erstellt man eine zweite Implementierungsklasse, [B2]. Wenn in der ursprünglichen Anwendung die Schicht [A] direkt mit der Klasse [B1] gearbeitet hat, wären wir gezwungen, den Code der Schicht [A] teilweise neu zu schreiben. Angenommen, wir hätten in der Schicht [A] etwa Folgendes geschrieben:

1
2
3
val b1: B1 = 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] Funktionen mit derselben Signatur wie die Klasse [B1], müssen Sie alle Vorkommen von [B1] durch [B2] ersetzen. Das ist der günstigste Fall, und er ist ziemlich unwahrscheinlich, wenn Sie auf diese Signaturen nicht geachtet haben. In der Praxis haben die Klassen [B1] und [B2] häufig unterschiedliche Funktionssignaturen, 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. Sie legt in einer Schnittstelle die Funktionssignaturen fest, die die Schicht [B] der Schicht [A] bereitstellt. Das vorherige Schema wird zu Folgendem:

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 einmal, nämlich dort, wo das Objekt erzeugt wird, das die Schnittstelle [IB] implementiert. Danach wird die Schnittstelle [IB] – und nicht ihre Implementierungsklasse – verwendet. Der vorherige Code wird zu:

1
2
3
val ib: IB = B1(...)
...
ib.getData(...)
  • Zeile 1: Eine Instanz [ib] , die die Schnittstelle [IB] implementiert, wird durch Instanziierung der Klasse [B1] erzeugt. Der Typ der Variablen wird explizit deklariert: Ohne ihn würde die Typinferenz [B1] als Typ von [ib] festlegen;
  • Zeile 3: Von der Instanz [ib] werden Daten angefordert.

Ersetzen wir nun die Implementierung [B1] der Schicht [B] durch eine Implementierung [B2] und entsprechen beide Implementierungen derselben Schnittstelle [IB], muss nur Zeile 1 der Schicht [A] geändert werden. Das ist ein großer Vorteil, der für sich allein die systematische Verwendung von Schnittstellen zwischen zwei Schichten rechtfertigt.

Wir können noch weiter gehen und die Schicht [A] vollständig von der Schicht [B] unabhängig machen. Im obigen Code ist Zeile 1 problematisch, weil sie den Klassennamen [B1] fest codiert. 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 mit der 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:

1
2
3
4
5
6
7
8
// Schicht [A] erhält Schicht [B] über ihren Konstruktor
class A(private val ib: IB) {

    fun work() {
        ...
        ib.getData(...)
    }
}
  • Zeile 2: Die Schicht [A] erhält über ihren primären Konstruktor eine Instanz [ib], die die Schnittstelle [IB] implementiert. Das Schlüsselwort ***[val]*** vor dem Parameter macht ihn zu einer privaten Eigenschaft der Klasse: Wo Java ein Feld, einen Konstruktor und eine Zuweisung benötigt, braucht Kotlin nur eine einzige Zeile. Diese Instanz wird nicht von der Schicht *[A]* erzeugt, sondern vom Container;
  • Zeile 6: Von der Instanz [ib] werden Daten angefordert.

Die Implementierungsklasse [B1] erscheint nirgends mehr im Code der Schicht [A]. Wird die Implementierung [B1] durch eine neue Implementierung [B2] ersetzt, ändert sich im Code der Schicht [A] nichts: Das Einzige, was sich ändert, ist 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.

Auf der JVM wurde Dependency Injection Anfang der 2000er-Jahre durch das Framework Spring populär, dessen Konfiguration damals in XML-Dateien geschrieben wurde. Das Spring Framework, inzwischen in Version 7, bleibt der Branchenstandard und behandelt Kotlin als erstklassige Sprache: Es bietet Kotlin-Erweiterungen für seine API, und Kotlin ist eine der beiden Sprachen, die in seiner Dokumentation verwendet werden. 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 weitere: CDI, den Jakarta-EE-Standard, Google Guice oder, speziell für Kotlin, Koin und Kodein). Die Kombination aus „Schnittstellen und Dependency Injection“ verbessert die Wartbarkeit von Anwendungen erheblich, indem sie die Schichten voneinander unabhängig macht.

Kehren wir zur Schichtenarchitektur unserer Anwendung zurück. In einfachen Fällen können wir mit 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 erhält.

Welche Schnittstelle sollte die Schicht [dao] der Schicht [business] bereitstellen? Die Schicht [dao] muss der Schicht [business] die Steuerstufen liefern. In unserer Anwendung nutzt die Schicht [dao] vorhandene Daten, erzeugt aber keine neuen. Ihre Schnittstelle könnte wie folgt aussehen:

package dao

import entities.TaxBracket

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

    // die Steuerstufen: eine schreibgeschützte Eigenschaft
    val taxBrackets: List<TaxBracket>
}
  • Zeile 1: Die Schnittstelle liegt im Paket [dao]. Wie wir sehen werden, legen wir die Datei [ITaxDao.kt] in einem Ordner [dao] ab;
  • Zeile 9: Die Schnittstelle [ITaxDao] deklariert die Eigenschaft [taxBrackets], die der Schicht [business] die Steuerstufen liefert. Eine Kotlin-Schnittstelle kann nicht nur Funktionen, sondern auch Eigenschaften deklarieren: Eine Schnittstelleneigenschaft [val] ist abstrakt; jede implementierende Klasse legt fest, wie sie ihren Wert erhält. Während Java schreibgeschützte Daten gemäß der JavaBeans-Konvention über eine Methode [getTaxBrackets()] bereitstellte, deklariert Kotlin sie als das, was sie ist: eine schreibgeschützte Eigenschaft. Aus Sicht von Java ist diese Eigenschaft tatsächlich eine Methode [getTaxBrackets()];
  • die Stufen werden als Liste [List<TaxBracket>] statt als Array geliefert. In Kotlin ist [List] eine schreibgeschützte Schnittstelle: Sie hat weder [add], [set] noch [remove], die zur Schnittstelle [MutableList] gehören (Kapitel 5). Der Empfänger der Liste kann sie somit nicht ändern, 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
package entities

import java.math.BigDecimal

// eine Steuerstufe: eine Data-Klasse, deren Eigenschaften schreibgeschützt sind
data class TaxBracket(val limit: BigDecimal, val coeffR: BigDecimal, val coeffN: BigDecimal)

Eine Steuerstufe wird durch eine Datenklasse ([data class], Kapitel 4) dargestellt, das Kotlin-Äquivalent zu einem Java-Record. Der Compiler erzeugt die Eigenschaften [limit], [coeffR] und [coeffN] sowie die Funktionen [equals], [hashCode], [toString], [copy] und [component1]…[component3] (für die Destrukturierung). Wir schreiben [TaxBracket(limit, coeffR, coeffN)] , um eine Stufe zu erzeugen. Die Eigenschaften werden als [val] deklariert: Eine Stufe kann nach ihrer Erzeugung nicht mehr geändert werden (eine Datenklasse kann [var]-Eigenschaften haben, das ist aber nicht üblich). Alle drei Eigenschaften haben den Typ [BigDecimal], die Java-Klasse für exakte Dezimalzahlen, die Kotlin direkt verwendet: Ein [Double] kann 0.068 oder 291.09 nicht exakt darstellen. Da ein *[BigDecimal] selbst unveränderlich ist, ist eine Stufe vollständig unveränderlich. Eine Klasse mit [var]-Eigenschaften hätte ihre Änderung erlaubt; wir werden sehen, dass diese Unveränderlichkeit einen Seiteneffekt einer älteren Schreibweise der Schicht [business]* beseitigt.

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

  • Die Schicht [ui] fragt den Benutzer nach Familienstand, Anzahl der Kinder und Jahresgehalt. Dies 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. Dies ist die Operation [2].

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

1
2
3
4
5
6
7
package business

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

    fun calculateTax(married: Boolean, nbChildren: Int, salary: Int): Int
}
  • Zeile 1: Alles, was die Schicht [business] betrifft, wird im Paket [business] abgelegt;
  • Zeile 6: Die Schnittstelle [ITaxBusiness] deklariert nur eine Funktion, die die Steuer eines Steuerpflichtigen anhand seines Familienstands, der Anzahl der Kinder und seines Jahresgehalts berechnet. Eine Schnittstellenfunktion ohne Rumpf ist abstrakt und, wie jeder Kotlin-Member ohne Sichtbarkeitsmodifizierer, öffentlich: [public abstract] muss nicht geschrieben werden. Das Ergebnis ist [Int]: die Steuer in Euro, ohne Cent.

Wir betrachten 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. Kotlin hat kein einfaches Äquivalent zum Quellcode-Launcher von Java ([java Main.java]), der ein Programm aus mehreren Dateien im Arbeitsspeicher kompiliert und ausführt: Ein Kotlin-Programm aus mehreren Dateien wird vor der Ausführung kompiliert. Wir erstellen daher ein Gradle-Projekt, [TaxV4], das eines der Unterprojekte des Gradle-Builds des Kapitels ist (Kapitel 2). Der Ordner [06-architectures] enthält alle Projekte des Kapitels; seine Datei [settings.gradle.kts] listet sie auf:

// Kapitel 6: ein Gradle-Build, der alle Projekte des Kapitels zusammenfasst

// Gradle lädt das von jvmToolchain(25) angeforderte JDK selbst herunter, wenn es auf dem Rechner nicht gefunden wird
plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}

rootProject.name = "architectures"

// die Unterprojekte, bezeichnet durch ihren Pfad: [TaxV5:tax-dao] ist der Ordner TaxV5/tax-dao
include("DemoTests", "TaxV4", "TaxV5:tax-dao", "TaxV5:tax-business", "TaxV5:tax-ui")
  • Zeilen 3–6: das Plugin, mit dem Gradle das JDK 25 selbst herunterladen kann, wenn es es auf dem Rechner nicht findet (Kapitel 2);
  • Zeile 8: der Name des Wurzelprojekts;
  • Zeile 11: die fünf Unterprojekte dieses Kapitels. Ein Unterprojekt wird durch seinen Pfad identifiziert, dessen Elemente durch Doppelpunkte getrennt sind: [TaxV5:tax-dao] ist das Unterprojekt des Ordners [TaxV5/tax-dao]. Auf [DemoTests] und die drei Unterprojekte von Version 5 gehen wir später ein.

Die Datei [build.gradle.kts] im Wurzelprojekt deklariert die von den Unterprojekten verwendeten Plugins samt ihren Versionen, ohne sie anzuwenden:

1
2
3
4
5
6
// Kapitel 6: Wurzelprojekt. Die Plugins werden hier mit ihrer Version deklariert, ohne angewendet zu werden:
// die Unterprojekte wenden sie an
plugins {
    kotlin("jvm") version "2.4.20" apply false
    kotlin("plugin.spring") version "2.4.20" apply false
}
  • Zeile 4: das Kotlin-Plugin für die JVM, Version 2.4.20. Der Zusatz [apply false] macht es den Unterprojekten verfügbar, die es anwenden, ohne seine Version zu wiederholen;
  • Zeile 5: ein Kotlin-Compiler-Plugin, das Version 5 für Spring benötigt. Wir erklären es, wenn es so weit ist.

Das Unterprojekt [TaxV4] hat die folgende Verzeichnisstruktur. Jede Schicht belegt einen Ordner:

TaxV4/
  build.gradle.kts           the build file of the subproject
  TaxData.txt                the tax brackets
  TaxDataInvalid.txt         an incorrect bracket file
  src/main/kotlin/
    Main.kt                  integration of the layers
    entities/
      TaxBracket.kt
      ErrorCode.kt
      TaxException.kt
    dao/
      ITaxDao.kt
      HardwiredTax.kt
      FileTax.kt
    business/
      ITaxBusiness.kt
      TaxBusiness.kt
    ui/
      Dialog.kt
  • Der Ordner [entities] enthält Typen, die den Schichten [ui], [business], und [dao] gemeinsam sind: die Datenklasse [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 codiert sind (Version 2), und die Klasse [FileTax], die Daten aus einer Textdatei liest (Version 3). Das Lesen einer JSON-Datei – die andere Option in Version 3 – wird in Version 5 behandelt;
  • 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.kt] erzeugt die Schichten und verbindet sie miteinander;
  • die Datei [TaxData.txt] enthält die Steuerstufen, die die Implementierung [FileTax] der Schicht [dao] liest. Sie liegt im Wurzelverzeichnis des Unterprojekts, das das aktuelle Verzeichnis des von Gradle gestarteten Programms ist.

In Java sind die Ordnernamen wichtig: Eine Klasse des Pakets [dao] muss in einem Ordner namens [dao] liegen. Kotlin ist flexibler: Das Paket ist dasjenige, das die Direktive [package] in der Datei deklariert, unabhängig vom Ordner, in dem sie liegt. Die Konvention – der IntelliJ, IDEA und dieser Kurs folgen – lautet jedoch weiterhin, Dateien in Ordnern zu organisieren, die die Pakete widerspiegeln: eine Datei des Pakets [tax.dao] in einem Ordner [tax/dao] (in einem Projekt, in dem alle Pakete mit derselben Wurzel beginnen, werden die Ordner für diese gemeinsame Wurzel einfach weggelassen). Die vom Compiler erzeugten [.class]-Dateien sind dagegen stets nach Paketen organisiert: So findet die virtuelle Maschine die Klassen anhand ihrer vollständigen Namen.

Die Datei [Main.kt] hat keine [package]-Direktive: Sie gehört zum Wurzelpaket, das keinen Namen hat. Ihre Funktion [main] wird in die Klasse [MainKt] kompiliert, den Namen, den die Build-Datei des Unterprojekts dem Plugin [application] zuweist:

// TaxV4: die geschichtete [Tax]-Anwendung in einem einzigen Projekt, ohne externe Bibliothek
plugins {
    kotlin("jvm")
    application
}

group = "examples.architectures"
version = "4.0"

repositories {
    mavenCentral()
}

kotlin {
    // der Code wird mit JDK 25 kompiliert und ausgeführt
    jvmToolchain(25)
    compilerOptions {
        // eine Compiler-Warnung wird als Fehler behandelt
        allWarningsAsErrors = true
        // die Namen der Funktionsparameter bleiben im Bytecode erhalten
        javaParameters = true
    }
}

application {
    // die main-Funktion der Datei Main.kt, die kein Paket hat: ihre Klasse ist MainKt
    mainClass = "MainKt"
}

tasks.named<JavaExec>("run") {
    // das laufende Programm kann die Tastatur lesen
    standardInput = System.`in`
}

// unter Windows wird die Bildschirmausgabe des von Gradle gestarteten Programms (run, bootRun ...) in UTF-8 kodiert,
// sonst werden Zeichen mit Akzenten in der IntelliJ-IDEA-Konsole oder im Terminal falsch dargestellt
tasks.withType<JavaExec>().configureEach {
    jvmArgs("-Dstdout.encoding=UTF-8", "-Dstderr.encoding=UTF-8")
}
  • Zeilen 2–4: Das Unterprojekt wendet das Kotlin-Plugin ohne Version an (sie wird vom Wurzelprojekt vorgegeben) sowie das Plugin [application], das die Aufgabe [run] hinzufügt;
  • Zeilen 7–8: die Projektangaben;
  • Zeilen 14–21: die Compiler-Konfiguration, dieselbe wie in den vorherigen Kapiteln;
  • Zeilen 25–27: die Hauptklasse, [MainKt], ohne Paketnamen. In diesem Unterprojekt gibt es nur ein Programm: Die Eigenschaft [main] aus den vorherigen Kapiteln ist unnötig;
  • Zeilen 30–32: Das Programm liest von der Tastatur;
  • Zeilen 35–38: Die von Gradle gestarteten Programme schreiben ihre Ausgabe in UTF-8, damit akzentuierte Zeichen unter Windows korrekt angezeigt werden (Kapitel 2).

Anders als Java erlaubt Kotlin, eine Deklaration des Wurzelpakets aus einem anderen Paket zu importieren, indem man sie ohne Präfix benennt ([import declarationName]). Die Konvention bleibt jedoch, dort nur das Hauptprogramm abzulegen, das von niemandem importiert wird.

Führen Sie das Programm aus dem Ordner des Kapitels mit [gradlew -q :TaxV4:run] aus: Der Pfad [:TaxV4] bezeichnet das Unterprojekt, und die Aufgabe [run] läuft mit dem Ordner des Unterprojekts als aktuellem Verzeichnis. IntelliJ IDEA öffnet den Ordner [06-architectures] als Gradle-Projekt und führt [Main.kt] aus, wenn Sie auf das grüne Dreieck neben der Funktion [main] klicken.

6.3.2. Anwendungsentitäten

Image

Als Entitäten bezeichnen wir Typen, die mehrere Schichten durchziehen. Es sind im Allgemeinen 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 die bereits vorgestellte Datenklasse [TaxBracket] und die Ausnahme [TaxException] samt der Enumeration ihrer Fehlercodes:

package entities

// die Fehlercodes der [dao]-Schicht: jeder entspricht einem Bit, sodass sie kombiniert werden können
enum class 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
    val bit: Int
        get() = 1 shl ordinal

    companion object {
        // die Namen der in einer Bitkombination enthaltenen Codes, zum Beispiel "FIELD2, FIELD3" für 24
        fun names(code: Int): String =
            entries.filter { (code and it.bit) != 0 }.joinToString(", ") { it.name }
    }
}
  • Zeile 4: eine Enumeration ([enum class]). Wie in Java sind die Werte einer Enumeration Objekte – eindeutige Instanzen der Klasse [ErrorCode] –, und eine Enumeration kann Eigenschaften und Methoden haben;
  • Zeile 5: die fünf Fehlercodes. Das Semikolon, das die Liste abschließt, ist erforderlich, wenn weitere Member folgen. Die Eigenschaft [ordinal], die von der Klasse [Enum] geerbt wird, liefert die Position des Werts in der Liste: 0 für [ACCESS], 4 für [FIELD3];
  • Zeilen 8–9: Jeder Code ist einem Bit zugeordnet. [bit] ist eine berechnete Eigenschaft: Sie hat kein Feld; ihr Accessor [get()], berechnet sie bei jedem Lesen. Kotlin hat keine Schiebeoperatoren: [1 shl ordinal] („shift left“) entspricht [1 << ordinal] in Java und ergibt 1, 2, 4, 8 und 16. Diese Zweierpotenzen lassen sich mit der Infix-Funktion [or] ([|] in Java) kombinieren: Der Code [FIELD2.bit or FIELD3.bit] (8 + 16 = 24) bedeutet, dass die Felder 2 und 3 einer Zeile fehlerhaft sind. Der Fehlercode der Ausnahme bleibt eine einfache Ganzzahl, die alle Implementierungen der Schicht [dao] verwenden können;
  • Zeilen 11–14: Die Funktion [names] wandelt die Namen der Codes, die in einer Bitfolge enthalten sind, um – „FIELD2, FIELD3“ für 24. Sie verwendet keinen spezifischen Wert der Enumeration: Sie steht im Companion-Objekt und wird wie eine statische Java-Methode aufgerufen, [ErrorCode.names(24)]. Die Eigenschaft [entries] (Kotlin 1.9) ist die Liste der Werte der Enumeration; sie ersetzt die Funktion [values()], die bei jedem Aufruf ein neues Array erzeugt. [(code and it.bit) != 0] ist wahr, wenn das Bit, das dem Wert von [it] entspricht, in [code] vorhanden ist ([and] ist das Java-Äquivalent zu [&]). Die von [filter] ermittelten Werte werden anschließend von [joinToString] zusammengesetzt, mit dem Trenner [", "] und einem Lambda, das den Namen ([name]) jedes Werts liefert. Der Rumpf der Funktion ist ein Ausdruck: Die Funktion hat keine geschweiften Klammern, und ihr Ergebnis folgt auf das Zeichen [=].
package entities

// die von der [dao]-Schicht geworfene Exception
// Kotlin kennt keine geprüften Exceptions: keine Methode muss sie deklarieren
class TaxException(
    message: String,
    // die ursprüngliche Exception, falls vorhanden
    cause: Throwable? = null,
    // Fehlercode (eine Kombination von ErrorCode-Bits)
    val code: Int = 0,
) : RuntimeException(message, cause)
  • Zeile 5: Eine anwendungsspezifische Ausnahme leitet sich von der Klasse [RuntimeException] ab. In Kotlin stellt sich die Frage nach der Wahl zwischen geprüften und ungeprüften Ausnahmen nicht: Die Sprache kennt keine geprüften Ausnahmen (Kapitel 3), keine Funktion deklariert die Ausnahmen, die sie auslöst, und kein Aufrufer ist verpflichtet, sie abzufangen. Die Ableitung von *[RuntimeException]* statt von *[Exception]* bleibt die übliche Praxis, da so gewährleistet ist, dass eine Ausnahme aus Java-Code einheitlich betrachtet wird;
  • Zeilen 6–10: Der primäre Konstruktor hat drei Parameter. [message] und [cause] sind einfache Parameter, die an den Konstruktor der Elternklasse weitergereicht werden (Zeile 11); [code], das als [val] deklariert ist, ist zudem eine schreibgeschützte Eigenschaft der Ausnahme. Die Ursache – die ursprüngliche Ausnahme, sofern vorhanden – ist über die Eigenschaft [cause], die von [Throwable] geerbt wird, zugänglich;
  • Zeilen 8–10: Dank der Standardwerte für Parameter ersetzt dieser einzelne Konstruktor die beiden Konstruktoren der Java-Version – einen mit Nachricht und Code, den anderen zusätzlich mit der Ursache. Mit benannten Argumenten schreiben wir [TaxException(message, code = 2)] , wenn es keine Ursache gibt, und [TaxException(message, e, 1)] , wenn es eine gibt;
  • Zeile 10: Das Komma nach dem letzten Parameter („Trailing Comma“) ist erlaubt; es erleichtert das Hinzufügen eines Parameters;
  • Eine Ausnahme ist serialisierbar (die Klasse [Throwable] implementiert die Schnittstelle [Serializable]). Die Java-Version deklarierte ein Feld [serialVersionUID], um eine Warnung von [javac -Xlint:all] zu vermeiden; der Kotlin-Compiler gibt diese Warnung nicht aus, daher deklarieren wir dieses Feld nicht.

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

6.3.3. Die Schicht [dao]

Sehen wir uns die Schnittstelle der Schicht [dao] noch einmal an:

package dao

import entities.TaxBracket

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

    // die Steuerstufen: eine schreibgeschützte Eigenschaft
    val taxBrackets: List<TaxBracket>
}

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

package dao

import entities.TaxBracket

// eine [dao]-Schicht, deren Daten "hart codiert" sind
class HardwiredTax : ITaxDao {

    // Steuerstufen (Steuertarif 2004 auf Einkommen 2003): eine schreibgeschützte Liste
    override val taxBrackets: List<TaxBracket> = listOf(
        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"),
    )
}

// eine aus Strings erstellte Stufe: die BigDecimals sind exakt
private fun bracket(limit: String, coeffR: String, coeffN: String) =
    TaxBracket(limit.toBigDecimal(), coeffR.toBigDecimal(), coeffN.toBigDecimal())
  • Zeile 6: Die Klasse [HardwiredTax] implementiert die Schnittstelle [ITaxDao]. In Kotlin dient der Doppelpunkt sowohl der Klassenvererbung als auch der Implementierung von Schnittstellen: Es gibt kein Schlüsselwort [implements]. Beachten Sie, dass die Schnittstelle ohne Klammern genannt wird, während eine Elternklasse mit ihren Konstruktorargumenten genannt wird ([RuntimeException(message, cause)]): Eine Schnittstelle hat keinen Konstruktor;
  • Zeilen 9–16: die Implementierung der Eigenschaft der Schnittstelle. Das Schlüsselwort [override] ist erforderlich: Der Compiler prüft, dass die Eigenschaft tatsächlich einen Member der Schnittstelle implementiert, ähnlich der optionalen Annotation [@Override] in Java. Die Eigenschaft wird in ihrer Deklaration mit [listOf] initialisiert, das eine schreibgeschützte Liste erzeugt. Auch hier ist ein Komma nach dem letzten Element erlaubt;
  • Zeilen 20–22: eine private Funktion, die aus drei Zeichenketten eine Stufe erzeugt. Sie ist auf Dateiebene außerhalb der Klasse deklariert: [private] macht sie nur innerhalb der Datei [HardwiredTax.kt] sichtbar. Die Erweiterungsfunktion [toBigDecimal] der Standardbibliothek wandelt eine Zeichenkette in [BigDecimal] um; dies ist der Konstruktor [BigDecimal(String)]. Ein aus einer Zeichenkette konstruierter [BigDecimal] ist exakt: ["0.068".toBigDecimal()] ist genau 0.068, während ein aus einem [BigDecimal] konstruierter [Double] dessen Ungenauigkeit erbt: [0.068.toBigDecimal()], das durch Umwandlung von [Double] in eine Zeichenkette entsteht, liefert zwar tatsächlich 0.068, aber [(0.1 + 0.2).toBigDecimal()] liefert 0.30000000000000004. Der Typ des Funktionsergebnisses, [TaxBracket], wird aus dem Ausdruck nach dem Zeichen [=] abgeleitet.

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]. Zahlen werden unabhängig von der Systemsprache mit Dezimalpunkt geschrieben; so ist die Datei auf allen Rechnern lesbar. Die Werte stammen aus dem Steuertarif 2004 für die Einkünfte des Jahres 2003 und wurden unverändert übernommen: Es handelt sich um eine Übung. Die Klasse [FileTax] sieht wie folgt aus:

package dao

import entities.ErrorCode.ACCESS
import entities.ErrorCode.FIELD1
import entities.ErrorCode.FIELD2
import entities.ErrorCode.FIELD3
import entities.ErrorCode.LINE
import entities.TaxException
import entities.TaxBracket
import java.io.IOException
import java.math.BigDecimal
import java.nio.file.NoSuchFileException
import kotlin.io.path.Path
import kotlin.io.path.exists
import kotlin.io.path.readLines

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

    // Steuerstufen, gelesen bei der Konstruktion des Objekts
    override val taxBrackets: List<TaxBracket>

    init {
        // Lesen der Datei (relativ zum aktuellen Ordner): eine Liste von Zeilen
        val lines = try {
            val path = Path(fileName)
            if (!path.exists()) {
                throw NoSuchFileException(fileName, null, "The file [$fileName] does not exist")
            }
            path.readLines()
        } catch (e: IOException) {
            // Dateizugriffsfehler: er wird in eine TaxException verpackt
            throw TaxException("Error while reading the file $fileName", e, ACCESS.bit)
        }
        // eine Stufe pro nicht leerer Zeile; die Zeilen werden ab 1 nummeriert
        taxBrackets = lines.withIndex()
            .filter { it.value.isNotBlank() }
            .map { (index, line) -> bracket(index + 1, line.trim()) }
    }

    // die durch eine Zeile beschriebene Stufe oder eine TaxException, wenn die Zeile fehlerhaft ist
    private fun bracket(lineNumber: Int, line: String): TaxBracket {
        // in Felder aufgeteilte Zeile, getrennt durch : (möglicherweise mit Leerzeichen davor und danach)
        val fields = line.split(SEPARATOR)
        if (fields.size != 3) {
            throw TaxException("Line no. $lineNumber is incorrect: [$line]", code = LINE.bit)
        }
        // Konvertierungen der 3 Felder: null bei fehlerhaftem Feld
        val (limit, coeffR, coeffN) = fields.map(::number)
        if (limit == null || coeffR == null || coeffN == null) {
            // jedes fehlerhafte Feld fügt dem Code sein Bit hinzu
            var code = 0
            if (limit == null) code = code or FIELD1.bit
            if (coeffR == null) code = code or FIELD2.bit
            if (coeffN == null) code = code or FIELD3.bit
            throw TaxException("Line no. $lineNumber is incorrect: [$line]", code = code)
        }
        // die drei Felder sind korrekt: hier sind sie vom Typ BigDecimal und nicht BigDecimal?
        return TaxBracket(limit, coeffR, coeffN)
    }

    companion object {
        // das Feldtrennzeichen und die Form einer Zahl (reguläre Ausdrücke)
        private val SEPARATOR = Regex("""\s*:\s*""")
        private val NUMBER = Regex("""\d+(\.\d+)?""")

        // eine mit Ziffern und Dezimalpunkt geschriebene positive Zahl oder null; null, wenn fehlerhaft
        private fun number(field: String): BigDecimal? =
            if (NUMBER.matches(field)) field.toBigDecimal() else null
    }
}
  • Zeilen 3–7: Kotlin kennt keine statischen Importe ([import static] aus Java): Die normale [import]-Direktive importiert Klassen, Enumerationswerte und Funktionen gleichermaßen. Wir schreiben dann [FIELD1] statt [ErrorCode.FIELD1];
  • Zeilen 13–15: die Funktionen des Pakets [kotlin.io.path] (Kapitel 5), die die Java-Funktionen der API und von NIO ergänzen;
  • Zeile 19: Der primäre Konstruktor erhält den Namen der Datei mit den Steuerstufen. Da er als [val] deklariert ist, ist dieser Parameter zugleich eine öffentliche, schreibgeschützte Eigenschaft, [fileName]: Sie ersetzt das Feld und die Methode [getFileName] der Java-Version;
  • Zeile 22: die Eigenschaft der Schnittstelle. Sie wird in ihrer Deklaration nicht initialisiert: Der Compiler prüft, dass ihr im folgenden [init]-Block ein Wert zugewiesen wird – und zwar nur einmal;
  • Zeilen 24–39: Der Block [init] wird bei der Konstruktion des Objekts ausgeführt. Er liest die Datei und extrahiert anschließend die Stufen daraus;
  • Zeilen 26–34: In Kotlin ist [try] ein Ausdruck: Sein Wert ist entweder der des letzten Ausdrucks im [try]***-Block – hier die Liste der Zeilen der Datei – oder der des [catch] -Blocks. Der Block [catch] löst eine Ausnahme aus: Sein Typ ist [Nothing], der Typ von Ausdrücken, die nie einen Wert liefern, und die Variable [lines] hat den Typ [List<String>]*;
  • Zeile 27: Die Funktion [Path] aus [kotlin.io.path] erzeugt den Dateipfad; sie entspricht [Path.of]. Ein relativer Pfad bezieht sich auf das aktuelle Verzeichnis;
  • Zeilen 28–29: Existiert die Datei nicht, wird eine [NoSuchFileException] (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 diese Prüfung würde der Lesevorgang selbst eine [NoSuchFileException] auslösen, deren Meldung nur aus dem Dateinamen bestünde;
  • Zeile 31: Die Erweiterungsfunktion [readLines] liest die gesamte Datei in UTF-8 und liefert eine Liste ihrer Zeilen. Sie öffnet und schließt die Datei selbst. Bei einer großen Datei würden wir ein datenstrombasiertes Lesen mit [useLines] bevorzugen;
  • Zeilen 32–34: Alle Ein-/Ausgabefehler stammen von [IOException] ab: fehlende Datei ([NoSuchFileException]), unzureichende Berechtigungen ([AccessDeniedException]), Datei nicht im UTF-8-Format ([MalformedInputException]) usw. Der Fehler wird in eine [TaxException] mit dem Code [ACCESS] eingebettet; die ursprüngliche Ausnahme bleibt als Ursache erhalten (zweites Argument);
  • Zeilen 37–39: Das Lesen der Zeilen und ihre Analyse sind getrennte Operationen, was in Java nicht der Fall war. [withIndex] ordnet jeder Zeile ihren Index (beginnend bei 0) in einem Objekt [IndexedValue] mit den Eigenschaften [index] und [value] zu; [filter] entfernt leere Zeilen oder Zeilen, die nur aus Leerzeichen bestehen ([isNotBlank]), ohne die Indizes der übrigen zu verlieren; [map] wandelt jede der verbleibenden Zeilen in eine Stufe um. Die Lambda-Funktion von [map] entpackt ihren Parameter [IndexedValue] in seine beiden Komponenten, [(index, line)]. Die Zeilennummer, [index + 1], und die Zeile ohne führende und nachfolgende Leerzeichen ([trim]) werden an die Funktion [bracket] übergeben. Das Ergebnis von [map] ist eine schreibgeschützte [List];
  • Zeile 43: die Funktion, die die von einer Zeile beschriebene Stufe liefert oder eine [TaxException] auslöst, wenn die Zeile ungültig ist. Diese Ausnahme ist keine [IOException]: Sie wird unverändert an den Aufrufer weitergegeben;
  • Zeile 45: Die Zeile wird von [split] mithilfe des regulären Ausdrucks [SEPARATOR] zerlegt: Der Trenner ist ein Doppelpunkt, der von Leerzeichen umgeben sein darf. Achtung: In Kotlin zerlegt ***[split(":")]** mit einer Zeichenkette die Zeichenkette selbst, ohne sie als regulären Ausdruck zu interpretieren; dafür müssen Sie ein *[Regex] -Objekt übergeben;
  • Zeilen 46–47: Eine Zeile, die nicht drei Felder hat, ist ungültig. Der Fehlercode wird über ein benanntes Argument übergeben, [code = LINE.bit]: Es gibt keine Ursache, und der Parameter [cause] behält seinen Standardwert, [null];
  • Zeile 50: Umwandlung der drei Felder. [fields.map(::number)] wendet die Funktion [number] auf jedes Feld an ([::number] ist eine Funktionsreferenz; siehe Kapitel 7) und liefert eine Liste aus drei [BigDecimal?]-Werten, die die Destrukturierungszuweisung auf drei Variablen verteilt;
  • Zeilen 51–57: Ist ein Feld fehlerhaft, fügt jedes fehlerhafte Feld mit der Infix-Funktion [or] sein Bit zum Fehlercode hinzu, und es wird eine [TaxException] ausgelöst. Ihre Meldung nennt die Zeilennummer und den Inhalt der Zeile;
  • Zeile 60: An dieser Stelle weiß der Compiler, dass [limit], [coeffR] und [coeffN] nicht [null] sind; andernfalls hätte das vorherige [if] eine Ausnahme ausgelöst. Durch Smart Casts werden diese Variablen vom Typ [BigDecimal?] als [BigDecimal] behandelt, dem Typ, den der Konstruktor von [TaxBracket] erwartet: Weder [!!] noch irgendeine Umwandlung ist nötig;
  • Zeilen 65–66: Die beiden regulären Ausdrücke werden einmalig im Companion-Objekt erzeugt, nicht bei jedem Aufruf. Sie sind als Raw Strings geschrieben (["""..."""]), in denen der Backslash nicht verdoppelt werden muss: [\s*] steht für null oder mehr Leerzeichen;
  • Zeilen 69–70: Umwandlung eines Feldes in [BigDecimal]. [NUMBER.matches(field)] prüft, dass die gesamte Zeichenkette zum regulären Ausdruck [\d+(\.\d+)?] passt: eine oder mehrere Ziffern, optional gefolgt von einem Punkt und weiteren Ziffern. „0,191“ wird somit abgelehnt, ebenso jede negative Zahl. Die Funktion [toBigDecimal] hängt nicht von der Sprache des Benutzers ab: Sie erwartet stets einen Dezimalpunkt. Im Fehlerfall liefert die Funktion [null], daher ihr Typ [BigDecimal?]. Wir hätten [toBigDecimalOrNull] verwenden können, das für eine ungültige Zeichenkette [null] liefert, aber auch „-1“ oder „1e3“ akzeptiert.

6.3.4. Die Schicht [business]

Sehen wir uns die Schnittstelle dieser Schicht noch einmal an:

1
2
3
4
5
6
7
package business

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

    fun calculateTax(married: Boolean, nbChildren: Int, salary: Int): Int
}

Ihre Implementierung, [TaxBusiness], sieht wie folgt aus:

package business

import dao.ITaxDao
import java.math.BigDecimal
import java.math.MathContext

// die [business]-Schicht erhält die [dao]-Schicht über ihren Konstruktor
class TaxBusiness(dao: ITaxDao) : ITaxBusiness {

    // die Steuerstufen, einmalig bei der [dao]-Schicht angefordert
    private val brackets = dao.taxBrackets

    // Steuerberechnung
    override fun calculateTax(married: Boolean, nbChildren: Int, salary: Int): Int {
        // Überprüfung der Parameter
        require(nbChildren >= 0) { "nbChildren ($nbChildren) must be positive or zero" }
        require(salary >= 0) { "salary ($salary) must be positive or zero" }
        // Anzahl der Anteile: die Operatoren + und * von BigDecimal sind exakt
        var shares = nbChildren.toBigDecimal() * HALF + (if (married) 2 else 1).toBigDecimal()
        if (nbChildren >= 3) {
            shares += HALF
        }
        // zu versteuerndes Einkommen und Familienquotient
        val income = ALLOWANCE * salary.toBigDecimal()
        val qf = income.divide(shares, MathContext.DECIMAL128)
        // die Stufe: die erste, deren Grenze größer oder gleich QF ist,
        // die letzte, wenn keine passt (ihre Grenze wird nicht verwendet)
        val bracket = brackets.dropLast(1).firstOrNull { qf <= it.limit } ?: brackets.last()
        // Steuer (ganzzahliger Anteil)
        return (income * bracket.coeffR - shares * bracket.coeffN).toInt()
    }

    private companion object {
        // ein halber Anteil und der Koeffizient, der aus dem Gehalt das zu versteuernde Einkommen ergibt
        val HALF = BigDecimal("0.5")
        val ALLOWANCE = BigDecimal("0.72")
    }
}
  • Zeile 8: Die Klasse [TaxBusiness] implementiert die Schnittstelle [ITaxBusiness]. Die Schicht [business] muss mit der Schicht [dao] zusammenarbeiten: Sie erhält daher über ihren primären Konstruktor eine Referenz [dao] auf das Objekt, das die Schnittstelle [ITaxDao] implementiert. Dieser Parameter ist nicht als [val] deklariert: Er wird nur während der Konstruktion des Objekts verwendet und wird nicht zur Eigenschaft;
  • Zeile 11: Bei der Konstruktion des Objekts fordert die Schicht [business] die Steuerstufen ein für alle Mal von der Schicht [dao] an und speichert sie in einer privaten, schreibgeschützten Eigenschaft. Ihr Typ, [List<TaxBracket>], wird abgeleitet. 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;
  • Zeile 14: die Implementierung der Funktion der Schnittstelle mit dem erforderlichen Schlüsselwort [override];
  • Zeilen 16–17: Die Schicht [business] vertraut ihren Aufrufern nicht. Die Funktion [require] der Standardbibliothek (Kapitel 3) löst eine [IllegalArgumentException] aus, wenn die Bedingung falsch ist; die Meldung der Ausnahme wird von dem Lambda berechnet, das nur im Fehlerfall ausgeführt wird. Die Meldung benennt den fehlerhaften Parameter;
  • Zeilen 19–21: die Anzahl der Anteile. [nbChildren.toBigDecimal()] wandelt die Ganzzahl in [BigDecimal] um. Eine Java-Klasse wie [BigDecimal] hat keine arithmetischen Operatoren, aber die Kotlin-Standardbibliothek fügt sie über Erweiterungsfunktionen hinzu, die mit [operator] gekennzeichnet sind (Kapitel 4): [a + b], [a - b], und [a * b] rufen [add], [subtract] und [multiply] auf, und [shares += HALF] wird in Java als [shares = shares.add(HALF)] geschrieben. Da ein [BigDecimal] unveränderlich ist, liefert jede Operation ein neues Objekt: Deshalb ist [shares] eine Variable ([var]). Die Anzahl der Kinder wird aus dem unten genannten Grund mit 0.5 multipliziert statt durch 2 geteilt: 3 Kinder ergeben 1.5 Anteile;
  • Zeilen 24–25: zu versteuerndes Einkommen und Familienquotient. Die Division durch die Anzahl der Anteile kann unendlich viele Nachkommastellen ergeben (etwa bei Division durch 3): Ohne angegebene Begrenzung würde die Methode [divide] dann eine [ArithmeticException] auslösen. [MathContext.DECIMAL128] begrenzt das Ergebnis auf 34 signifikante Stellen;
  • Zeile 28: Wir suchen unter allen Stufen außer der letzten ([dropLast(1)]) die erste Einkommensstufe, deren Schwelle größer oder gleich dem Familienquotienten ist. [firstOrNull] liefert das erste Element, das die Bedingung erfüllt, oder [null] , falls es keines gibt; der Elvis-Operator [?:] ersetzt dann [null] durch die letzte Stufe, [brackets.last()], deren Grenze (0) nicht verwendet wird. Die [BigDecimal]-Klassen implementieren die Schnittstelle [Comparable]: Kotlin übersetzt [qf <= it.limit] in [qf.compareTo(it.limit) <= 0]. Diese Zeile ersetzt die [for]-Schleife und das [break] der Java-Version;
  • Zeile 30: die Steuer. Die Funktion [toInt()] eines [BigDecimal] (die Java-Methode [intValue()]) liefert den ganzzahligen Anteil des Ergebnisses;
  • Zeilen 33–36: zwei Konstanten, die in einem privaten Companion-Objekt abgelegt sind. Sie können nicht als [const] deklariert werden: Das ist nur für primitive Typen und Zeichenketten möglich.

Ein Hinweis zum Operator [/]. Die Standardbibliothek definiert auch den Operator [/] für [BigDecimal], aber er ruft [divide(other, RoundingMode.HALF_EVEN)] auf: Das Ergebnis hat dieselbe Anzahl an Nachkommastellen wie der Dividend. So ergibt [3.toBigDecimal() / BigDecimal.TWO] den Wert 2, nicht 1.5, während [3.toBigDecimal().divide(BigDecimal.TWO)] tatsächlich 1.5 ergibt. Deshalb vermeidet der obige Code diesen Operator: Er multipliziert mit 0.5 und ruft [divide] explizit mit einem [MathContext] auf. Bei den Funktionen von [BigDecimal] sollte man stets genau wissen, was eine Divisionsoperation tut.

Früher war es üblich, vor der Suche die Grenze der letzten Stufe zu ändern (etwa mit [brackets[brackets.size - 1].limit = qf + 1]), damit die Suchschleife immer endet. Diese Anweisung änderte das von der Schicht [dao] gelieferte Array: ein Seiteneffekt auf Daten, die von allen Schichten gemeinsam genutzt werden. Das könnten wir hier nicht mehr schreiben: Die Eigenschaft [limit] eines [TaxBracket] ist schreibgeschützt, und auch die Liste mit den Stufen ist schreibgeschützt. Moderner Code nimmt einfach die letzte Stufe, wenn keine Grenze passt, ohne die erhaltenen Daten zu ändern.

6.3.5. Die Schicht [ui]

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

package ui

import business.ITaxBusiness

// der Konsolendialog mit dem Benutzer: er kennt nur die Schnittstelle der [business]-Schicht
object Dialog {

    // die an den Benutzer gestellte Frage
    private const val QUESTION =
        "Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: "

    // Hilfe, die bei fehlerhafter Eingabe angezeigt wird
    private val SYNTAX = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros
        """.trimIndent()

    // ein oder mehrere Leerzeichen
    private val SPACES = Regex("""\s+""")

    // Dialogschleife: Eingabe der Parameter, Berechnung, Anzeige
    fun run(business: ITaxBusiness) {
        while (true) {
            // wir fragen die Parameter der Steuerberechnung ab; null am Ende des Streams wird wie keine Eingabe behandelt
            print(QUESTION)
            val parameters = readlnOrNull()?.trim() ?: ""
            // noch etwas zu tun?
            if (parameters.isEmpty()) {
                break
            }
            // Überprüfung der Anzahl der Parameter
            val fields = parameters.split(SPACES)
            if (fields.size != 3) {
                println(SYNTAX)
                continue
            }
            // verheiratet
            val married = fields[0].lowercase()
            if (married != "y" && married != "n") {
                println("$SYNTAX\nIncorrect Married argument: type y or n")
                continue
            }
            // Anzahl der Kinder: -1, wenn das Feld keine ganze Zahl ist
            val nbChildren = fields[1].toIntOrNull() ?: -1
            if (nbChildren < 0) {
                println("$SYNTAX\nIncorrect NbChildren argument: type a positive or zero integer")
                continue
            }
            // salary
            val salary = fields[2].toIntOrNull() ?: -1
            if (salary < 0) {
                println("$SYNTAX\nIncorrect Salary argument: type a positive or zero integer")
                continue
            }
            // die Parameter sind korrekt: wir fordern die Berechnung von der [business]-Schicht an
            println("Tax=${business.calculateTax(married == "y", nbChildren, salary)} euros")
        }
    }
}
  • Zeile 6: Der Dialog hat keinen eigenen Zustand. In Java haben wir dafür eine Klasse namens [final] mit einem privaten Konstruktor erstellt, die nur statische Member enthält. Kotlin verwendet hierfür die Objektdeklaration ([object], Kapitel 4): [Dialog] ist zugleich eine Klasse und ihre einzige Instanz, die bei der ersten Verwendung erzeugt wird. Ihre Funktionen werden wie statische Methoden aufgerufen: [Dialog.run(business)];
  • Zeilen 9–10: die an den Benutzer gestellte Frage, eine private Konstante ([const val]);
  • Zeilen 13–18: Der Hilfetext ist ein Raw String, der durch drei Anführungszeichen begrenzt wird. Er kann sich über mehrere Zeilen erstrecken; [trimIndent] (Kapitel 5) entfernt die gemeinsame Einrückung der Zeilen sowie die erste und die letzte Zeile, wenn sie leer sind: Der Text beginnt und endet nicht mit einem Zeilenumbruch. Das Ergebnis von [trimIndent] wird zur Laufzeit berechnet: Die Zeichenkette kann nicht als [const] deklariert werden;
  • Zeile 24: Die Funktion [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 27–28: Die Frage wird mit [print] ohne Zeilenumbruch angezeigt, und anschließend liest [readlnOrNull] eine Zeile von der Tastatur. Am Ende des Eingabestroms liefert es [null] ; der sichere Aufruf von [?.trim()] liefert dann ebenfalls [null], was der Elvis-Operator durch die leere Zeichenkette ersetzt: Das Ende des Datenstroms beendet den Dialog genauso wie eine leere Zeile;
  • Zeile 34: Die eingegebene Zeile wird an Leerzeichen zerlegt; der reguläre Ausdruck [\s+] (ein oder mehr Leerzeichen) ignoriert mehrfache Leerzeichen;
  • Zeilen 40–41: In Kotlin vergleicht der Operator [] (und [!=]) den Inhalt von Zeichenketten: Er ruft [equals]* auf. Der Operator *[=] vergleicht Referenzen. Die Java-Falle, bei der [==] Referenzen vergleicht, gibt es nicht;
  • Zeilen 46–54: Die Anzahl der Kinder und das Gehalt müssen positive Ganzzahlen oder null sein. [toIntOrNull] liefert [null] , wenn das Feld keine Ganzzahl ist, und der Elvis-Operator ersetzt dann [null] durch -1. Eine negative Zahl und eine ungültige Eingabe werden so durch dieselbe Prüfung abgelehnt. Die Methode [integer] der Java-Version samt ihren [try]/[catch]-Varianten für [NumberFormatException] ist überflüssig geworden;
  • Zeile 58: Die Parameter sind korrekt: Die Berechnung wird von der Schicht [business] angefordert. Der Aufruf steht direkt im String-Template, zwischen [${...}].

6.3.6. Integration der Schichten

Es bleibt noch, die Schichten zu erstellen und miteinander zu verbinden. Dies ist die Aufgabe des Hauptprogramms [Main.kt]:

import dao.FileTax
import dao.HardwiredTax
import dao.ITaxDao
import entities.ErrorCode
import entities.TaxException
import business.ITaxBusiness
import business.TaxBusiness
import ui.Dialog
import kotlin.system.exitProcess

// 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)
fun main(args: Array<String>) {
    val source = args.firstOrNull() ?: "TaxData.txt"
    val business: ITaxBusiness = try {
        // Erstellung der [dao]-Schicht
        val dao: ITaxDao = if (source == "hardwired") HardwiredTax() else FileTax(source)
        // Erstellung der [business]-Schicht, die die [dao]-Schicht erhält
        TaxBusiness(dao)
    } catch (e: TaxException) {
        // Anzeige des Fehlers und Beenden des Programms mit Exit-Code 1
        val origin = e.cause?.let { ", original exception: ${it.message}" } ?: ""
        println("The following error occurred: [Code=${ErrorCode.names(e.code)}, " +
            "Message=${e.message}$origin]")
        exitProcess(1)
    }

    // die [ui]-Schicht: der Dialog mit dem Benutzer
    Dialog.run(business)
}
  • Zeilen 1–9: Die Datei enthält keine [package]-Direktive; ihre Importe bezeichnen die Klassen aus den vier anderen Paketen;
  • Zeile 14: Die Funktion [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, mit [TaxData.txt] als Standardwert;
  • Zeile 15: [firstOrNull] liefert das erste Argument oder [null] , falls es keines gibt; der Elvis-Operator ersetzt Letzteres durch den Standarddateinamen;
  • Zeile 16: Die Variable [business] wird mit einem [try]-Ausdruck initialisiert. Ihr Typ ist ausdrücklich angegeben: Es ist die Schnittstelle [ITaxBusiness], nicht die Klasse [TaxBusiness], die sich durch Typinferenz ergäbe;
  • Zeile 18: Erstellung der Schicht [dao]. [if] ist ein Ausdruck: Sein Wert ist die eine oder die andere der beiden Implementierungen. Dies ist die einzige Stelle im Programm, an der die Klassen [HardwiredTax] und [FileTax] namentlich genannt werden;
  • Zeile 20: Erstellung der Schicht [business], die die Schicht [dao] erhält. Dies ist der letzte Ausdruck im [try]-Block und damit dessen Wert;
  • Zeilen 21–26: Die Erstellung der Schicht [dao] kann eine [TaxException] auslösen. Es wird dann ein Fehler ausgegeben, zusammen mit der Meldung der ursprünglichen Exception (falls vorhanden), und das Programm endet mit dem Exit-Code 1. Der Fehlercode wird mit der Funktion [ErrorCode.names] im Klartext ausgegeben. Ist [e.cause] nicht [null], [let] erstellt die Beschreibung der ursprünglichen Exception; andernfalls liefert der Elvis-Operator eine leere Zeichenkette;
  • Zeile 26: Die Funktion [exitProcess] aus der Standardbibliothek ruft [System.exit] auf. Ihr Rückgabetyp ist [Nothing]: Der Compiler weiß, dass sie die Kontrolle nie zurückgibt und der [catch]-Block somit keinen Wert liefert. Der Ausdruck [try] hat daher den Typ [ITaxBusiness]. In der Java-Version musste nach [System.exit(1)] eine – nie ausgeführte – [return]-Anweisung ergänzt werden, damit der Compiler erkannte, dass die Variable [business] initialisiert wurde;
  • Zeile 30: Die Schichten sind bereit: Die Schicht [ui] interagiert mit dem Benutzer.

6.3.7. Ausführungen

Aus dem Ordner des Kapitels heraus, mit der Datei [TaxData.txt] (Implementierung [FileTax]) und unter Prüfung der Validierung der Benutzereingaben (in den Ergebnissen dieses Kapitels wurden die Eingaben des Benutzers dem Programm per Eingabeumleitung übergeben und dann hinter den Fragen eingefügt, an der Stelle, an der der Benutzer sie eingibt):

> gradlew -q :TaxV4:run
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]. Die Programmargumente werden über die Option [--args] der Task [run] übergeben:

1
2
3
4
5
6
> gradlew -q :TaxV4:run --args="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:

> gradlew -q :TaxV4:run --args="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 ist [ACCESS], und die Meldung der ursprünglichen Exception, [NoSuchFileException], wird angezeigt: Sie besteht aus dem Dateinamen, gefolgt von dem Grund, der ihrem Konstruktor übergeben wurde. Das Programm endet mit dem Exit-Code 1: Gradle meldet dann das Scheitern der Task [run] mit einigen zusätzlichen Zeilen, die wir hier nicht wiedergeben.

Mit der folgenden Datei [TaxDataInvalid.txt], in der Zeile 3 mit Dezimalkommas geschrieben ist:

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

erhalten wir:

> gradlew -q :TaxV4:run --args="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 der Zeile 3 sind fehlerhaft: Der Fehlercode kombiniert die Bits von [FIELD2] und [FIELD3], und die Funktion [ErrorCode.names] zeigt ihn als „FIELD2, FIELD3“ an.

6.3.8. Fazit

Die Schichtenarchitektur und der Einsatz von Schnittstellen haben unserer Anwendung ein gewisses Maß an Flexibilität verschafft. Das zeigt sich daran, wie das Hauptprogramm die Schichten [dao] und [business] erstellt:

1
2
3
4
        // Erstellung der [dao]-Schicht
        val dao: ITaxDao = if (source == "hardwired") HardwiredTax() else FileTax(source)
        // Erstellung der [business]-Schicht, die die [dao]-Schicht erhält
        TaxBusiness(dao)

Ein Wechsel der Implementierung der Schicht [dao] betrifft nur Zeile 2. Sobald die Schichten erstellt sind, ist der Code der Schicht [ui] in beiden Fällen identisch: 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 auf der Grundlage einer Referenz auf die Schnittstelle der Schicht [dao] aufgebaut. Ein Wechsel der Implementierung Letzterer 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, mit den folgenden Änderungen:

  • Die Schichten [dao] und [business] werden jeweils in einem Gradle-Teilprojekt untergebracht, das eine Bibliothek (eine JAR-Datei) erzeugt, und mit dem Unit-Test-Framework JUnit getestet;
  • Die Schicht [dao] erhält eine dritte Implementierung, [JsonTax], die die Steuerstufen mithilfe 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 über eine 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 der anderen Entwickler an den 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]. Bis diese Implementierung fertig ist, kann der Entwickler eine Attrappe der Schicht [dao] verwenden, sofern sie die Schnittstelle [ITaxDao] einhält. Dies ist ein weiterer Vorteil der Schichtenarchitektur: Eine Verzögerung bei der Schicht [dao] hindert nicht daran, die Schicht [business] zu testen. Die Mock-Implementierung hat außerdem den Vorteil, viel einfacher einzurichten zu sein als die tatsächliche 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] in Form einer Bibliothek (einer JAR-Datei) und nicht als zu kopierender Quellcode bereitgestellt. Letztlich wird die Anwendung als Hauptprogramm (das der Schicht [ui]) und Klassenbibliotheken (die übrigen Schichten) ausgeliefert.

6.4.1. Die Gradle-Teilprojekte der Version 5

Version 5 besteht aus drei Teilprojekten des Gradle-Builds des Kapitels, eines pro Schicht, die im Ordner [TaxV5] liegen. Die Tests bilden kein eigenes Projekt: Die Gradle-Konvention (dieselbe wie bei Maven) legt die Tests eines Teilprojekts in dessen Ordner [src/test/kotlin] ab. Sie werden von Gradle kompiliert und ausgeführt, sind aber nicht Teil der JAR-Datei des Teilprojekts. Daraus ergibt sich die folgende Verzeichnisstruktur:

TaxV5/
  tax-dao/                         subproject: entities and [dao] layer (jar)
    build.gradle.kts
    TaxData.txt
    TaxData.json
    TaxDataInvalid.txt             an incorrect bracket file, for the tests
    src/main/kotlin/tax/entities/
      TaxBracket.kt
      TaxException.kt
    src/main/kotlin/tax/dao/
      ITaxDao.kt
      HardwiredTax.kt
      FileTax.kt
      JsonTax.kt
    src/test/kotlin/tax/dao/
      DaoTests.kt                  JUnit tests
      TrialDao.kt                  trial program
  tax-business/                    subproject: [business] layer (jar)
    build.gradle.kts
    src/main/kotlin/tax/business/
      ITaxBusiness.kt
      TaxBusiness.kt
    src/test/kotlin/tax/business/
      BusinessTests.kt             JUnit tests
      TrialBusiness.kt             trial program
  tax-ui/                          subproject: [ui] layer and integration of the layers
    build.gradle.kts
    tax.properties                 configuration files
    tax-json.properties
    tax-hardwired.properties
    tax-error.properties
    tax-beans.xml                  Spring XML configuration
    tax-beans-error.xml
    TaxData.txt
    TaxData.json
    src/main/kotlin/tax/ui/
      Dialog.kt
      Main.kt
      MainXml.kt
      TaxConfig.kt
      MainConfig.kt

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

Der Ordner [TaxV5] selbst hat keine Build-Datei: Er ist ein einfacher Gruppierungsordner, den Gradle als leeres Projekt [:TaxV5] behandelt, als Elternprojekt der drei Teilprojekte [:TaxV5:tax-dao], [:TaxV5:tax-business] und [:TaxV5:tax-ui], die in der Datei [settings.gradle.kts] dieses Kapitels deklariert sind. Während Maven ein Elternprojekt benötigt, um Module zu gruppieren, genügt Gradle diese Datei. Jedes Teilprojekt hat seine eigene Datei [build.gradle.kts], die wir zusammen mit der jeweiligen Schicht besprechen. Diese Dateien wiederholen einige Zeilen (das Repository Maven Central, die Compiler-Konfiguration und die Testeinrichtung); in einem größeren Projekt würden wir diese Zeilen in einem Convention-Plugin ([buildSrc]-Ordner) bündeln und die Bibliotheksversionen in einem Version Catalog ([gradle/libs.versions.toml]) zusammenfassen.

Die Anwendung wird mit dem folgenden Befehl erstellt und getestet, der im Ordner des Kapitels eingegeben wird:

> gradlew build

Gradle kompiliert jedes Teilprojekt, kompiliert und führt dessen Tests aus und erstellt anschließend seine JAR-Datei im Ordner [build/libs] des Teilprojekts – zum Beispiel [TaxV5/tax-dao/build/libs/tax-dao-5.0.jar]. Die Teilprojekte werden in der Reihenfolge verarbeitet, die ihre Abhängigkeiten vorgeben: [tax-dao], dann [tax-business], dann [tax-ui]. Schlägt ein Test fehl, bricht der Build ab. Der Befehl [gradlew :TaxV5:tax-business:build] erstellt nur das Teilprojekt [tax-business] … und die Teilprojekte, von denen es abhängt: Gradle weiß, dass [tax-business] [tax-dao] benötigt, und kompiliert Letzteres zuerst, falls es sich geändert hat (ohne seine Tests auszuführen). Anders als bei Maven gibt es kein lokales Repository, das durch einen Befehl [install] aktuell gehalten werden muss: Innerhalb eines Builds sind die Teilprojekte direkt füreinander sichtbar.

Die Anwendungen der Kapitel 10 bis 13 werden die Schichten aus Version 5 wiederverwenden, ohne deren Quellcode zu kopieren. Ihre Datei [settings.gradle.kts] wird den Build aus Kapitel 6 als Composite Build einbinden:

// der Build von Kapitel 6, dessen Unterprojekte die Bibliotheken mit denselben Koordinaten ersetzen
includeBuild("../06-architectures")

und ihre Dateien [build.gradle.kts] werden Abhängigkeiten zu [examples.tax:tax-business:5.0] und, für das Objekt [Dialog], zu [examples.tax:tax-ui:5.0] deklarieren, genau wie für Jackson oder Spring:

1
2
3
4
dependencies {
    implementation("examples.tax:tax-business:5.0")
    implementation("examples.tax:tax-ui:5.0")
}

Gradle erkennt die Teilprojekte anhand dieser Koordinaten (Gruppe [examples.tax], Name des Teilprojekts, Version [5.0]) im eingebundenen Build und verwendet sie anstelle einer heruntergeladenen Bibliothek: Es erstellt sie bei Bedarf, und eine Änderung an Version 5 spiegelt sich sofort in den nachfolgenden Versionen wider. Deshalb deklarieren die drei Teilprojekte die Gruppe [group = "examples.tax"] und die Version [version = "5.0"].

6.4.2. Die Schicht [dao]

Das Teilprojekt [tax-dao] enthält die Schicht [dao] und die Entitäten der Anwendung. Seine Datei [build.gradle.kts] sieht wie folgt aus:

// TaxV5: das Unterprojekt tax-dao, eine Bibliothek (die Entitäten und die [dao]-Schicht)
plugins {
    kotlin("jvm")
    // das Bibliotheks-Plugin: es fügt die Konfiguration [api] hinzu
    `java-library`
}

// die Koordinaten der Bibliothek: examples.tax:tax-dao:5.0
group = "examples.tax"
version = "5.0"

repositories {
    mavenCentral()
}

dependencies {
    // Jackson zum Lesen der JSON-Datei: eine interne Abhängigkeit der Bibliothek
    implementation("tools.jackson.core:jackson-databind:3.1.5")
    // die Tests
    testImplementation(kotlin("test"))
    testImplementation(platform("org.junit:junit-bom:6.0.3"))
    testImplementation("org.junit.jupiter:junit-jupiter")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

kotlin {
    jvmToolchain(25)
    compilerOptions {
        allWarningsAsErrors = true
        // Parameternamen bleiben erhalten: Jackson und JUnit verwenden sie
        javaParameters = true
    }
}

tasks.test {
    useJUnitPlatform()
    testLogging {
        events("passed", "skipped", "failed")
    }
}

// gradlew -q :TaxV5:tax-dao:trial : führt das Testprogramm aus, das bei den Tests liegt
tasks.register<JavaExec>("trial") {
    classpath = sourceSets["test"].runtimeClasspath
    mainClass = "tax.dao.TrialDaoKt"
}

// unter Windows wird die Bildschirmausgabe des von Gradle gestarteten Programms (run, bootRun ...) in UTF-8 kodiert,
// sonst werden Zeichen mit Akzenten in der IntelliJ-IDEA-Konsole oder im Terminal falsch dargestellt
tasks.withType<JavaExec>().configureEach {
    jvmArgs("-Dstdout.encoding=UTF-8", "-Dstderr.encoding=UTF-8")
}
  • Zeilen 2–5: Das Teilprojekt wendet das Kotlin-Plugin und das Plugin [java-library] an, das Plugin für Bibliotheken. Letzteres, von Gradle bereitgestellt, wird mit Backticks geschrieben, weil sein Name einen Bindestrich enthält. Es fügt die Abhängigkeitskonfiguration [api] hinzu, die das Teilprojekt [tax-business] verwenden wird;
  • Zeilen 9–10: die Koordinaten der Bibliothek, [examples.tax:tax-dao:5.0];
  • Zeile 18: die Bibliothek Jackson 3, die die JSON-Datei liest. Sie wird mit [implementation] deklariert: Das ist ein internes Detail der Schicht [dao], deren Typen in ihrer öffentlichen Schnittstelle nicht vorkommen. Ein Projekt, das von [tax-dao] abhängt, hat Jackson zur Laufzeit zur Verfügung, kann dessen Klassen aber nicht in seinem eigenen Code verwenden;
  • Zeilen 20–23: die Testabhängigkeiten, die wir zusammen mit den Tests vorstellen. Die Konfigurationen [testImplementation] und [testRuntimeOnly] dienen nur zum Kompilieren und Ausführen der Tests: Sie gehören nicht zu den Abhängigkeiten der erzeugten Bibliothek;
  • Zeilen 26–31: die Compiler-Konfiguration. Die im kompilierten Code beibehaltenen Parameternamen werden von Jackson verwendet, um die Eigenschaften des JSON den Konstruktorparametern von [TaxBracket] zuzuordnen, und von JUnit, um die parametrisierten Tests anzuzeigen;
  • Zeilen 35–38: die Konfiguration der Task [test], die wir zusammen mit den Tests vorstellen;
  • Zeilen 43–45: eine zusätzliche Task, [trial], vom Typ [JavaExec] (Ausführung einer Java-Klasse), die das weiter unten vorgestellte Testprogramm startet. Dieses Programm liegt bei den Tests: Sein Klassenpfad ([classpath]) ist daher der der Tests, [sourceSets["test"].runtimeClasspath], der die Hauptklassen, die Testklassen und alle Abhängigkeiten umfasst;
  • Zeilen 48–51: Von Gradle gestartete Programme schreiben ihre Ausgabe in UTF-8, damit akzentuierte Zeichen unter Windows korrekt angezeigt werden (Kapitel 2).

6.4.2.1. Die Entitäten

Die Datenklasse [TaxBracket] stammt aus Version 4 (Paket [tax.entities]). Die Enumeration [ErrorCode] entfällt, und die Exception [TaxException] wird zur Exception der gesamten Anwendung, unabhängig davon, welche Schicht sie auslöst:

package tax.entities

// die Exception der [Tax]-Anwendung, unabhängig von der Schicht, die sie wirft
// Kotlin kennt keine geprüften Exceptions: keine Funktion muss sie deklarieren
class TaxException(
    message: String,
    // die ursprüngliche Exception, falls vorhanden
    cause: Throwable? = null,
    // Fehlercode, spezifisch für die Klasse, die die Exception wirft (0: kein Code)
    val code: Int = 0,
) : RuntimeException(message, cause)
  • Zeile 10: Der Fehlercode bleibt eine einfache Ganzzahl: Jede Implementierung der Schicht [dao] definiert ihre eigenen Codes. Sein Standardwert 0 bedeutet „kein Code“;
  • Zeilen 6–10: Dank der Standardwerte akzeptiert dieser einzelne Konstruktor die vier Aufrufformen, für die die Java-Version vier Konstruktoren hatte: [TaxException(message)], [TaxException(message, cause)], [TaxException(message, code = 2)], und [TaxException(message, cause, 2)]. Wird der Code ohne Ursache übergeben, muss er benannt werden: Ohne den Namen würde der Compiler versuchen, die Ganzzahl dem Parameter [cause] zu übergeben. Man könnte die Klasse auch mit einem sekundären Konstruktor implementieren ([constructor(message: String, code: Int) : this(message, null, code)]), aber das benannte Argument macht den Aufruf lesbarer.

6.4.2.2. Die Implementierung [FileTax]

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

1
2
3
4
5
6
7
    companion object {
        // für diese Implementierung spezifische Fehlercodes: Zweierpotenzen, die kombiniert werden können
        const val ACCESS = 1
        const val LINE = 2
        const val FIELD1 = 4
        const val FIELD2 = 8
        const val FIELD3 = 16
  • Zeilen 3–7: Die Fehlercodes, die sich zuvor in der Enumeration [ErrorCode] im Entitätenpaket befanden, sind zu Konstanten in der Klasse [FileTax] geworden: Es handelt sich tatsächlich um Codes, die für diese Implementierung der Schnittstelle [ITaxDao] spezifisch sind ([JsonTax] hat eigene). Kotlin kennt keine statischen Member: Die Klassenkonstanten werden im Companion Object mit dem Schlüsselwort [const] deklariert, das sie zu Konstanten zur Kompilierzeit macht (das Äquivalent eines Java-Felds [static final]). Sie werden innerhalb der Klasse als [FIELD1] und außerhalb davon als [FileTax.FIELD1] geschrieben. Die Importe der Werte von [ErrorCode] aus Version 4 sind nicht mehr nötig.

Weiter oben in der Klasse:

        } catch (e: IOException) {
            // Dateizugriffsfehler: er wird in eine TaxException verpackt
            throw TaxException("Error while reading the file $fileName", e, ACCESS)
        }
        // eine Stufe pro nicht leerer Zeile; die Zeilen werden ab 1 nummeriert
        taxBrackets = lines.withIndex()
            .filter { it.value.isNotBlank() }
            .map { (index, line) -> bracket(index + 1, line.trim()) }
    }

    // die durch eine Zeile beschriebene Stufe oder eine TaxException, wenn die Zeile fehlerhaft ist
    private fun bracket(lineNumber: Int, line: String): TaxBracket {
        // in Felder aufgeteilte Zeile, getrennt durch : (möglicherweise mit Leerzeichen davor und danach)
        val fields = line.split(SEPARATOR)
        if (fields.size != 3) {
            throw TaxException("Line no. $lineNumber is incorrect: [$line]", code = LINE)
        }
        // Konvertierungen der 3 Felder: null bei fehlerhaftem Feld
        val (limit, coeffR, coeffN) = fields.map(::number)
        if (limit == null || coeffR == null || coeffN == null) {
            // jedes fehlerhafte Feld fügt seinen Code hinzu
            var code = 0
            if (limit == null) code = code or FIELD1
            if (coeffR == null) code = code or FIELD2
            if (coeffN == null) code = code or FIELD3
            throw TaxException("Line no. $lineNumber is incorrect: [$line]", code = code)
  • Zeile 3: Der Fehler beim Dateizugriff wird in eine [TaxException] mit der Ursache und dem Code [ACCESS] gekapselt;
  • Zeile 16: Eine Zeile, die nicht drei Felder hat, löst eine Exception mit dem Code [LINE] aus;
  • Zeilen 22–25: Die Codes sind Ganzzahlen, die direkt mit der Infix-Funktion [or] kombiniert werden.

6.4.2.3. Die Implementierung [JsonTax]

Wie Version 3 aus Kapitel 5 liest die dritte Implementierung der Schicht [dao] die Steuerstufen mithilfe 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.NoSuchFileException
import kotlin.io.path.Path
import kotlin.io.path.exists
import kotlin.io.path.readText
import tools.jackson.core.JacksonException
import tools.jackson.databind.json.JsonMapper

// eine [dao]-Schicht, die die Steuerstufen aus einer JSON-Datei liest
class JsonTax(val fileName: String) : ITaxDao {

    // Steuerstufen, gelesen bei der Konstruktion des Objekts
    override val taxBrackets: List<TaxBracket>

    init {
        // Lesen der Datei (relativ zum aktuellen Ordner)
        val json = try {
            val path = Path(fileName)
            if (!path.exists()) {
                throw NoSuchFileException(fileName, null, "The file [$fileName] does not exist")
            }
            path.readText()
        } catch (e: IOException) {
            throw TaxException("Error while reading the file $fileName", e, ACCESS)
        }
        // Deserialisierung des JSON-Arrays in ein Array von TaxBracket (null für den JSON-Text null)
        val message = "The file $fileName is not a valid JSON file of tax brackets"
        val brackets = try {
            JsonMapper.builder().build().readValue(json, Array<TaxBracket>::class.java)
        } catch (e: JacksonException) {
            throw TaxException(message, e, FORMAT)
        }
        taxBrackets = brackets?.toList() ?: throw TaxException(message, code = FORMAT)
    }

    companion object {
        // für diese Implementierung spezifische Fehlercodes
        const val ACCESS = 1
        const val FORMAT = 2
    }
}
  • Zeile 14: Wie [FileTax] erhält die Klasse den Dateinamen, der zur Eigenschaft [fileName] wird;
  • Zeilen 21–28: Die Datei wird wie in [FileTax] gelesen. Die Erweiterungsfunktion [readText] liest die gesamte Datei, ebenfalls in UTF-8, in eine Zeichenkette. Ein E/A-Fehler führt zu einer [TaxException] mit dem Code [ACCESS];
  • Zeilen 32–35: Deserialisierung (Kapitel 5). [JsonMapper.builder().build()] erstellt das Jackson-Objekt, das JSON in Objekte umwandelt, und seine Methode [readValue] liest den JSON-Text als Array von [TaxBracket]. Der Array-Typ wird als [Array<TaxBracket>::class.java] geschrieben: [::class] bezeichnet die Kotlin-Klasse ([KClass]) des Typs, und [.java] bezeichnet die entsprechende Java-Klasse, die Jackson erwartet. Um jede Stufe zu erstellen, ruft Jackson den Konstruktor der Datenklasse [TaxBracket] auf, wobei es die JSON-Eigenschaften [limit], [coeffR] und [coeffN] den Namen seiner Parameter zuordnet, die dank der Compiler-Option [javaParameters] erhalten bleiben. Die JSON-Zahlen werden in [BigDecimal], den Parametertyp, umgewandelt, ohne den Umweg über [Double]: Die Umwandlung ist exakt. Ein Syntax- oder Inhaltsfehler führt zu einer [JacksonException], die in eine [TaxException] mit dem Code [FORMAT] gekapselt wird;
  • Zeile 37: [readValue] ist eine Java-Methode: Kotlin weiß nicht, ob sie [null] zurückgeben kann, und weist ihrem Ergebnis einen Plattformtyp zu – in Compilermeldungen als [Array<TaxBracket>!] notiert –, der sowohl als nullable als auch als nicht nullable behandelt werden kann. Sie liefert tatsächlich [null] , wenn die Datei den JSON-Text [null] enthält: Der sichere Aufruf [?.toList()] und der Elvis-Operator verwandeln diesen Fall in eine [TaxException] mit dem Code [FORMAT]. Andernfalls wandelt [toList] das Array in eine schreibgeschützte Liste um;
  • Zeilen 42–43: die Fehlercodes dieser Implementierung.

In Kapitel 5 wurde das Modul [jackson-module-kotlin] erwähnt, das Jackson über die Besonderheiten von Kotlin informiert (Standardwerte von Parametern, nullable Typen), sowie die Bibliothek kotlinx.serialization von JetBrains. Unsere einfache Datenklasse benötigt sie nicht.

6.4.2.4. Ein Testprogramm

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

package tax.dao

import tax.entities.TaxException

// Testprogramm: die von den drei Implementierungen der [dao]-Schicht gelieferten Steuerstufen
fun main() {
    try {
        val daos = listOf(HardwiredTax(), FileTax("TaxData.txt"), JsonTax("TaxData.json"))
        for (dao in daos) {
            println("--- ${dao::class.simpleName}")
            dao.taxBrackets.forEach(::println)
        }
    } catch (e: TaxException) {
        // Anzeige des Fehlers
        val origin = e.cause?.let { ", original exception: ${it.message}" } ?: ""
        println("The following error occurred: [Code=${e.code}, Message=${e.message}$origin]")
    }
}
  • Zeile 6: eine Funktion [main] auf oberster Ebene ohne Parameter im Paket [tax.dao]: Ihre Klasse ist [tax.dao.TrialDaoKt]. Da das Programm im selben Paket wie die getesteten Klassen liegt, verwendet es sie, ohne sie zu importieren;
  • Zeile 8: eine Liste der drei Implementierungen der Schnittstelle [ITaxDao]. Der Compiler leitet den spezifischsten Typ ab, der allen drei Elementen gemeinsam ist: [List<ITaxDao>];
  • Zeile 10: [dao::class] liefert die tatsächliche Klasse des Objekts, deren Name (ohne Paket) [simpleName] ist;
  • Zeile 11: Jede Steuerstufe wird an die Funktion [println] übergeben (Funktionsreferenz [::println]), die sie mit ihrer Funktion [toString] ausgibt, welche der Compiler für eine Datenklasse generiert;
  • Zeilen 13–16: Behandlung einer möglichen [TaxException].

Das Programm wird mit dem Ordner des Teilprojekts [tax-dao] als aktuellem Ordner über die in der Build-Datei deklarierte Task [trial] ausgeführt:

> gradlew -q :TaxV5:tax-dao:trial
--- 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 Steuerstufen. Die Funktion [toString] einer Datenklasse zeigt den Klassennamen gefolgt von ihren Eigenschaften in runden Klammern an (ein Java-Record zeigte sie in eckigen Klammern an); die Funktion [BigDecimal] schreibt stets einen Dezimalpunkt, unabhängig von der Sprache des Benutzers. In IntelliJ IDEA wird das Programm auch über das grüne Dreieck vor seiner Funktion [main] gestartet.

6.4.3. Die Schicht [business]

Die Datei [build.gradle.kts] des Teilprojekts [tax-business] sieht wie folgt aus:

// TaxV5: das Unterprojekt tax-business, eine Bibliothek (die [business]-Schicht)
plugins {
    kotlin("jvm")
    `java-library`
}

// die Koordinaten der Bibliothek: examples.tax:tax-business:5.0
group = "examples.tax"
version = "5.0"

repositories {
    mavenCentral()
}

dependencies {
    // die [business]-Schicht verwendet die [dao]-Schicht, die Teil ihrer API ist:
    // der Konstruktor von TaxBusiness erhält ein ITaxDao
    api(project(":TaxV5:tax-dao"))
    // die Tests
    testImplementation(kotlin("test"))
    testImplementation(platform("org.junit:junit-bom:6.0.3"))
    testImplementation("org.junit.jupiter:junit-jupiter")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

kotlin {
    jvmToolchain(25)
    compilerOptions {
        allWarningsAsErrors = true
        javaParameters = true
    }
}

tasks.test {
    useJUnitPlatform()
    testLogging {
        events("passed", "skipped", "failed")
    }
}

// gradlew -q :TaxV5:tax-business:trial : führt das Testprogramm aus, das bei den Tests liegt
tasks.register<JavaExec>("trial") {
    classpath = sourceSets["test"].runtimeClasspath
    mainClass = "tax.business.TrialBusinessKt"
}

// unter Windows wird die Bildschirmausgabe des von Gradle gestarteten Programms (run, bootRun ...) in UTF-8 kodiert,
// sonst werden Zeichen mit Akzenten in der IntelliJ-IDEA-Konsole oder im Terminal falsch dargestellt
tasks.withType<JavaExec>().configureEach {
    jvmArgs("-Dstdout.encoding=UTF-8", "-Dstderr.encoding=UTF-8")
}
  • Zeile 18: Die Schicht [business] verwendet die Schicht [dao]. Die Notation [project(":TaxV5:tax-dao")] verweist über ihren Pfad auf ein anderes Teilprojekt der Struktur. Die Abhängigkeit wird mit [api] und nicht mit [implementation] deklariert: Die Schnittstelle [ITaxDao] erscheint in der öffentlichen API der Schicht [business], da der Konstruktor von [TaxBusiness] ein [ITaxDao] erhält. Ein Projekt, das von [tax-business] abhängt, sollte daher in seinem Code die Typen aus [tax-dao] verwenden können: Mit [api] erhält es sie automatisch, ohne die Abhängigkeit zu [tax-dao] selbst deklarieren zu müssen. Jackson, das in [tax-dao] mit [implementation] deklariert ist, ist nur zur Laufzeit enthalten;
  • Zeilen 42–44: die Task [trial] dieses Teilprojekts;
  • Zeilen 47–50: Von Gradle gestartete Programme schreiben ihre Ausgabe in UTF-8, damit akzentuierte Zeichen unter Windows korrekt angezeigt werden (Kapitel 2).

Die Schnittstelle [ITaxBusiness] und die Klasse [TaxBusiness] stammen aus Version 4 (Paket [tax.business]). Das Testprogramm [TrialBusiness.kt], das in den Testquellen des Teilprojekts liegt, führt einige Steuerberechnungen durch:

package tax.business

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

// Testprogramm: einige Steuerberechnungen mit der [dao]-Schicht FileTax
fun main() {
    try {
        // die Stufendatei ist die des Unterprojekts tax-dao (Pfad relativ zum aktuellen Ordner)
        val business: ITaxBusiness = TaxBusiness(FileTax("../tax-dao/TaxData.txt"))
        println("Tax(true,2,60000)=${business.calculateTax(true, 2, 60000)} euros")
        println("Tax(false,3,60000)=${business.calculateTax(false, 3, 60000)} euros")
        println("Tax(false,3,6000)=${business.calculateTax(false, 3, 6000)} euros")
        println("Tax(false,3,600000)=${business.calculateTax(false, 3, 600000)} euros")
    } catch (e: TaxException) {
        // Anzeige des Fehlers
        val origin = e.cause?.let { ", original exception: ${it.message}" } ?: ""
        println("The following error occurred: [Code=${e.code}, Message=${e.message}$origin]")
    }
}
  • Zeile 10: Erstellung 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 Teilprojekts [tax-dao];
  • Zeilen 11–14: wiederholte Aufrufe der einzigen Funktion der Schnittstelle [ITaxBusiness].

Ergebnisse:

1
2
3
4
5
> gradlew -q :TaxV5:tax-business:trial
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 verheiratetes Paar mit 2 Kindern und eine alleinstehende Person mit 3 Kindern haben dieselbe Anzahl an Anteilen (3): Ihre Steuern sind gleich.

6.4.4. Unit-Tests mit JUnit

6.4.4.1. Das Prinzip

Die bisher durchgeführten Tests beruhten auf visueller Kontrolle: Wir haben geprüft, ob der Bildschirm die erwarteten Ergebnisse anzeigte. Diese Methode ist unpraktikabel, wenn viele Tests auszuführen sind: Menschen ermüden, und ihre Fähigkeit, Ergebnisse zu überprüfen, lässt im Laufe des Tages nach. Die Tests müssen daher automatisiert werden und ohne menschliches Eingreifen auskommen.

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

Zur Automatisierung dieser Tests wurden Test-Frameworks entwickelt. Für die JVM ist das Referenz-Framework JUnit, das Ende der 1990er-Jahre von Kent Beck und Erich Gamma geschaffen wurde. Es kann sowohl in Kotlin als auch in Java verwendet werden. Wir verwenden Version 6, die im September 2025 erschienen ist (hier Version 6.0.3); ihre API, die des Pakets [org.junit.jupiter.api], ist dieselbe wie bei JUnit 5, auch JUnit Jupiter genannt. Kotlin ergänzt seine eigene Testbibliothek, kotlin.test: eine Sammlung von für Kotlin geschriebenen Assertions ([assertEquals], [assertFailsWith], [assertIs] …), die ihre Arbeit an das jeweils verwendete Test-Framework delegieren, hier an JUnit. Die Tests werden über die Kommandozeile mit dem Befehl [gradlew test] ausgeführt: Dadurch lassen sie sich automatisch starten, zum Beispiel bei jedem Push von Codeänderungen an einen Continuous-Integration-Server. IntelliJ IDEA führt sie ebenfalls aus und zeigt ihre Ergebnisse in einer Baumstruktur an. Kotest ist ein weiteres, für Kotlin geschriebenes Test-Framework, das nach demselben Prinzip arbeitet.

6.4.4.2. Ein erstes Beispiel

Betrachten wir das Prinzip der JUnit-Tests anhand eines Beispiels. Das Teilprojekt [DemoTests] enthält nur Tests, die im Ordner [src/test/kotlin/demotests] liegen. Seine Datei [build.gradle.kts] sieht wie folgt aus:

// DemoTests: ein Projekt, das nur JUnit-Tests enthält
plugins {
    kotlin("jvm")
}

group = "examples.architectures"
version = "1.0"

repositories {
    mavenCentral()
}

dependencies {
    // die Kotlin-Assertions (kotlin.test), an JUnit angebunden
    testImplementation(kotlin("test"))
    // JUnit: die Stückliste (BOM) legt die Version aller seiner Module fest
    testImplementation(platform("org.junit:junit-bom:6.0.3"))
    // die Test-API und die JUnit-Jupiter-Engine, die sie ausführt
    testImplementation("org.junit.jupiter:junit-jupiter")
    // der JUnit-Platform-Launcher, der von Gradle verwendet wird
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
}

kotlin {
    jvmToolchain(25)
    compilerOptions {
        allWarningsAsErrors = true
        // Parameternamen bleiben erhalten: JUnit zeigt sie bei parametrisierten Tests an
        javaParameters = true
    }
}

tasks.test {
    // gradlew test: die Tests werden von der JUnit-Plattform ausgeführt
    useJUnitPlatform()
    testLogging {
        // ein Bericht für jeden Test
        events("passed", "skipped", "failed")
        // die Ausgabe der Tests (println) wird angezeigt
        showStandardStreams = true
        // bei einem Fehlschlag: die vollständige Meldung der Assertion, ohne Aufrufstack
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
        showStackTraces = false
    }
}
  • Zeilen 2–3: das Kotlin-Plugin; mehr nicht – das Projekt hat kein Hauptprogramm;
  • Zeile 15: die Bibliothek kotlin.test. Die Notation [kotlin("test")] verweist auf das Artefakt [org.jetbrains.kotlin:kotlin-test] in der Version des Kotlin-Plugins. Wenn die Task [test] die JUnit-Plattform verwendet (Zeile 35), fügt das Kotlin-Plugin automatisch den Adapter hinzu, der die Assertions von kotlin.test mit denen von JUnit verbindet;
  • Zeile 17: JUnit besteht aus mehreren Modulen (API, Engine, parametrisierte Tests, Plattform usw.), deren Versionen zueinander kompatibel sein müssen. Seine Stückliste (BOM, Bill of Materials), [junit-bom], legt die Versionen all dieser Module fest: Die folgenden Abhängigkeiten werden ohne Versionsangabe deklariert;
  • Zeile 19: Das Artefakt [junit-jupiter] bündelt die Test-API ([@Test], [@BeforeEach] …), die Artefakte für parametrisierte Tests und die Jupiter-Engine, die sie ausführt;
  • Zeile 21: der JUnit-Platform-Launcher, über den Gradle die Tests startet. Er wird nur zur Laufzeit benötigt ([testRuntimeOnly]);
  • Zeile 29: Der Compiler behält die Namen der Funktionsparameter bei, die JUnit bei parametrisierten Tests anzeigt;
  • Zeilen 33–43: die Konfiguration der Task [test]. [useJUnitPlatform()] weist sie an, die Tests mit der JUnit-Plattform auszuführen. Standardmäßig zeigt Gradle nur fehlgeschlagene Tests und eine Zusammenfassung an; [events("passed", "skipped", "failed")] weist es an, über jeden Test zu berichten – ob er bestanden wurde, übersprungen wurde oder fehlgeschlagen ist –, [showStandardStreams = true] weist es an, die Ausgabe der Tests auf dem Bildschirm anzuzeigen, und die Zeilen 42–43 weisen es an, bei einem fehlgeschlagenen Test die vollständige Fehlermeldung ohne den Aufrufstapel anzuzeigen (standardmäßig zeigt Gradle nur den Namen der Exception und die Fehlerstelle an).

Die Testklasse [Tests1] sieht wie folgt aus:

package demotests

import kotlin.test.Test
import kotlin.test.assertEquals
import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.BeforeEach

// die getestete Funktion
private fun sum(a: Int, b: Int) = a + b

// eine Testklasse
class Tests1 {

    // der init-Block ist Teil des Konstruktors
    init {
        println("constructor")
    }

    // wird vor jedem Test ausgeführt
    @BeforeEach
    fun before() {
        println("before")
    }

    // wird nach jedem Test ausgeführt
    @AfterEach
    fun after() {
        println("after")
    }

    // ein erfolgreicher Test
    @Test
    fun `two and two make four`() {
        println("test1")
        assertEquals(4, sum(2, 2))
    }

    // ein fehlschlagender Test
    @Test
    fun `two and two make five`() {
        println("test2")
        assertEquals(5, sum(2, 2), "2 + 2 is not equal to 5")
    }

    // die Funktionen, die nur einmal ausgeführt werden, vor dem ersten und nach dem letzten Test:
    // für JUnit müssen sie statische Methoden sein
    companion object {
        @BeforeAll
        @JvmStatic
        fun beforeAll() {
            println("before all the tests")
        }

        @AfterAll
        @JvmStatic
        fun afterAll() {
            println("after all the tests")
        }
    }
}
  • Zeilen 3–4: die Annotation [Test] und die Assertion [assertEquals] von kotlin.test. Mit JUnit ist [kotlin.test.Test] ein Typalias ([typealias]) für die Annotation [org.junit.jupiter.api.Test]: Es ist dieselbe Annotation. Assertions sind Funktionen auf oberster Ebene, die wie Klassen importiert werden;
  • Zeilen 5–8: Annotationen für den Lebenszyklus von Tests, die spezifisch für JUnit sind;
  • Zeile 11: die zu testende Funktion. In einem realen Projekt läge sie im Hauptquellcode des Projekts ([src/main/kotlin]);
  • Zeile 14: Eine Testklasse ist eine gewöhnliche Klasse ohne jegliche Annotationen;
  • Zeilen 17–18: der Block [init], der bei der Konstruktion des Objekts ausgeführt wird. Er dient nur dazu, eine Meldung auf dem Bildschirm auszugeben: Wir wollen sehen, wann das Objekt erstellt wird;
  • Zeile 22: Die Annotation [@BeforeEach] kennzeichnet eine Funktion, die vor jedem Test ausgeführt wird;
  • Zeile 28: Die Annotation [@AfterEach] kennzeichnet eine Funktion, die nach jedem Test ausgeführt wird;
  • Zeilen 34–35: Die Annotation [@Test] kennzeichnet eine Testfunktion. Eine Testfunktion gibt nichts zurück, ist nicht privat und hat – bis auf eine Ausnahme, die wir noch besprechen – keine Parameter. Ihr Name wird in Backticks geschrieben: Kotlin erlaubt es so, einer Funktion einen Namen zu geben, der Leerzeichen und Zeichen mit Akzenten enthält, was im normalen Code nicht empfohlen, bei Tests aber gängige Praxis ist – der Name des Tests gibt klar an, was er überprüft. Auf der JVM darf dieser Name bestimmte Zeichen nicht enthalten ([. ; [ ] / < > :] und den Backslash). Java erreicht denselben Effekt mit der Annotation [@DisplayName];
  • Zeile 37: Die Funktion [assertEquals(expected, actual)] prüft, dass der erhaltene Wert dem erwarteten Wert entspricht. Ist dies nicht der Fall, löst sie eine Exception [AssertionFailedError] aus, und der Test schlägt fehl. Hier muss die Assertion erfolgreich sein;
  • Zeile 44: Diese Assertion muss fehlschlagen. Der dritte Parameter ist die Meldung, die im Fehlerfall angezeigt wird: Wie bei JUnit ist die Meldung bei den Assertions von kotlin.test der letzte Parameter;
  • Zeilen 49–59: Die Annotationen [@BeforeAll] und [@AfterAll] kennzeichnen Funktionen, die nur einmal ausgeführt werden, vor dem ersten und nach dem letzten Test der Klasse. JUnit verlangt, dass es statische Methoden sind. Kotlin kennt keine statischen Member: Diese Funktionen werden im Companion Object der Klasse abgelegt und mit [@JvmStatic] annotiert, was den Compiler anweist, zusätzlich eine echte statische Methode in der Klasse [Tests1] zu erzeugen. Ohne [@JvmStatic] wären diese Funktionen einfach Methoden der Klasse des Companion Objects: JUnit, das in der Klasse [Tests1] nach annotierten Funktionen sucht, würde sie nicht finden, und sie würden nie ausgeführt.

Die Tests werden mit dem Befehl [gradlew test] ausgeführt, der die Tests aller Teilprojekte startet, oder mit [gradlew :DemoTests:test], der nur die Tests des Teilprojekts [DemoTests] ausführt. Nachfolgend geben wir die Testberichte und ihre Ausgaben in der Reihenfolge ihrer Ausführung wieder, nicht aber die übrigen Gradle-Meldungen:

> gradlew :DemoTests:test
Tests1 STANDARD_OUT
    before all the tests
    constructor

Tests1 > two and two make five() STANDARD_OUT
    before
    test2
    after

Tests1 > two and two make five() FAILED
    org.opentest4j.AssertionFailedError: 2 + 2 is not equal to 5 ==> expected: <5> but was: <4>

Tests1 STANDARD_OUT
    constructor

Tests1 > two and two make four() STANDARD_OUT
    before
    test1
    after

Tests1 > two and two make four() PASSED

Tests1 STANDARD_OUT
    after all the tests

Tests2 > booleans, null and references() PASSED

Tests2 > reals equal within a tolerance() PASSED

Tests2 > exceptions() PASSED

Tests2 > sum of two integers(int, int, int) > [1] a = "1", b = "1", sum = "2" PASSED

Tests2 > sum of two integers(int, int, int) > [2] a = "2", b = "3", sum = "5" PASSED

Tests2 > sum of two integers(int, int, int) > [3] a = "-1", b = "1", sum = "0" PASSED

Tests2 > even numbers(int) > [1] n = 2 PASSED

Tests2 > even numbers(int) > [2] n = 4 PASSED

Tests2 > even numbers(int) > [3] n = 6 PASSED

Tests2 > strings and collections() PASSED

Tests3 STANDARD_OUT
    preparing the data

Tests3 > the square of 7() PASSED

Tests3 > the sum of the squares() PASSED

14 tests completed, 1 failed
  • Zeilen der Form [Tests1 > two and two make four() PASSED] sind die Testberichte: die Klasse, der Test und dann das Ergebnis, [PASSED] (bestanden) oder [FAILED] (fehlgeschlagen). Die Tests der Klassen [Tests2] und [Tests3], die weiter unten gezeigt werden, wurden alle bestanden. Die Ausführungsreihenfolge der Klassen und Funktionen ist festgelegt, aber bewusst nicht offensichtlich: Die Tests dürfen nicht von ihrer Ausführungsreihenfolge abhängen;
  • Gradle gruppiert die Ausgaben unter einer Zeile, die ihren Urheber gefolgt von der Notation [STANDARD_OUT] nennt: die Klasse ([Tests1 STANDARD_OUT]) für außerhalb eines Tests geschriebenen Code und der Test selbst für innerhalb des Tests geschriebenen Code;
  • Die Zeile [before all the tests]: Die Funktion [@BeforeAll] wird einmal ausgeführt, vor dem ersten Test der Klasse [Tests1];
  • Es folgen die Ausgaben des Tests [two and two make five]: Der Konstruktor wurde ausgeführt (die Zeile [constructor], die vor Beginn des Tests geschrieben wurde, steht unter [Tests1 STANDARD_OUT]), gefolgt von der Funktion [before], dem Test und schließlich der Funktion [after];
  • danach die Ausgabe des Tests [two and two make four]. Beachten Sie, dass der Konstruktor erneut ausgeführt wurde: JUnit erstellt 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 Klasse [Tests3] wird zeigen, wie sich stattdessen eine einzige Instanz für alle Tests der Klasse anfordern lässt);
  • Der Test [two and two make five] ist fehlgeschlagen. Die Fehlermeldung enthält die an [assertEquals] übergebene Meldung, den erwarteten Wert und den tatsächlichen Wert: Es ist [AssertionFailedError], eine Kindklasse von JUnit, an die kotlin.test die Überprüfung delegiert hat. Die Meldungen von JUnit sind auf Englisch. Ohne die Einstellungen [exceptionFormat] und [showStackTraces] in der Datei [build.gradle.kts] würde Gradle nur die Stelle der fehlgeschlagenen Assertion anzeigen ([org.opentest4j.AssertionFailedError at Tests1.kt:44], Zeile 44 der Datei [Tests1.kt]). Gradle meldet schließlich, dass die Task [test] fehlgeschlagen ist („14 tests completed, 1 failed“): Der Befehl [gradlew test] endet dann mit einem Build-Fehler („BUILD FAILED“) und einem Exit-Code ungleich null, sodass ein Skript den Fehlschlag erkennen kann. Gradle erzeugt außerdem einen detaillierten HTML-Testbericht im Ordner [build/reports/tests/test] des Teilprojekts;
  • Die Zeile [after all the tests], die letzte Zeile der Klasse [Tests1]: Die Funktion [@AfterAll] wird einmal ausgeführt, nach dem letzten Test der Klasse.

Um nur eine Teilmenge der Tests auszuführen, verwenden Sie die Option [--tests] der Task [test]: [gradlew :DemoTests:test --tests demotests.Tests2] führt nur die Tests der Klasse [Tests2] aus (der Name darf das Platzhalterzeichen [*] enthalten). Standardmäßig führt JUnit die Tests nacheinander aus; eine parallele Ausführung lässt sich in einer Konfigurationsdatei [junit-platform.properties] festlegen.

6.4.4.3. Weitere Assertions

Die Bibliothek kotlin.test bietet viele Assertions, und JUnit fügt weitere hinzu. Die Klasse [Tests2] liefert einige Beispiele:

package demotests

import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertFalse
import kotlin.test.assertIs
import kotlin.test.assertNotEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNotSame
import kotlin.test.assertNull
import kotlin.test.assertSame
import kotlin.test.assertTrue
import org.junit.jupiter.api.assertAll
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
import org.junit.jupiter.params.provider.ValueSource

// einige weitere Assertions von kotlin.test und JUnit
class Tests2 {

    // Booleans, null, Referenzen
    @Test
    fun `booleans, null and references`() {
        val yes = 1 < 2
        val no = 1 > 2
        assertTrue(yes)
        assertFalse(no)
        val obj1 = Any()
        val obj2: Any? = null
        val obj3 = obj1
        assertNotNull(obj1)
        assertNull(obj2)
        assertSame(obj1, obj3)
        assertNotSame(obj1, Any())
    }

    // reelle Zahlen: Gleichheit innerhalb einer Toleranz
    @Test
    fun `reals equal within a tolerance`() {
        val d1 = 0.1 + 0.2
        val d2 = 0.3
        assertNotEquals(d2, d1)
        assertEquals(d2, d1, absoluteTolerance = 1e-6)
    }

    // Strings und Collections: alle Assertions werden geprüft, auch wenn eine davon fehlschlägt
    @Test
    fun `strings and collections`() {
        val message = "Line no. 3 is incorrect"
        val numbers = listOf(1, 2, 3)
        assertAll(
            { assertTrue(message.startsWith("Line")) },
            { assertContains(message, "incorrect") },
            { assertEquals(3, numbers.size) },
            { assertContains(numbers, 2) },
            { assertEquals(listOf(1, 2, 3), numbers) },
        )
    }

    // Exceptions: der Test ist erfolgreich, wenn die erwartete Exception geworfen wird
    @Test
    fun exceptions() {
        val numbers = listOf(1, 2, 3)
        assertFailsWith<IndexOutOfBoundsException> { numbers[3] }
        val e = assertFailsWith<NumberFormatException> { "x".toInt() }
        assertNotNull(e.message)
        // assertIs prüft den Typ eines Objekts... und führt einen Cast durch
        val obj: Any = "abc"
        assertIs<String>(obj)
        assertEquals(3, obj.length)
    }

    // ein parametrisierter Test: eine Ausführung pro Wertezeile
    @ParameterizedTest
    @CsvSource("1, 1, 2", "2, 3, 5", "-1, 1, 0")
    fun `sum of two integers`(a: Int, b: Int, sum: Int) {
        assertEquals(sum, a + b)
    }

    // ein parametrisierter Test mit einem einzigen Parameter: eine Ausführung pro Wert
    @ParameterizedTest
    @ValueSource(ints = [2, 4, 6])
    fun `even numbers`(n: Int) {
        assertEquals(0, n % 2)
    }
}
  • Zeilen 28–29: Prüfung, ob ein boolescher Ausdruck wahr oder falsch ist;
  • Zeilen 33–34: Prüfung, ob eine Referenz nicht null oder null ist. [obj2] muss mit einem nullable Typ deklariert sein, [Any?];
  • Zeilen 35–36: Prüfung, ob zwei Referenzen auf dasselbe Objekt verweisen (der Operator [===]);
  • Zeilen 42–45: Berechnungen mit 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 Toleranz, hier einem Millionstel. Der Parameter [absoluteTolerance] wird benannt: Der Aufruf gibt klar an, was die dritte Zahl ist;
  • Zeilen 53–58: Die Funktion [assertAll] von JUnit erhält Lambda-Ausdrücke, die jeweils eine Assertion enthalten: Alle Assertions werden ausgeführt, auch wenn eine davon fehlschlägt, und die Fehlschläge werden gemeinsam gemeldet. Ohne [assertAll] beendet der erste Fehlschlag den Test. Diese Funktion auf oberster Ebene aus dem Paket [org.junit.jupiter.api] gehört zu den Erweiterungen, die JUnit für Kotlin bereitstellt: Sie akzeptiert Kotlin-Lambdas ([{ ... }]) statt [Executable]-Objekten. [assertContains] prüft, ob eine Zeichenkette eine Teilzeichenkette oder eine Sammlung ein Element enthält. Kotlin-Listen werden mit [==] (Funktion [equals]) verglichen: Zwei Listen sind gleich, wenn sie dieselben Elemente in derselben Reihenfolge haben, und [assertEquals] genügt dort, wo Java [assertIterableEquals] verwendete;
  • Zeile 66: [assertFailsWith<Type> { action }] führt die Aktion – ein Lambda – aus und prüft, dass sie eine Exception vom Typ [Type] oder einem abgeleiteten Typ auslöst. Der Typ ist ein Typparameter mit [reified] (Kapitel 4): Er wird zwischen spitzen Klammern geschrieben, ohne [::class]. Hier löst der Lesezugriff [numbers[3]] eine [ArrayIndexOutOfBoundsException] aus, eine von [IndexOutOfBoundsException] abgeleitete Klasse: Die Assertion ist erfolgreich;
  • Zeilen 67–68: [assertFailsWith] gibt die Exception zurück, wodurch sich anschließend ihre Eigenschaften überprüfen lassen. Ihr Typ ist der angeforderte, [NumberFormatException]: Eine Typumwandlung ist nicht nötig. kotlin.test hat kein Äquivalent zu [assertThrowsExactly], das den exakten Typ der Exception verlangt; man kann die Variante von JUnit verwenden oder anschließend [e::class] überprüfen;
  • Zeilen 70–72: [assertIs<Type>(obj)] prüft, dass das Objekt vom angegebenen oder einem abgeleiteten Typ ist. Es teilt dem Compiler außerdem mit, dass [obj] nach der Assertion von diesem Typ ist: Dank Smart Cast verwendet die nächste Zeile die Eigenschaft [length] eines [String] bei einer Variablen, die als [Any] deklariert ist;
  • Zeilen 76–79: ein parametrisierter Test. Die Annotation [@ParameterizedTest] ersetzt [@Test]; die Funktion hat Parameter, und die Annotation [@CsvSource] liefert Wertesätze, eine Zeichenkette pro Satz, mit durch Kommas getrennten Werten. Ist in Kotlin der Parameter [value] einer Annotation ein Array, wird er als Liste von Argumenten geschrieben. JUnit wandelt die Werte in den Parametertyp um. Der Test wird einmal pro Wertesatz ausgeführt;
  • Zeilen 84–86: Bei einem Test mit nur einem Parameter liefert die Annotation [@ValueSource] direkt die Werteliste ([ints], [strings], [doubles] …). Ein Array, das einem benannten Annotationsparameter übergeben wird, wird in eckigen Klammern geschrieben: [ints = [2, 4, 6]].

In den vorherigen Ergebnissen führte jeder Wertesatz eines parametrisierten Tests zu einem Bericht, der in eckigen Klammern nummeriert und von den Namen und Werten der Parameter begleitet ist: [Tests2 > sum of two integers(int, int, int) > [1] a = "1", b = "1", sum = "2" PASSED]. Der Test wird zunächst durch den Funktionsnamen gefolgt von den Typen seiner Parameter identifiziert, wie sie von Java aus gesehen werden ([int] für ein Kotlin-[Int]). Die von [@CsvSource] gelieferten Werte werden vor ihrer Umwandlung genau so angezeigt, wie sie in der Annotation geschrieben sind, in Anführungszeichen eingeschlossen; die von [@ValueSource], die bereits Ganzzahlen sind, werden ohne Anführungszeichen angezeigt ([even numbers(int) > [1] n = 2]).

Fassen wir die wichtigsten Assertions von kotlin.test (Paket [kotlin.test]) zusammen:

Funktion
Prüft, dass
[assertEquals(expected, actual)]
die beiden Werte gleich sind (Funktion [equals], das gilt also auch für Listen)
[assertEquals(real1, real2, absoluteTolerance)]
die beiden reellen Zahlen innerhalb der Toleranz 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 verweisen
[assertNull(o)], [assertNotNull(o)]
die Referenz null ist (bzw. nicht null ist); [assertNotNull] gibt den Wert zurück, der nicht nullable ist
[assertTrue(b)], [assertFalse(b)]
der boolesche Ausdruck wahr (bzw. falsch) ist
[assertIs<Type>(o)]
das Objekt vom Typ [Type] oder von einem abgeleiteten Typ ist (und die Typumwandlung)
[assertContains(c, e)]
die Sammlung, das Array oder die Zeichenkette [c] das Element [e] enthält
[assertContentEquals(t1, t2)]
beide Arrays (oder Sequenzen) dieselben Elemente in derselben Reihenfolge haben
[assertFailsWith<Type> { action }]
die Aktion eine Exception vom Typ [Type] oder von einem abgeleiteten Typ auslöst
[assertFails { action }]
die Aktion eine Exception auslöst, unabhängig von ihrem Typ
[fail(message)]
(schlägt immer fehl)

Alle diese Funktionen akzeptieren einen optionalen Parameter [message]: die Meldung, die im Fehlerfall angezeigt wird. Die Funktion [assertAll] gibt es nur in JUnit. Die Assertions von JUnit (Klasse [org.junit.jupiter.api.Assertions]) bleiben in Kotlin verwendbar; kotlin.test hat den Vorteil, prägnanter zu sein, reified Typen und Smart Casts zu nutzen und nicht vom Test-Framework abzuhängen.

6.4.4.4. Eine Instanz pro Testklasse

Die Funktionen [@BeforeAll] der Klasse [Tests1] mussten im Companion Object abgelegt werden. JUnit bietet eine andere Lösung, wie die Klasse [Tests3] zeigt:

package demotests

import kotlin.test.Test
import kotlin.test.assertEquals
import org.junit.jupiter.api.BeforeAll
import org.junit.jupiter.api.TestInstance

// eine einzige Instanz der Klasse für alle ihre Tests: @BeforeAll kann dann eine gewöhnliche Funktion sein
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class Tests3 {

    // aufwendig vorzubereitende Daten, die von den Tests gemeinsam genutzt werden; lateinit: später initialisiert
    private lateinit var squares: List<Int>

    // wird nur einmal ausgeführt, vor dem ersten Test
    @BeforeAll
    fun prepare() {
        println("preparing the data")
        squares = (0..10).map { it * it }
    }

    @Test
    fun `the square of 7`() {
        assertEquals(49, squares[7])
    }

    @Test
    fun `the sum of the squares`() {
        assertEquals(385, squares.sum())
    }
}
  • Zeile 9: Die Annotation [@TestInstance(Lifecycle.PER_CLASS)] weist JUnit an, für alle Tests der Klasse eine einzige Instanz zu erstellen statt einer Instanz pro Test. Die Funktionen [@BeforeAll] und [@AfterAll] können dann gewöhnliche Funktionen der Klasse sein;
  • Zeile 13: von den Tests gemeinsam genutzte Daten. Der Modifizierer [lateinit] erlaubt es, eine Eigenschaft [var] als nicht nullable zu deklarieren, ohne sie zu initialisieren: Sie erhält ihren Wert später, vor dem ersten Lesen (ein vorzeitiges Lesen würde eine [UninitializedPropertyAccessException] auslösen);
  • Zeilen 16–19: Die einmal vor dem ersten Test ausgeführte Funktion bereitet die Daten vor: die Liste der Quadrate der ganzen Zahlen von 0 bis 10;
  • Zeilen 23–29: zwei Tests verwenden diese Daten.

Die vorherigen Ergebnisse zeigen, dass die Vorbereitung nur einmal durchgeführt wurde. Dieser Modus ist nützlich, wenn die Vorbereitung ressourcenintensiv ist (Verbindung zu einer Datenbank, Lesen einer großen Datei); in solchen Fällen müssen die Tests darauf achten, den gemeinsamen Zustand nicht zu verändern. Er lässt sich auch für das gesamte Projekt in der Datei [junit-platform.properties] auswählen ([junit.jupiter.testinstance.lifecycle.default = per_class]), was in Kotlin-Projekten häufig geschieht.

6.4.4.5. Tests der Schicht [dao]

Kehren wir zur Anwendung [Tax] zurück. Die Klasse [DaoTests], die die Schicht [dao] testet, liegt im Ordner [src/test/kotlin/tax/dao] des Teilprojekts [tax-dao]. Sie gehört zum selben Paket wie die getesteten Klassen. Die Testquellen eines Teilprojekts umfassen auch dessen [internal]-Deklarationen, die in dem einen Modul sichtbar sind, das sie deklariert. Die Testabhängigkeiten wurden in der Build-Datei des Teilprojekts deklariert, genau wie in der von [DemoTests]. Die ungültige Datendatei [TaxDataInvalid.txt] liegt im Ordner des Teilprojekts: Dies ist der aktuelle Ordner, während die Tests laufen.

package tax.dao

import tax.entities.TaxException
import java.math.BigDecimal
import java.nio.file.NoSuchFileException
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertIs
import kotlin.test.assertTrue
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource

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

    // derselbe Test für die drei Implementierungen
    @ParameterizedTest
    @ValueSource(strings = ["HardwiredTax", "FileTax", "JsonTax"])
    fun `tax brackets`(implementation: String) {
        val brackets = createDao(implementation).taxBrackets
        // einige Prüfungen: compareTo ignoriert die Skalierung von BigDecimals (0.191 und 0.1910 sind gleich)
        assertEquals(7, brackets.size)
        val (limit, coeffR, coeffN) = brackets[2]
        assertEquals(0, BigDecimal("14753").compareTo(limit))
        assertEquals(0, BigDecimal("0.191").compareTo(coeffR))
        assertEquals(0, BigDecimal("1322.92").compareTo(coeffN))
    }

    // die drei Implementierungen liefern dieselben Stufen
    @Test
    fun `the three implementations give the same brackets`() {
        val reference = HardwiredTax().taxBrackets
        assertEquals(reference, FileTax("TaxData.txt").taxBrackets)
        assertEquals(reference, JsonTax("TaxData.json").taxBrackets)
    }

    // fehlende Datei
    @Test
    fun `missing file`() {
        val e = assertFailsWith<TaxException> { FileTax("TaxDataMissing.txt") }
        assertEquals(FileTax.ACCESS, e.code)
        assertIs<NoSuchFileException>(e.cause)
    }

    // Datei, deren Zeile 3 fehlerhaft ist (Dezimalkommas)
    @Test
    fun `incorrect line`() {
        val e = assertFailsWith<TaxException> { FileTax("TaxDataInvalid.txt") }
        assertEquals(FileTax.FIELD2 or FileTax.FIELD3, e.code)
        assertTrue(e.message!!.startsWith("Line no. 3"))
    }

    // fehlende JSON-Datei
    @Test
    fun `missing JSON file`() {
        val e = assertFailsWith<TaxException> { JsonTax("TaxDataMissing.json") }
        assertEquals(JsonTax.ACCESS, e.code)
    }

    private companion object {
        // Factory einer [dao]-Schicht anhand des Namens ihrer Klasse
        fun createDao(implementation: String): ITaxDao = when (implementation) {
            "HardwiredTax" -> HardwiredTax()
            "FileTax" -> FileTax("TaxData.txt")
            "JsonTax" -> JsonTax("TaxData.json")
            else -> throw IllegalArgumentException("unknown implementation: $implementation")
        }
    }
}
  • Zeilen 61–67: eine Funktion, die eine Schicht [dao] anhand des Namens ihrer Klasse erstellt, mit einem [when]-Ausdruck: Jeder Zweig liefert nach dem Pfeil [->] den Wert des Ausdrucks. Sie liegt in einem privaten Companion Object, hätte aber ebenso gut eine private Funktion der Klasse oder der Datei sein können;
  • Zeilen 18–27: Derselbe Test wird für alle drei Implementierungen durchgeführt, mithilfe der Annotation [@ValueSource]. Er prüft, dass es 7 Steuerstufen gibt, und kontrolliert den Wert von Stufe Nr. 2 (der dritten). Die Destrukturierungsdeklaration [val (limit, coeffR, coeffN) = brackets[2]] verteilt die drei Eigenschaften der Stufe auf drei Variablen, mithilfe der für eine Datenklasse generierten Funktionen [component1] bis [component3] . 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. Beachten Sie: In Kotlin ruft [a == b] die Methode [equals] auf und hat daher dieses Problem bei [BigDecimal]-Werten; es sind die Operatoren [<], [<=] …, die [compareTo] aufrufen;
  • Zeilen 32–35: Alle drei Implementierungen liefern exakt dieselben Steuerstufen. [assertEquals] vergleicht die Listen mit ihrer Funktion [equals], die die Elemente einzeln vergleicht; die vom Compiler generierte Funktion [equals] einer Datenklasse vergleicht deren Eigenschaften. Der Vergleich gelingt, weil alle drei Quellen die Zahlen auf dieselbe Weise schreiben;
  • Zeilen 40–43: Eine fehlende Datei löst eine [TaxException] mit dem Code [ACCESS] aus, die eine [NoSuchFileException] kapselt. [assertFailsWith] akzeptiert auch von dem angeforderten Typ abgeleitete Klassen, aber eine Kotlin-Klasse ist standardmäßig final: [TaxException] hat keine abgeleiteten Klassen, und der Test prüft zu Recht den exakten Typ der Exception. [assertIs] prüft den Typ der Ursache;
  • Zeilen 48–51: Die Datei [TaxDataInvalid.txt] löst eine [TaxException] aus, deren Code die Codes [FIELD2] und [FIELD3] kombiniert und deren Meldung mit „Line no. 3“ beginnt. Die Eigenschaft [message] einer Exception hat den Typ [String?]: Der Operator [!!] sichert zu, dass sie nicht [null] ist (andernfalls würde eine [NullPointerException] ausgelöst, was den Test ebenfalls fehlschlagen ließe);
  • Zeilen 56–58: dieselbe Prüfung für die Implementierung [JsonTax].

6.4.4.6. Tests der Schicht [business]

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

package tax.business

import tax.dao.HardwiredTax
import tax.dao.ITaxDao
import tax.entities.TaxBracket
import java.math.BigDecimal
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
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 erstellt pro Test eine Instanz der Klasse
    private val dao = HardwiredTax()
    private val business: ITaxBusiness = 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",
    )
    fun `tax calculation`(married: Boolean, nbChildren: Int, salary: Int, tax: Int) {
        assertEquals(tax, business.calculateTax(married, nbChildren, salary))
    }

    // die Berechnung verändert die von der [dao]-Schicht gelieferten Stufen nicht
    @Test
    fun `the brackets are unchanged`() {
        val before = dao.taxBrackets.toList()
        business.calculateTax(true, 2, 600000)
        assertEquals(before, dao.taxBrackets)
    }

    // negative Parameter werden abgelehnt
    @Test
    fun `negative parameters are rejected`() {
        assertFailsWith<IllegalArgumentException> { business.calculateTax(true, -1, 60000) }
        assertFailsWith<IllegalArgumentException> { business.calculateTax(true, 2, -60000) }
    }

    // die [business]-Schicht, getestet mit einer Fake-[dao]-Schicht: eine einzige Stufe, 10 % Steuer
    // ITaxDao hat nur eine Eigenschaft: ein anonymes Objekt genügt zur Implementierung
    @Test
    fun `with a fake dao layer`() {
        val fakeDao = object : ITaxDao {
            override val taxBrackets =
                listOf(TaxBracket(BigDecimal.ZERO, "0.1".toBigDecimal(), BigDecimal.ZERO))
        }
        val fakeBusiness: ITaxBusiness = TaxBusiness(fakeDao)
        // zu versteuerndes Einkommen = 0.72 x 100000 = 72000; Steuer = 10 % von 72000
        assertEquals(7200, fakeBusiness.calculateTax(false, 0, 100000))
    }
}
  • Zeilen 17–18: Die zu testende Schicht [business] wird auf den Schichten [dao] und [HardwiredTax] aufgebaut, die von keiner Datei abhängen. Die Eigenschaften werden bei der Erstellung des Objekts initialisiert; da JUnit für jeden Test eine neue Instanz der Klasse erstellt, hat jeder Test brandneue Schichten;
  • Zeilen 21–31: Berechnungen mit bekannten Ergebnissen, geliefert von [@CsvSource]. 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] umgewandelt. Der Name des Tests, [tax calculation], enthält ein Leerzeichen: Das ist zwischen Backticks erlaubt;
  • Zeilen 36–39: Die Steuerberechnung verändert die von der Schicht [dao] gelieferten Steuerstufen nicht. Vor einer Berechnung, die die letzte Stufe verwendet, wird eine Kopie der Stufen ([toList]) gespeichert und anschließend ein Vergleich durchgeführt. Der Test verfolgt den oben beschriebenen alten Fehler: Würde jemand ihn wieder einführen, würde dieser Test ihn melden. Beachten Sie, dass eine Kotlin-[List] für den Compiler schreibgeschützt ist, das tatsächliche Objekt aber eine veränderliche Liste sein kann: Code, der sie in [MutableList] umwandeln würde, könnte sie ändern;
  • Zeilen 44–46: Negative Parameter werden mit einer *[IllegalArgumentException] abgelehnt, der von *[require] ausgelösten;
  • Zeilen 53–55: eine Attrappe der Schicht [dao], wie sie der Entwickler der Schicht [business] verwenden würde, bevor die tatsächliche Schicht [dao] fertig ist: eine einzige Steuerstufe, eine Steuer von 10 % auf das zu versteuernde Einkommen. Die Schnittstelle [ITaxDao] wird ohne das Schreiben einer Klasse implementiert, mithilfe eines Objektausdrucks ([object : ITaxDao { ... }]): ein Objekt einer anonymen Klasse, die die Schnittstelle implementiert, das Äquivalent der anonymen Klassen von Java. Die Java-Version, deren Schnittstelle nur eine abstrakte Methode hatte, verwendete einen Lambda-Ausdruck; unsere Schnittstelle deklariert eine Eigenschaft, und ein Lambda kann nur eine funktionale Kotlin-Schnittstelle ([fun interface], Kapitel 7) implementieren, die nur eine abstrakte Funktion deklariert. Der Typ der überschriebenen Eigenschaft, [List<TaxBracket>], wird abgeleitet;
  • Zeilen 57–59: Die Schicht [business] arbeitet mit der Attrappe der Schicht [dao]. Die Schicht [business] wird somit für sich allein getestet, unabhängig von den tatsächlichen Implementierungen der Schicht [dao].

6.4.4.7. Ausführung der Tests

Der Befehl [gradlew test], der im Ordner des Kapitels eingegeben wird, führt die Tests aller Teilprojekte aus; [gradlew :TaxV5:tax-dao:test] führt nur die Tests des Teilprojekts [tax-dao] aus. Hier sind die Testberichte dieses Teilprojekts (wir haben nur diese Zeilen aufgenommen):

> gradlew :TaxV5:tax-dao:test
DaoTests > missing JSON file() PASSED

DaoTests > incorrect line() PASSED

DaoTests > missing file() PASSED

DaoTests > the three implementations give the same brackets() PASSED

DaoTests > tax brackets(String) > [1] implementation = "HardwiredTax" PASSED

DaoTests > tax brackets(String) > [2] implementation = "FileTax" PASSED

DaoTests > tax brackets(String) > [3] implementation = "JsonTax" PASSED

und die des Teilprojekts [tax-business]:

> gradlew :TaxV5:tax-business:test
BusinessTests > negative parameters are rejected() PASSED

BusinessTests > tax calculation(boolean, int, int, int) > [1] married = "true", nbChildren = "2", salary = "60000", tax = "4282" PASSED

BusinessTests > tax calculation(boolean, int, int, int) > [2] married = "false", nbChildren = "3", salary = "60000", tax = "4282" PASSED

BusinessTests > tax calculation(boolean, int, int, int) > [3] married = "true", nbChildren = "3", salary = "60000", tax = "2959" PASSED

BusinessTests > tax calculation(boolean, int, int, int) > [4] married = "false", nbChildren = "0", salary = "60000", tax = "11519" PASSED

BusinessTests > tax calculation(boolean, int, int, int) > [5] married = "false", nbChildren = "3", salary = "6000", tax = "0" PASSED

BusinessTests > tax calculation(boolean, int, int, int) > [6] married = "false", nbChildren = "3", salary = "600000", tax = "179275" PASSED

BusinessTests > with a fake dao layer() PASSED

BusinessTests > the brackets are unchanged() PASSED

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 [javaParameters] verfügbar). Wir betrachten die Schichten [dao] und [business] nun als funktionsfähig. Die von [gradlew build] (oder [gradlew jar]) erzeugten JAR-Dateien enthalten nur den Code der Schichten: Die Testklassen, die im Ordner [build/classes/kotlin/test] kompiliert werden, sind nicht enthalten. Beachten Sie schließlich, dass [gradlew build] die Tests ausführt: Eine Regression lässt den Build fehlschlagen. Gradle wiederholt nur die notwendige Arbeit: Haben sich weder der Code noch die Tests eines Teilprojekts seit dem letzten erfolgreichen Lauf geändert, werden seine Tests nicht erneut ausgeführt (die Task wird als „UP-TO-DATE“ gemeldet); die Option [--rerun] ([gradlew :TaxV5:tax-dao:test --rerun]) erzwingt ihre Ausführung.

6.4.5. Die Schicht [ui]

Die Datei [build.gradle.kts] des Teilprojekts [tax-ui] sieht wie folgt aus:

// TaxV5: das Unterprojekt tax-ui (die [ui]-Schicht und die Integration der Schichten)
plugins {
    kotlin("jvm")
    // macht die von Spring annotierten Klassen, wie @Configuration, offen (nicht final)
    kotlin("plugin.spring")
    application
}

// die Koordinaten des Projekts: examples.tax:tax-ui:5.0 (die Klasse Dialog wird wiederverwendet)
group = "examples.tax"
version = "5.0"

repositories {
    mavenCentral()
}

dependencies {
    // die [ui]-Schicht verwendet die [business]-Schicht und über deren API die [dao]-Schicht
    implementation(project(":TaxV5:tax-business"))
    // der Dependency-Injection-Container von Spring
    implementation("org.springframework:spring-context:7.0.9")
}

kotlin {
    jvmToolchain(25)
    compilerOptions {
        allWarningsAsErrors = true
        javaParameters = true
    }
}

application {
    // das von [gradlew run] ausgeführte Programm wird durch die Eigenschaft [main] bezeichnet:
    // gradlew -q :TaxV5:tax-ui:run -Pmain=tax.ui.MainConfigKt
    mainClass = providers.gradleProperty("main").orElse("tax.ui.MainKt")
}

tasks.named<JavaExec>("run") {
    // das laufende Programm kann die Tastatur lesen
    standardInput = System.`in`
}

// unter Windows wird die Bildschirmausgabe des von Gradle gestarteten Programms (run, bootRun ...) in UTF-8 kodiert,
// sonst werden Zeichen mit Akzenten in der IntelliJ-IDEA-Konsole oder im Terminal falsch dargestellt
tasks.withType<JavaExec>().configureEach {
    jvmArgs("-Dstdout.encoding=UTF-8", "-Dstderr.encoding=UTF-8")
}
  • Zeilen 2–6: das Kotlin-Plugin, das Kotlin-Compiler-Plugin [plugin.spring] – dessen Rolle wir bei der Konfiguration von Spring mit einer annotierten Klasse betrachten werden – und das Plugin [application];
  • Zeile 19: Die Schicht [ui] verwendet die Schicht [business] und, über deren Abhängigkeit [api], die Schicht [dao];
  • Zeile 21: der Dependency-Injection-Container von Spring, das Artefakt [spring-context], das die anderen benötigten Spring-Module mitbringt ([spring-core], [spring-beans] usw.);
  • Zeilen 32–35: Das Teilprojekt hat mehrere Hauptprogramme; die Eigenschaft [main] wählt dasjenige aus, das von [gradlew run] ausgeführt wird, und zwar standardmäßig [tax.ui.MainKt] ;
  • Zeilen 43–46: Von Gradle gestartete Programme schreiben ihre Ausgabe in UTF-8, damit akzentuierte Zeichen unter Windows korrekt angezeigt werden (Kapitel 2).

Das Objekt [Dialog] stammt aus Version 4 (Paket [tax.ui]), ergänzt um eine Funktion, die eine Exception und alle von ihr gekapselten Exceptions anzeigt:

    // Anzeige einer Exception und aller Exceptions, die sie verpackt
    fun displayError(exception: Throwable) {
        val separator = "-".repeat(40)
        println("Exception chain:\n$separator")
        generateSequence(exception) { it.cause }.forEach { e ->
            println("${e::class.qualifiedName}: ${e.message}")
            println(separator)
        }
    }
}
  • Zeile 2: Der Parameter hat den Typ [Throwable], die Elternklasse aller Exceptions;
  • Zeile 3: eine Zeichenkette aus 40 Bindestrichen, erzeugt mit der Funktion [repeat];
  • Zeile 5: Jede Exception ermöglicht über ihre Eigenschaft [cause] den Zugriff auf die Exception, die sie kapselt, bis hinunter zur letzten, deren Ursache [null] ist. Die Funktion [generateSequence] (Kapitel 5) erzeugt diese Kette als Sequenz: Sie beginnt mit dem Anfangswert [exception] und berechnet jedes weitere Element aus dem vorhergehenden mit dem Lambda [{ it.cause }]; die Sequenz endet beim ersten [null]. Die [for]-Schleife der Java-Version, deren Variable bei jedem Durchlauf geändert wird, wird zu einer einfachen Aufzählung;
  • Zeile 6: Für jede Exception werden der vollständige Name ihrer Klasse (einschließlich des Pakets) und ihre Meldung angezeigt.

Das Objekt [Dialog] ist öffentlich: Künftige Versionen der Anwendung, die die Schicht [dao] ändern werden, können die Schicht [ui] wiederverwenden, indem sie vom Teilprojekt [tax-ui] abhängen und [Dialog.run(business)] aufrufen.

6.4.6. Integration der Schichten per Dependency Injection

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

1
2
3
        val dao: ITaxDao = if (source == "hardwired") HardwiredTax() else FileTax(source)
        // Erstellung der [business]-Schicht, die die [dao]-Schicht erhält
        TaxBusiness(dao)

Abgesehen von diesen Zeilen ändert sich nichts an der Anwendung, wenn sich die Implementierung einer Schicht ändert, da jede Schicht mit der nächsten über eine Schnittstelle kommuniziert. Wir können die Unabhängigkeit der Schichten noch weiter treiben, indem wir ihre Erstellung 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 erstellt die [dao]-Schicht [1], dann die Schicht [business] [2], an die er die Schicht [dao] übergibt. Schließlich fordert die Schicht [ui] die Schicht [business] beim 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 [Tax]-Anwendung: Implementierung der [dao]-Schicht
dao.implementation=FileTax
dao.file=TaxData.txt
  • Zeile 1: Ein Kommentar beginnt mit dem Zeichen [#];
  • 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 der JVM: eine Eigenschaft pro Zeile, in der Form [key=value], gelesen von der Java-Klasse [java.util.Properties]. Den Schlüsseln wird häufig ein Präfix vorangestellt, um Gruppen zu bilden, wie hier das Präfix [dao.]. Das Teilprojekt 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 [gradlew run] führt das Programm im Ordner des Teilprojekts aus.

6.4.6.2. Das Hauptprogramm

Das Hauptprogramm [Main.kt] des Teilprojekts [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.util.Properties
import kotlin.io.path.Path
import kotlin.io.path.bufferedReader
import kotlin.system.exitProcess
import org.springframework.beans.factory.getBean
import org.springframework.context.support.GenericApplicationContext
import org.springframework.context.support.registerBean

// Integration der Schichten durch den Spring-Container GenericApplicationContext
fun main(args: Array<String>) {
    // die Konfigurationsdatei: standardmäßig tax.properties oder die als Argument übergebene
    val configFile = args.firstOrNull() ?: "tax.properties"

    // Integration der Schichten
    val business: ITaxBusiness = try {
        // Lesen der Konfiguration im aktuellen Ordner
        val config = Properties()
        Path(configFile).bufferedReader().use { config.load(it) }
        val implementation = config.getProperty("dao.implementation", "HardwiredTax")
        val file = config.getProperty("dao.file", "")

        // der Spring-Container: die Schichten werden darin registriert
        val context = GenericApplicationContext()
        // die [dao]-Schicht: die Implementierung wird durch die Konfiguration gewählt
        context.registerBean<ITaxDao> {
            when (implementation) {
                "HardwiredTax" -> HardwiredTax()
                "FileTax" -> FileTax(file)
                "JsonTax" -> JsonTax(file)
                else -> throw TaxException("Unknown implementation [$implementation] of the [dao] layer")
            }
        }
        // die [business]-Schicht: der Container übergibt die [dao]-Schicht an ihren Konstruktor
        context.registerBean<TaxBusiness>()

        // Start des Containers: er erstellt die [dao]-Schicht, dann die [business]-Schicht
        context.refresh()
        context.getBean<ITaxBusiness>()
    } catch (e: Exception) {
        // Anzeige des Fehlers und Beenden des Programms
        Dialog.displayError(e)
        exitProcess(1)
    }

    // der Dialog mit dem Benutzer
    Dialog.run(business)
}
  • Zeilen 14–16: Spring stellt Erweiterungsfunktionen für Kotlin bereit, die seine API in dieser Sprache natürlicher machen. [getBean] und [registerBean] werden als Funktionen auf oberster Ebene aus ihren Paketen importiert;
  • Zeile 19: die Funktion [main] aus dem Paket [tax.ui], kompiliert in die Klasse [tax.ui.MainKt];
  • Zeile 21: der Name der Konfigurationsdatei: standardmäßig [tax.properties] oder die als Argument übergebene;
  • Zeile 24: Wie in Version 4 ist die Schicht [business] der Wert eines [try]-Ausdrucks;
  • Zeilen 26–29: Lesen der Konfiguration. Die Erweiterungsfunktion [bufferedReader] von [kotlin.io.path] öffnet die Datei in UTF-8, und [use] schließt sie am Ende des Blocks, auch im Falle einer Exception ([try] mit einer Java-Ressource). [Properties.load] liest die Zeilen der Form [key=value]. Eine fehlende Datei löst eine [NoSuchFileException] aus, die weiter unten abgefangen wird. [getProperty] liefert den Wert eines Schlüssels oder den als zweiten Parameter übergebenen Standardwert, falls der Schlüssel nicht existiert;
  • Zeile 32: der Spring-Container. Spring bezeichnet ein vom Container erstelltes und verwaltetes Objekt als „Bean“ und den Container selbst als „Application Context“. [GenericApplicationContext] ist ein Container, der programmatisch konfiguriert wird;
  • Zeilen 34–39: der Eintrag der Schicht [dao]. Die Erweiterungsfunktion [registerBean<ITaxDao> { ... }] legt fest, dass die Bean vom Typ [ITaxDao] durch das folgende Lambda erstellt wird – einen parameterlosen „Supplier“, der das Objekt zurückgibt. Der Typ der Bean ist ein Typparameter mit reified: Wir schreiben [registerBean<ITaxDao>] , wo Java [registerBean(ITaxDao.class, ...)] schreibt. Die Bean ist ein Singleton, der Standard-Scope von Spring: Sie wird nur einmal erstellt, und alle Anfragen liefern dasselbe Objekt; in der Anwendung gibt es nur eine Schicht [dao]. Der Supplier wählt die Klasse anhand der Konfiguration mit dem Ausdruck [when] aus. Eine unbekannte Implementierung führt zu einer [TaxException]. Beachten Sie, dass das Lambda die Variablen [implementation] und [file] der Funktion [main] verwendet: Es „erfasst“ sie (Kapitel 7) und nutzt sie, wenn der Container es aufruft;
  • Zeile 43: Die Registrierung der Schicht [business]: Der Container erstellt 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 46: [refresh()] startet den Container. Spring erstellt dann alle Singleton-Beans in der Reihenfolge ihrer Registrierung: zuerst die Schicht [dao], dann die Schicht [business]. Ein Fehler bei der Erstellung tritt daher in dieser Zeile auf;
  • Zeile 47: Beim Container wird eine Bean vom Typ [ITaxBusiness] angefordert. Der Container findet die Bean [TaxBusiness], die diese Schnittstelle implementiert. Die Erweiterungsfunktion [getBean<T>()] ersetzt den Java-Aufruf [getBean(ITaxBusiness.class)], und ihr Ergebnis hat den angeforderten Typ. [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] abruft, ohne die Klasse anzugeben, die sie implementiert. Dies ist der letzte Ausdruck im [try]-Block und damit der Wert der Variablen [business];
  • Zeilen 48–51: Jeder Fehler beim Lesen der Konfiguration ([IOException]) oder beim Erstellen der Schichten (Spring-Exceptions und unsere [TaxException]) wird zusammen mit dem Stacktrace der Exception angezeigt, und das Programm endet. Kotlin unterstützt keine Multi-Catch-Blöcke ([catch (IOException | RuntimeException e)] in Java); das Abfangen von [Exception], der Elternklasse beider, erzielt hier dasselbe Ergebnis;
  • Zeile 55: die Benutzeroberfläche, identisch mit der von Version 4.

Frühe Versionen von Spring lasen die vollständigen Namen der zu instanziierenden Klassen aus einer XML-Datei und erstellten sie per Reflection; ein Beispiel dafür sehen wir später. Hier haben wir uns stattdessen dafür entschieden, die möglichen Implementierungen im Provider zu definieren: Die Konfigurationsdatei wählt lediglich unter ihnen aus, und der Compiler überprüft, dass die Klassen existieren und die erforderlichen Konstruktoren haben. In beiden Fällen nennt der Code der Schichten [ui] und [business] nie die Klasse, die die Schicht [dao] implementiert. Bemerkenswert ist außerdem, dass die Klassen der Schichten nichts von Spring wissen: Keine von ihnen importiert Spring-Klassen; nur das Hauptprogramm tut es.

6.4.6.3. Ausführungen

Aus dem Ordner des Kapitels heraus, mit der Datei [tax.properties] (Implementierung [FileTax]):

1
2
3
4
5
6
7
8
> gradlew -q :TaxV5:tax-ui:run
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
> gradlew -q :TaxV5:tax-ui:run --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
> gradlew -q :TaxV5:tax-ui:run --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:

> gradlew -q :TaxV5:tax-ui:run --args="tax-error.properties"
Oct 04, 2026 12:25:44 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
----------------------------------------
  • die ersten beiden Zeilen: Bevor Spring die Exception weitergibt, schreibt es eine Warnung in sein Log. Da das Projekt keine Logging-Bibliothek enthält, wird dieses Log vom Standard-Logging-Mechanismus des JDK ([java.util.logging]) verarbeitet, der das Datum, die auslösende Klasse, dann die Stufe der Meldung und die Meldung selbst (auf Englisch) in die Fehlerausgabe schreibt;
  • die ursprüngliche Exception – die zuletzt angezeigte, vom Typ [NoSuchFileException] – wurde von der Klasse [FileTax] ausgelöst;
  • die Schicht [dao] hat sie in eine [TaxException] gekapselt;
  • Spring selbst hat die [TaxException] in eine [BeanCreationException] gekapselt, deren Meldung die Bean angibt, die nicht erstellt werden konnte: die vom Typ [ITaxDao], die die Funktion [registerBean] nach dem vollständigen Typnamen benannt hat, [tax.dao.ITaxDao]. Diese Exception wurde über den Aufruf von [refresh] bis zum Hauptprogramm weitergegeben.

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

Schließlich tritt bei einer Konfigurationsdatei, die nicht existiert, der Fehler schon vor der Erstellung des Containers auf:

1
2
3
4
5
> gradlew -q :TaxV5:tax-ui:run --args="tax-missing.properties"
Exception chain:
----------------------------------------
java.nio.file.NoSuchFileException: tax-missing.properties
----------------------------------------

Die Meldung der vom JDK ausgelösten [NoSuchFileException], enthält nur den Dateinamen.

6.4.6.4. Eine Variante: die XML-Konfiguration

Frühe Versionen von Spring beschrieben Beans in einer XML-Datei, und viele Anwendungen tun dies noch immer. Das Teilprojekt [tax-ui] enthält dafür ein Beispiel, die Datei [tax-beans.xml]:

<?xml version="1.0" encoding="UTF-8"?>
<!-- XML-Konfiguration des Spring-Containers: die Beans der [Tax]-Anwendung -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- die [dao]-Schicht: die Implementierungsklasse und das Argument ihres Konstruktors -->
    <bean id="dao" class="tax.dao.FileTax">
        <constructor-arg value="TaxData.txt"/>
    </bean>

    <!-- die [business]-Schicht: ihr Konstruktor erhält die [dao]-Bean -->
    <bean id="business" class="tax.business.TaxBusiness">
        <constructor-arg ref="dao"/>
    </bean>
</beans>
  • Zeilen 3–6: das Wurzelelement [beans] und der XML-Namespace von Spring. Das Attribut [xsi:schemaLocation] ordnet diesem Namespace das Schema zu, das die zulässigen Elemente beschreibt; Spring findet es in seinen eigenen JAR-Dateien, ohne Netzwerkzugriff zu benötigen;
  • Zeilen 9–11: die Bean der Schicht [dao]. Das Attribut [id] gibt ihr einen Namen, das Attribut [class] liefert den vollständigen Namen der zu instanziierenden Klasse, und das Element [constructor-arg] legt den Wert ([value]) fest, der ihrem Konstruktor übergeben wird: der Name der Datendatei. Um die Implementierung zu wechseln, sind diese Zeilen zu ändern;
  • Zeilen 14–15: die Bean der Schicht [business]. Ihr Konstruktor erhält eine Referenz ([ref]) auf die Bean mit dem Namen [dao]: Das ist Dependency Injection, in der XML-Datei beschrieben.

Das Hauptprogramm [MainXml.kt] verwendet diese Konfiguration:

package tax.ui

import tax.business.ITaxBusiness
import kotlin.system.exitProcess
import org.springframework.beans.factory.getBean
import org.springframework.context.support.GenericXmlApplicationContext

// Integration der Schichten durch den Spring-Container, konfiguriert über eine XML-Datei
fun main(args: Array<String>) {
    // die XML-Datei: standardmäßig tax-beans.xml oder die als Argument übergebene (im aktuellen Ordner)
    val xmlFile = args.firstOrNull() ?: "tax-beans.xml"
    try {
        // Erstellen und Starten des Containers; use schließt ihn am Ende des Blocks
        GenericXmlApplicationContext("file:$xmlFile").use { context ->
            // die [business]-Schicht und der Dialog mit dem Benutzer
            val business = context.getBean<ITaxBusiness>()
            Dialog.run(business)
        }
    } catch (e: Exception) {
        // Anzeige des Fehlers und Beenden des Programms
        Dialog.displayError(e)
        exitProcess(1)
    }
}
  • Zeile 11: der Name der XML-Datei: standardmäßig [tax-beans.xml] oder die als Argument übergebene;
  • Zeile 14: [GenericXmlApplicationContext] ist ein Container, der über XML-Dateien konfiguriert wird. Sein Konstruktor liest die angegebenen Dateien, registriert die darin beschriebenen Beans und startet den Container. 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. Der Container implementiert die Schnittstelle [AutoCloseable] (und [Closeable]): Die Funktion [use] schließt ihn am Ende des Blocks, wodurch die Beans freigegeben werden;
  • Zeile 16: Die Schicht [business] wird wie zuvor abgerufen, ohne ihren Klassennamen anzugeben;
  • Zeilen 19–22: Fehlerbehandlung.

Ergebnisse:

1
2
3
4
> gradlew -q :TaxV5:tax-ui:run -Pmain=tax.ui.MainXmlKt
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:

Die XML-Datei wählt nicht mehr unter den im Code festgelegten Implementierungen aus: Sie nennt die Klasse selbst, die Spring per Reflection erstellt. Das ist flexibler, da sich eine Implementierung hinzufügen lässt, ohne das Hauptprogramm zu ändern; der Compiler führt jedoch keine Prüfung mehr durch. Die Datei [tax-beans-error.xml] unterscheidet sich von der vorherigen nur durch einen Tippfehler im Namen der Klasse der Schicht [dao] ([tax.dao.FileTaxes]). Der Fehler tritt erst zur Laufzeit auf:

1
2
3
4
5
6
7
8
9
> gradlew -q :TaxV5:tax-ui:run -Pmain=tax.ui.MainXmlKt --args="tax-beans-error.xml"
Oct 04, 2026 12:25:55 PM org.springframework.context.support.GenericXmlApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.CannotLoadBeanClassException: Cannot find class [tax.dao.FileTaxes] for bean with name 'dao' defined in URL [file:tax-beans-error.xml]
Exception chain:
----------------------------------------
org.springframework.beans.factory.CannotLoadBeanClassException: Cannot find class [tax.dao.FileTaxes] for bean with name 'dao' defined in URL [file:tax-beans-error.xml]
----------------------------------------
java.lang.ClassNotFoundException: tax.dao.FileTaxes
----------------------------------------

Die [CannotLoadBeanClassException] von Spring gibt die Bean, die nicht auffindbare Klasse und die Datei an, die sie beschreibt; sie kapselt die [ClassNotFoundException] der virtuellen Maschine. Beachten Sie, dass die XML-Konfiguration keinerlei Anpassung an Kotlin erforderte: Für Spring sind die Klassen [FileTax] und [TaxBusiness] gewöhnliche Java-Klassen mit einem öffentlichen Konstruktor.

6.4.6.5. Eine Alternative: Konfiguration über eine annotierte Klasse

Moderne Spring-Anwendungen beschreiben ihre Beans üblicherweise in einer annotierten Konfigurationsklasse. Das Teilprojekt [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 Konfiguration des Spring-Containers, geschrieben als annotierte Kotlin-Klasse
@Configuration
// die Eigenschaften der Datei tax.properties im aktuellen Ordner sind über ${...} zugänglich
@PropertySource("file:tax.properties")
class TaxConfig {

    // die [dao]-Schicht: die Implementierung wird durch die Konfiguration gewählt
    @Bean
    fun dao(
        @Value("\${dao.implementation}") implementation: String,
        @Value("\${dao.file:}") file: String,
    ): ITaxDao = when (implementation) {
        "HardwiredTax" -> HardwiredTax()
        "FileTax" -> FileTax(file)
        "JsonTax" -> JsonTax(file)
        else -> throw TaxException("Unknown implementation [$implementation] of the [dao] layer")
    }

    // die [business]-Schicht: Spring übergibt der Funktion die von der Funktion dao erstellte [dao]-Schicht
    @Bean
    fun business(dao: ITaxDao): ITaxBusiness = TaxBusiness(dao)
}
  • Zeile 16: Die Annotation [@Configuration] zeigt an, dass die Klasse Beans beschreibt;
  • Zeile 18: Die Annotation [@PropertySource] weist Spring an, die Datei [tax.properties] aus dem aktuellen Verzeichnis (Präfix [file:]) selbst zu lesen;
  • Zeilen 22–30: Eine mit [@Bean] annotierte Funktion erstellt eine Bean, deren Name der Funktionsname ([dao]) und deren Typ der Rückgabetyp der Funktion ist. Spring ruft die Funktion 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], mit der leeren Zeichenkette (hinter dem Doppelpunkt) als Standardwert. Beachten Sie: In einer Kotlin-Zeichenkette ist [${...}] ein Platzhalter, den der Compiler durch den Wert des darin enthaltenen Ausdrucks ersetzen würde; das Zeichen [$] muss daher mit einem Backslash maskiert werden, ["\${dao.implementation}"], damit die an Spring übergebene Zeichenkette tatsächlich [${dao.implementation}] enthält. Der Rumpf der Funktion ist ein Ausdruck [when];
  • Zeilen 34–35: die Bean aus der Schicht [business]. Die Funktion erwartet ein Objekt vom Typ [ITaxDao]: Spring übergibt ihr die Bean, die von der Funktion [dao] erzeugt wurde. Diesmal erfolgt die Injektion über einen Funktionsparameter.

Damit eine Singleton-Bean nur einmal erzeugt wird – auch wenn eine Funktion [@Bean] eine andere Funktion aufruft –, leitet Spring zur Laufzeit eine Unterklasse der Konfigurationsklasse ab, die ihre Funktionen [@Bean] überschreibt: Weder die Klasse noch diese Funktionen dürfen daher final sein. In Kotlin sind Klassen und ihre Methoden jedoch standardmäßig final (Kapitel 4). Sie müssten [open class TaxConfig] und [open fun dao(...)]… schreiben. Dafür gibt es das Compiler-Plugin [plugin.spring], das in der Build-Datei des Teilprojekts angewendet wird: Es macht automatisch die mit [@Configuration], [@Component], [@Service], [@Transactional]… annotierten Klassen und ihre Member offen (open). Es ist eine Spring-spezifische Ausprägung des Plugins [all-open], das ausgewählte annotierte Klassen öffnet. Das passiert, wenn Sie denselben Code ohne dieses Plugin kompilieren:

1
2
3
4
5
6
7
8
9
> gradlew -q :TaxV5:tax-ui:run -Pmain=tax.ui.MainConfigKt      (without the plugin.spring plugin)
Oct 04, 2026 12:26:36 PM org.springframework.context.annotation.AnnotationConfigApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: @Configuration class 'TaxConfig' may not be final. Remove the final modifier to continue.
Offending resource: tax.ui.TaxConfig
Exception chain:
----------------------------------------
org.springframework.beans.factory.parsing.BeanDefinitionParsingException: Configuration problem: @Configuration class 'TaxConfig' may not be final. Remove the final modifier to continue.
Offending resource: tax.ui.TaxConfig
----------------------------------------

Spring lehnt die finale Klasse beim Start des Containers mit einer eindeutigen Fehlermeldung ab.

Das Hauptprogramm [MainConfig.kt] verwendet diese Konfiguration:

package tax.ui

import tax.business.ITaxBusiness
import kotlin.system.exitProcess
import org.springframework.beans.factory.getBean
import org.springframework.context.annotation.AnnotationConfigApplicationContext

// Integration der Schichten durch den Spring-Container, konfiguriert über die Klasse TaxConfig
fun main() {
    try {
        // Erstellen und Starten des Containers; use schließt ihn am Ende des Blocks
        AnnotationConfigApplicationContext(TaxConfig::class.java).use { context ->
            // die [business]-Schicht und der Dialog mit dem Benutzer
            val business = context.getBean<ITaxBusiness>()
            Dialog.run(business)
        }
    } catch (e: Exception) {
        // Anzeige des Fehlers und Beenden des Programms
        Dialog.displayError(e)
        exitProcess(1)
    }
}
  • Zeile 12: [AnnotationConfigApplicationContext] ist ein Container, der durch annotierte Klassen konfiguriert wird. Sein Konstruktor registriert die Beans, die die Klasse [TaxConfig] beschreibt, und startet den Container. Die Klasse wird als Java-Klasse übergeben, [TaxConfig::class.java]; die Funktion [use] fährt den Container am Ende des Blocks herunter;
  • Zeile 14: Die Schicht [business] wird wie zuvor abgerufen;
  • Zeilen 17–20: Fehlerbehandlung.

Ergebnisse:

1
2
3
4
> gradlew -q :TaxV5:tax-ui:run -Pmain=tax.ui.MainConfigKt
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 (hier eine Datei [tax.properties], deren Inhalt dem von [tax-error.properties] entspräche) enthält die Ausnahmekette nun eine zusätzliche Ebene: Spring meldet den Fehlschlag der Funktion [dao] über eine [BeanInstantiationException], die in der [BeanCreationException] gekapselt ist:

> gradlew -q :TaxV5:tax-ui:run -Pmain=tax.ui.MainConfigKt
Oct 04, 2026 12:26:13 PM org.springframework.context.annotation.AnnotationConfigApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'dao' defined in tax.ui.TaxConfig: Failed to instantiate [tax.dao.ITaxDao]: Factory method 'dao' threw exception with message: Error while reading the file TaxDataMissing.txt
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'dao' defined in tax.ui.TaxConfig: Failed to instantiate [tax.dao.ITaxDao]: Factory method 'dao' threw exception with message: Error while reading the file TaxDataMissing.txt
----------------------------------------
org.springframework.beans.BeanInstantiationException: Failed to instantiate [tax.dao.ITaxDao]: Factory method 'dao' threw exception with message: Error while reading the file TaxDataMissing.txt
----------------------------------------
tax.entities.TaxException: Error while reading the file TaxDataMissing.txt
----------------------------------------
java.nio.file.NoSuchFileException: TaxDataMissing.txt: The file [TaxDataMissing.txt] does not exist
----------------------------------------

Spring kann auch automatisch ermitteln, welche Klassen zu instanziieren sind: 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. Wir haben darauf hier verzichtet, da dafür die Klassen der Schichten hätten annotiert werden müssen und somit von Spring abhängig geworden wären. Spring Boot nutzt diesen Mechanismus in Kapitel 13 ausgiebig. Schließlich sei erwähnt, dass Spring in Kotlin auch eine eigene Sprache zur programmatischen Deklaration von Beans bietet ([BeanRegistrarDsl]), die noch knapper ist als die Aufrufe von [registerBean] in unserem Programm [Main.kt].

Die Dependency Injection verdient ein eigenes Kapitel. Wir haben nur das Wesentliche verwendet: das Registrieren von Beans ([registerBean], XML-Datei, [@Bean]), das Starten des Containers ([refresh]) und das Abrufen einer Bean ([getBean]). Der Container kann außerdem für jede Anforderung ein neues Objekt erzeugen (Scope [prototype]), ein Objekt pro Anfrage (HTTP) oder eines pro Sitzung in einer Webanwendung (Scopes [request] und [session]). Mehr zu diesem Thema finden Sie in der Spring-Dokumentation: The IoC Container und auf den Seiten zu Kotlin: Kotlin.

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 die Schicht [dao] nur über ihre Schnittstelle kennt;
  • 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 miteinander verbindet, hier mithilfe des Dependency-Injection-Containers von Spring und einer Konfigurationsdatei;
  • automatisierte Unit-Tests, die mit JUnit und kotlin.test geschrieben sind, 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 voll, in denen die Teilprojekte [tax-dao], [tax-business] und [tax-ui] aus Version 5 über einen Composite Build unverändert als gewöhnliche 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 den ORM 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 damit auf mehrere Maschinen verteilt, was dem Begriff „Tier“ seine ursprüngliche Bedeutung zurückgibt;
  • Version 9 (Kapitel 13, „Webservices“): Die Schicht [business] wird durch einen mit Spring Boot geschriebenen REST/JSON-Webservice bereitgestellt, dessen Konsolen-Client die Klasse [HttpClient] aus dem JDK verwendet.

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