Skip to content

9. Schichtenarchitektur und Datenzugriff

Die vorherigen Beispiele speicherten ihre Daten im Speicher. Eine reale Anwendung speichert sie in einer Datenbank und ist in Schichten gegliedert (siehe das Diagramm in der Einführung):

  • die Web-Schicht (Controller, Views): liest die Anfrage, ruft die Geschäftsschicht auf, wählt die View aus;
  • die Geschäftsschicht: Geschäftsregeln;
  • die DAO-Schicht ([Data Access Object]): Datenbankabfragen.

Jede Schicht kennt nur die darunterliegende Schicht, und von dieser so wenige Details wie möglich: Die Web-Schicht kennt kein SQL, und die Geschäftsschicht kennt kein HTML. Diese Trennung macht jede Schicht leichter verständlich, testbar und weiterentwickelbar. Beispiel 28 wendet dies auf die Verwaltung einer Personenliste an: Es ist, in kleinerem Maßstab, die Verwaltung der Ärzte und Klienten der Fallstudie.

In [Java] ist der Datenbankzugriff auf mehrere Schichten verteilt:

  • [JDBC] ([Java Database Connectivity]) ist die Standardschnittstelle, mit der [Java] SQL-Befehle an eine Datenbank sendet. Jedes Datenbankverwaltungssystem stellt einen Treiber [JDBC] bereit: für [MySQL] ist es die Bibliothek [mysql-connector-j]. Das Öffnen einer Verbindung ist ressourcenintensiv: [Spring Boot] verwendet einen Connection-Pool ([HikariCP]), der einige Verbindungen offen hält und sie an Anfragen verleiht;
  • [JPA] ([Jakarta Persistence API]) ist der Standard für [Java] im Bereich ORM ([Object-Relational Mapper]): Er bildet [Java]-Klassen (Entitäten) auf Datenbanktabellen ab und wandelt die gelesenen Zeilen in Objekte um. [JPA] ist lediglich ein Standard, bestehend aus Schnittstellen und Annotationen; das ORM, das ihn implementiert, ist hier [Hibernate];
  • [Spring Data JPA] wird darauf aufgesetzt: Sie müssen lediglich eine DAO-Schnittstelle deklarieren, und [Spring Data JPA] schreibt die Implementierung beim Start der Anwendung selbst, einschließlich der Abfragen, die es aus den Methodennamen ableitet.

Dies alles stellt der Starter [spring-boot-starter-data-jpa] bereit.

9.1. Beispiel 28: Ein dreischichtiges Personalverwaltungssystem

28-layers/
├── database/
│   └── dbpersons.sql
├── src/
│   └── main/
│       ├── java/
│       │   └── example28/
│       │       ├── config/
│       │       │   └── WebConfig.java
│       │       ├── controllers/
│       │       │   └── PersonsController.java
│       │       ├── dao/
│       │       │   └── PersonsDao.java
│       │       ├── entities/
│       │       │   └── Person.java
│       │       ├── business/
│       │       │   ├── PersonData.java
│       │       │   ├── BusinessException.java
│       │       │   └── PersonsBusiness.java
│       │       ├── models/
│       │       │   └── PersonForm.java
│       │       └── Example28Application.java
│       └── resources/
│           ├── static/
│           │   ├── css/
│           │   │   └── styles.css
│           │   └── js/
│           │       └── app.js
│           ├── templates/
│           │   ├── fragments/
│           │   │   ├── field.html
│           │   │   └── confirmation.html
│           │   ├── persons/
│           │   │   ├── form.html
│           │   │   └── list.html
│           │   └── layout.html
│           ├── application.properties
│           └── messages.properties
└── pom.xml

9.1.1. Die Datenbank

Die Datenbank [dbpersons] wird durch ein SQL-Skript erstellt. Mit [Laragon] können Sie es zum Beispiel im Tool [HeidiSQL] ausführen (Menü Datei / SQL-Datei ausführen) oder über die Befehlszeile aus dem Beispielordner:

mysql -u root < database/dbpersons.sql

Die Datei [database/dbpersons.sql]:

-- Datenbank von Beispiel 28: eine einzige Tabelle, [persons]
-- das Skript ist in UTF-8 geschrieben
SET NAMES utf8mb4;
DROP DATABASE IF EXISTS dbpersons;
CREATE DATABASE dbpersons CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE dbpersons;

CREATE TABLE persons (
  id INT NOT NULL AUTO_INCREMENT,
  -- die Version der Zeile, bei jeder Änderung von JPA erhöht
  version INT NOT NULL DEFAULT 0,
  first_name VARCHAR(30) NOT NULL,
  last_name VARCHAR(30) NOT NULL,
  age INT NOT NULL,
  PRIMARY KEY (id),
  -- zwei Personen dürfen nicht denselben Vor- und Nachnamen haben
  CONSTRAINT unq_persons_first_name_last_name UNIQUE (first_name, last_name)
) ENGINE = InnoDB;

INSERT INTO persons (first_name, last_name, age) VALUES
  ('Marie', 'Pélissier', 42),
  ('Jacques', 'Bromard', 35),
  ('Philippe', 'Jandot', 58);
  • Zeile 3: Das Skript ist in UTF-8 geschrieben; dies wird dem Server mitgeteilt, damit die Akzente in den Daten ([Pélissier]) erhalten bleiben;
  • Zeile 5: Der Zeichensatz [utf8mb4] akzeptiert alle Zeichen (Akzente, Emojis usw.). Die Kollation [utf8mb4_unicode_ci] vergleicht Zeichenfolgen, ohne zwischen Groß- und Kleinbuchstaben oder Akzenten zu unterscheiden: Für [MySQL] sind [pelissier] und [Pélissier] gleich;
  • Zeile 11: eine Versionsnummer, die bei jeder Änderung der Zeile erhöht wird (siehe „optimistische Sperre“ weiter unten);
  • Zeile 17: eine benannte Eindeutigkeitsbedingung: Die Datenbank lässt nicht zwei Personen mit demselben Vor- und Nachnamen zu. Der Name dient dazu, den Fehler zu identifizieren.

9.1.2. Die Konfiguration

Die Datei [pom.xml]:

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

  <dependencies>
    <!-- die Thymeleaf-Views -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- Validierung (Bean Validation, Hibernate Validator) -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
    <!-- Spring Data JPA (Hibernate) und der MySQL-JDBC-Treiber -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.mysql</groupId>
      <artifactId>mysql-connector-j</artifactId>
      <scope>runtime</scope>
    </dependency>
  </dependencies>
</project>
  • Zeilen 20–23: Datenvalidierung (siehe Kapitel 3);
  • Zeilen 25–28: [Spring Data JPA] samt [Hibernate], [HikariCP] und der Transaktionsverwaltung für [Spring];
  • Zeilen 29–33: der Treiber [JDBC] für [MySQL]. Der Scope [runtime] zeigt an, dass der Anwendungscode ihn nicht direkt verwendet (er kennt nur [JPA]): Der Treiber wird nur zur Laufzeit benötigt. Er funktioniert auch mit [MariaDB].

Die Datei [application.properties]:

# der Listening-Port des Servers (standardmäßig 8080)
server.port=5000
# die Fehlerantworten von Spring Boot enthalten den Call Stack nicht
spring.web.error.include-stacktrace=never
# die Session (die die Flash-Attribute trägt) wird ausschließlich über ein Cookie verfolgt
server.servlet.session.tracking-modes=cookie

# die Verbindung zur Datenbank: JDBC-URL, Benutzer, Passwort (die von Laragon)
spring.datasource.url=jdbc:mysql://localhost:3306/dbpersons
spring.datasource.username=root
spring.datasource.password=
# Hibernate erstellt oder ändert die Tabellen nicht: das ist die Aufgabe des SQL-Skripts
spring.jpa.hibernate.ddl-auto=none
# die Verbindung zur Datenbank bleibt nicht geöffnet, während die View aufgebaut wird
spring.jpa.open-in-view=false
# true: die an die Datenbank gesendeten SQL-Anweisungen werden in der Konsole angezeigt
spring.jpa.show-sql=false
  • Zeile 6: Erfolgsmeldungen werden als Flash-Attribute gesendet (siehe Beispiel 20) und in der Session gespeichert: Das Session-Cookie reicht aus, um sie abzurufen, ohne dass die Session-ID an die URL angehängt wird;
  • Zeilen 9–11: die Verbindung zur Datenbank für die Datenquelle ([DataSource]), die [Spring Boot] mithilfe von [HikariCP] erstellt: URL [JDBC] (Treiber, Server, Port, Datenbank), Benutzername und Passwort. Dies sind die Standardwerte von [Laragon] (Benutzer [root], kein Passwort). Der Datenbanktyp (und seine Version) muss nicht angegeben werden: [Hibernate] fragt diese Informationen beim ersten Verbindungsaufbau vom Server ab und passt das erzeugte SQL entsprechend an;
  • Zeile 13: [Hibernate] kann Tabellen anhand der Entitäten erstellen oder ändern; dies ist untersagt ([none]): Die Datenbank wird durch das SQL-Skript erstellt und dient als Referenz;
  • Zeile 15: Standardmäßig hält [Spring Boot] die [JPA]-Session (und ihre Verbindung zur Datenbank) offen, bis die View vollständig generiert ist ([Open Session In View]): Eine View könnte dann SQL-Abfragen auslösen, ohne dass der Benutzer es bemerkt. Dieses Verhalten ist deaktiviert: Alle Lesezugriffe erfolgen vor der View in der Geschäftsschicht. Wird diese Eigenschaft nicht angegeben, meldet [Spring Boot] dies beim Start mit einer Warnung ([spring.jpa.open-in-view is enabled by default...]);
  • Zeile 17: [true] zeigt in der Konsole jeden SQL-Befehl an, den [Hibernate] sendet (siehe die Ausführung weiter unten).

Die Datei [messages.properties] enthält eine Konvertierungsfehlermeldung (ein Alter [abc]) wie in Beispiel 19. Die Klasse [config/WebConfig.java] stellt [Bootstrap] bereit, wie in den vorherigen Beispielen.

9.1.3. Die Entität Person

Die Datei [entities/Person.java]:

package example28.entities;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Version;

// eine Zeile der Tabelle [persons]
@Entity
@Table(name = "persons")
public class Person {

    // der Primärschlüssel, von der Datenbank erzeugt (AUTO_INCREMENT); JPA liest seinen
    // Wert nach jedem INSERT erneut
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

    // optimistisches Sperren: JPA erhöht die Version bei jedem UPDATE und fügt
    // die Bedingung "AND version = <gelesener Wert>" hinzu
    @Version
    @Column(name = "version")
    private Integer version;

    @Column(name = "first_name", length = 30)
    private String firstName;

    @Column(name = "last_name", length = 30)
    private String lastName;

    @Column(name = "age")
    private int age;

    // ein Konstruktor ohne Parameter wird von JPA benötigt
    public Person() {
    }

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Integer getId() { return id; }

    public Integer getVersion() { return version; }

    public String getFirstName() { return firstName; }
    public void setFirstName(String firstName) { this.firstName = firstName; }

    public String getLastName() { return lastName; }
    public void setLastName(String lastName) { this.lastName = lastName; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}
  • Zeile 12: [@Entity] erzeugt eine [JPA] -Entität aus der Klasse [Person]: Jede Zeile der Tabelle wird zu einem [Person]-Objekt. Die Annotationen stammen aus dem Paket [jakarta.persistence]: Es sind die aus dem Standard [JPA], nicht die von [Hibernate];
  • Zeile 13: die zugehörige Tabelle (standardmäßig wäre dies [Person]);
  • Zeilen 18–21: der Primärschlüssel ([@Id]). [@GeneratedValue(strategy = GenerationType.IDENTITY)] gibt an, dass sein Wert von der Datenbank vergeben wird ([AUTO_INCREMENT]): [Hibernate] liest den vergebenen Wert nach jedem [INSERT] aus. Der Typ [Integer] – nicht [int] – erlaubt den Wert [null]: Eine Person, die noch nicht gespeichert wurde, hat keine ID. [@Column] gibt den Spaltennamen an, der dem jeweiligen Feld entspricht;
  • Zeilen 25–27: die Versionsspalte. [@Version] überträgt die optimistische Sperre an [Hibernate]: Es setzt die Version beim [INSERT] auf 0, erhöht sie bei jedem [UPDATE] um 1 und fügt die Bedingung [AND version = <value read>] bei jedem [UPDATE] (und bei jedem [DELETE]) hinzu. Wozu das dient, sehen wir später;
  • Zeilen 29–36: die übrigen Spalten. [length] legt die Spaltenbreite fest: Sie wäre nur relevant, wenn [Hibernate] die Tabelle selbst erstellen würde, was hier nicht der Fall ist (siehe [ddl-auto]);
  • Zeilen 39–40: [JPA] verlangt einen parameterlosen Konstruktor: Es ist derjenige, den [Hibernate] verwendet, um aus einer gelesenen Zeile ein Objekt zu erzeugen, bevor es seine Felder befüllt;
  • Zeilen 48–59: die Zugriffsmethoden (Methoden [getX] und [setX]): Die Entität ist eine JavaBean. Es gibt kein [setId] und kein [setVersion]: Diese beiden Werte werden nur von [Hibernate] geschrieben, das direkt auf die Felder zugreift.

9.1.4. Die DAO-Schicht

Die Datei [dao/PersonsDao.java]:

package example28.dao;

import java.util.List;
import java.util.Optional;

import org.springframework.data.jpa.repository.JpaRepository;

import example28.entities.Person;

// die DAO-Schicht: Abfragen, keine Geschäftsregel.
// Ein Interface, das Spring Data JPA beim Start selbst IMPLEMENTIERT.
// JpaRepository<Person, Integer> bringt bereits findById, save, deleteById ... mit
public interface PersonsDao extends JpaRepository<Person, Integer> {

    // der Name der Methode beschreibt die Abfrage:
    // SELECT ... FROM persons ORDER BY last_name, first_name
    List<Person> findAllByOrderByLastNameAscFirstNameAsc();

    // eine Person mit gleichem Vor- und Nachnamen, außer [exceptId]:
    // SELECT ... WHERE first_name = ? AND last_name = ? AND id <> ? LIMIT 1
    Optional<Person> findFirstByFirstNameAndLastNameAndIdNot(String firstName, String lastName, Integer exceptId);
}

Dies ist die gesamte DAO-Schicht: eine Schnittstelle ohne eine einzige Zeile ausführbaren Codes.

  • Zeile 13: Die Schnittstelle erbt von [JpaRepository<Person, Integer>] (eine Entität [Person], deren Schlüssel ein [Integer] ist). Beim Start erzeugt [Spring Data JPA] eine Klasse, die diese Schnittstelle implementiert, und macht sie zu einem Bean, das anschließend injiziert wird. [JpaRepository] stellt bereits die Standardmethoden bereit: [findById] (Lesen über den Schlüssel, Ergebnis in einem [Optional]), [findAll], [save] ([INSERT] oder [UPDATE]), [saveAndFlush], [deleteById], [count] ...;
  • Zeile 17: eine abgeleitete Abfrage: [Spring Data JPA] analysiert den Methodennamen und leitet daraus die Abfrage ab. [findAll]: alle Personen; [By]: ohne Bedingungen, da nichts folgt; [OrderByLastNameAscFirstNameAsc]: sortiert nach Nachname, dann nach Vorname, jeweils aufsteigend;
  • Zeile 21: [findFirst]: die erste gefundene Person ([LIMIT 1]) oder ein leeres [Optional]; [ByFirstNameAndLastNameAndIdNot]: deren Vor- und Nachname mit den als Parametern übergebenen übereinstimmen und deren ID sich vom dritten Parameter unterscheidet. Das ist nützlich beim Ändern eines Datensatzes, der nicht mit sich selbst in Konflikt geraten darf. Der Vergleich wird von [MySQL] durchgeführt und folgt somit den Kollationsregeln der Datenbank: Er ignoriert Groß-/Kleinschreibung und Akzente.

Ein Fehler in einem Methodennamen ([findAllByOrderByLastNamee]) wird beim Start erkannt: Die Anwendung verweigert den Start und meldet eine unbekannte Eigenschaft. Eine für einen Methodennamen zu komplexe Abfrage wird in der Sprache [JPQL] ([Jakarta Persistence Query Language], ein SQL, das sich auf Entitäten und ihre Felder statt auf Tabellen bezieht), in einer Annotation [@Query] geschrieben: Die Fallstudie verwendet einige davon.

9.1.5. Die Geschäftsschicht

Die Datei [business/BusinessException.java]:

1
2
3
4
5
6
7
8
9
package example28.business;

// eine Geschäftsregel lehnt den Vorgang ab: die Meldung ist für den Benutzer bestimmt
public class BusinessException extends RuntimeException {

    public BusinessException(String message) {
        super(message);
    }
}

Eine [BusinessException] zeigt an, dass eine Geschäftsregel eine Operation ablehnt. Das ist kein Programmfehler: Ihre Meldung ist für den Benutzer bestimmt. Sie erbt von [RuntimeException]: Es ist eine ungeprüfte Exception, die eine Methode auslösen kann, ohne sie zu deklarieren ([throws]). Wir werden sehen, dass diese Wahl auch für Transaktionen gilt.

Die Datei [business/PersonData.java]:

1
2
3
4
5
package example28.business;

// die Daten einer Person, wie die Web-Schicht sie weitergibt
public record PersonData(String firstName, String lastName, int age) {
}

Die Daten einer Person, wie sie von der Web-Schicht übermittelt werden: Die Geschäftsschicht kennt die Formularklasse nicht.

Die Datei [business/PersonsBusiness.java]:

package example28.business;

import java.util.List;
import java.util.Objects;

import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.orm.ObjectOptimisticLockingFailureException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import example28.dao.PersonsDao;
import example28.entities.Person;

// die GESCHÄFTSSCHICHT: die Geschäftsregeln, und nur sie.
// @Transactional auf der Klasse: jede öffentliche Methode läuft in einer
// Transaktion, die am Ende der Methode bestätigt (COMMIT) und, wenn
// sie eine Exception wirft, abgebrochen wird (ROLLBACK)
@Service
@Transactional
public class PersonsBusiness {

    private static final String NAMESAKE = "A person already has these first and last names.";
    private static final String MODIFIED = "This record has been modified meanwhile: reload it.";

    private final PersonsDao dao;

    public PersonsBusiness(PersonsDao dao) {
        this.dao = dao;
    }

    // readOnly: eine schreibgeschützte Transaktion
    @Transactional(readOnly = true)
    public List<Person> list() {
        return dao.findAllByOrderByLastNameAscFirstNameAsc();
    }

    @Transactional(readOnly = true)
    public Person read(int id) {
        return dao.findById(id).orElseThrow(() -> new BusinessException("This person does not exist (anymore)."));
    }

    public Person add(PersonData data) {
        // Regel 1: keine zwei Personen mit gleichem Vor- und Nachnamen
        if (dao.findFirstByFirstNameAndLastNameAndIdNot(data.firstName(), data.lastName(), 0).isPresent()) {
            throw new BusinessException(NAMESAKE);
        }
        return save(new Person(data.firstName(), data.lastName(), data.age()));
    }

    public Person edit(int id, Integer version, PersonData data) {
        Person person = read(id);
        // Regel 2: wir ändern keinen Datensatz, der inzwischen von jemand anderem geändert wurde
        if (!Objects.equals(person.getVersion(), version)) {
            throw new BusinessException(MODIFIED);
        }
        if (dao.findFirstByFirstNameAndLastNameAndIdNot(data.firstName(), data.lastName(), id).isPresent()) {
            throw new BusinessException(NAMESAKE);
        }
        // die gelesene Entität wird von JPA "verfolgt": sie zu ändern genügt
        person.setFirstName(data.firstName());
        person.setLastName(data.lastName());
        person.setAge(data.age());
        return save(person);
    }

    public Person delete(int id) {
        Person person = read(id);
        dao.deleteById(id);
        return person;
    }

    // saveAndFlush: INSERT oder UPDATE wird SOFORT an die Datenbank gesendet (und nicht beim
    // COMMIT), um die Datenbankfehler hier abfangen zu können
    private Person save(Person person) {
        try {
            return dao.saveAndFlush(person);
        } catch (ObjectOptimisticLockingFailureException e) {
            // das UPDATE "WHERE id = ... AND version = ..." hat keine Zeile geändert
            throw new BusinessException(MODIFIED);
        } catch (DataIntegrityViolationException e) {
            // zwei gleichzeitige Hinzufügungen: der Eindeutigkeits-Constraint der Datenbank hat die zweite abgelehnt
            if (String.valueOf(e.getMostSpecificCause().getMessage()).contains("unq_persons_first_name_last_name")) {
                throw new BusinessException(NAMESAKE);
            }
            throw e;
        }
    }
}

Kommentieren wir diesen Code:

  • Zeile 18: Die Geschäftsschicht ist ein Service-Bean;
  • Zeile 19: [@Transactional], an der Klasse angebracht, gilt für jede ihrer öffentlichen Methoden: Die Methode wird innerhalb einer Transaktion ausgeführt, die vor ihrem Aufruf geöffnet ([START TRANSACTION]), bei ihrer Rückkehr festgeschrieben ([COMMIT]) und zurückgerollt ([ROLLBACK]) wird, wenn sie eine ungeprüfte Exception auslöst. Wie bei [@PreAuthorize] (Beispiel 26) umhüllt [Spring] das Bean mit einem Proxy, der die Transaktion um den Aufruf herum öffnet und schließt. Alles, was die Methode tut, einschließlich der Aufrufe des DAO, findet in derselben Transaktion und auf derselben Verbindung statt;
  • Zeilen 32–35: [readOnly = true]: eine schreibgeschützte Transaktion, die [Hibernate] davon befreit, am Ende geänderte Entitäten prüfen zu müssen;
  • Zeilen 37–40: Eine nicht vorhandene Person ist eine [BusinessException]. [orElseThrow] gibt den Inhalt des [Optional] zurück oder löst die vom Lambda erzeugte Exception aus, wenn er leer ist;
  • Zeilen 42–48: das Hinzufügen. Regel: Keine zwei Personen dürfen denselben Vor- und Nachnamen haben. Dies wird vor dem Schreiben geprüft, um eine klare Meldung anzuzeigen. Keine Person hat die ID 0: [IdNot] schließt hier niemanden von der Suche aus;
  • Zeilen 50–64: die Aktualisierung. Zusätzliche Regel: die optimistische Sperre (Zeilen 53–55). Das Aktualisierungsformular verwendet die Version des Datensatzes, wie sie beim Öffnen des Formulars war. Hat sie sich inzwischen geändert (ein anderer Benutzer hat denselben Datensatz bearbeitet), wird die Aktualisierung abgelehnt, statt die Arbeit des Benutzers stillschweigend zu überschreiben. [Objects.equals] vergleicht zwei [Integer]-Instanzen und akzeptiert dabei [null];
  • Zeile 51: Der Aufruf von [read] ist ein interner Aufruf innerhalb der Klasse: Er läuft nicht über den Proxy, und sein [readOnly] greift nicht. [read] wird einfach in der Transaktion von [edit] ausgeführt;
  • Zeilen 60–63: Die in der Transaktion gelesene Entität wird von [Hibernate] verfolgt (man sagt, sie sei „verwaltet“): Ändern Sie einfach ihre Felder; [Hibernate] erkennt die Änderungen und erzeugt ein [UPDATE] für die Spalten der Tabelle;
  • Zeilen 66–70: das Löschen. Die Person wird zuerst gelesen – um zu prüfen, dass sie existiert, und damit der Controller ihren Namen erwähnen kann;
  • Zeilen 74–87: das Speichern. Normalerweise sendet [Hibernate] die Befehle [INSERT] und [UPDATE] erst am Ende der Transaktion an die Datenbank, beim [COMMIT], d. h. nach dem Verlassen der Methode: Ein Datenbankfehler könnte hier nicht mehr abgefangen werden. [saveAndFlush] speichert die Entität und sendet sofort ([flush]) die ausstehenden SQL-Befehle;
  • Zeilen 77–79: Die zuvor erwähnte Versionsprüfung genügt nicht immer: Zwei Benutzer können denselben Datensatz gleichzeitig speichern, und beide bestehen die Prüfung. Das [UPDATE ... WHERE id = ? AND version = ?] des zweiten Benutzers ändert dann keine Zeile; [Hibernate] erkennt dies, und [Spring] löst eine [ObjectOptimisticLockingFailureException] aus, die zu derselben [BusinessException] wird;
  • Zeilen 80–85: Ebenso bestehen zwei gleichzeitige Hinzufügungen derselben Person die Namensprüfung, doch die Eindeutigkeitsbedingung der Datenbank lässt nicht zu, dass beide akzeptiert werden. [Spring] übersetzt die Exceptions der verschiedenen Datenbanken und der verschiedenen ORMs in eine gemeinsame Exception-Hierarchie: Eine Verletzung einer Bedingung wird zu einer [DataIntegrityViolationException]. [getMostSpecificCause()] liefert die ursprüngliche Exception – die des [MySQL]-Treibers –, deren Meldung den Namen der verletzten Bedingung nennt ([Duplicate entry '...' for key 'unq_persons_first_name_last_name']). Eine andere Verletzung einer Bedingung wird weitergereicht (Zeile 85): Das ist eine Anomalie.

In allen Fällen, in denen eine Exception eine Methode von [PersonsBusiness] verlässt (einschließlich [BusinessException], da sie von [RuntimeException] erbt), rollt der Proxy die Transaktion zurück: Keine der Aktionen der Methode bleibt erhalten. Hinweis: Standardmäßig löst eine geprüfte Exception (die von [Exception] erbt, ohne von [RuntimeException] zu erben) kein Rollback aus.

Diesen letzten Fall haben wir überprüft, indem wir 30 Anfragen gleichzeitig sendeten, um dieselbe Person hinzuzufügen: Nur eine wurde akzeptiert; bei den anderen lehnte die Datenbank das [INSERT] ab (Fehler [MySQL] Nr. 1062, den [Hibernate] in der Konsole als Warnung [HHH000247] meldet), und der Benutzer erhielt die Meldung zum Namensduplikat, keinen 500-Fehler.

9.1.6. Die Web-Schicht

Die Datei [models/PersonForm.java]:

package example28.models;

import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;

// die Formularfelder und ihre Constraints (siehe Beispiel 19)
public class PersonForm {

    @NotBlank(message = "The first name is required.")
    @Size(max = 30, message = "30 characters at most.")
    private String firstName;

    @NotBlank(message = "The last name is required.")
    @Size(max = 30, message = "30 characters at most.")
    private String lastName;

    @NotNull(message = "The age is required.")
    @Min(value = 0, message = "The age must be between 0 and 150.")
    @Max(value = 150, message = "The age must be between 0 and 150.")
    private Integer age;

    // die Version des Datensatzes, in einem versteckten Feld mitgeführt (nur beim Bearbeiten)
    private Integer version;

    public String getFirstName() { return firstName; }
    public void setFirstName(String firstName) { this.firstName = firstName; }

    public String getLastName() { return lastName; }
    public void setLastName(String lastName) { this.lastName = lastName; }

    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }

    public Integer getVersion() { return version; }
    public void setVersion(Integer version) { this.version = version; }
}

Das Formular und seine Validierungsbedingungen (siehe Beispiel 19), wobei die Version des Datensatzes (Zeile 26) über ein verstecktes Feld übergeben wird. Das Alter ist ein [Integer] und kein [int]: Ein leeres Feld ergibt [null], was durch [@NotNull] beanstandet wird.

Die Datei [controllers/PersonsController.java]:

package example28.controllers;

import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import example28.entities.Person;
import example28.business.PersonData;
import example28.business.BusinessException;
import example28.business.PersonsBusiness;
import example28.models.PersonForm;
import jakarta.validation.Valid;

// die WEB-Schicht: sie kennt nur die Geschäftsschicht
@Controller
public class PersonsController {

    private final PersonsBusiness business;

    public PersonsController(PersonsBusiness business) {
        this.business = business;
    }

    // von den empfangenen Strings werden überflüssige Leerzeichen entfernt (siehe Beispiel 19)
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
    }

    @GetMapping("/")
    public String home() {
        return "redirect:/persons";
    }

    @GetMapping("/persons")
    public String list(Model model) {
        model.addAttribute("persons", business.list());
        return "persons/list";
    }

    @GetMapping("/persons/add")
    public String addForm(Model model) {
        return form(model, "Add a person", "/persons/add", new PersonForm(), null);
    }

    @PostMapping("/persons/add")
    public String add(@Valid @ModelAttribute("person") PersonForm input, BindingResult result,
            Model model, RedirectAttributes redirect) {
        if (result.hasErrors()) {
            return form(model, "Add a person", "/persons/add", input, null);
        }
        try {
            Person p = business.add(new PersonData(input.getFirstName(), input.getLastName(), input.getAge()));
            redirect.addFlashAttribute("success", p.getFirstName() + " " + p.getLastName() + " has been added.");
            return "redirect:/persons";
        } catch (BusinessException e) {
            // eine Geschäftsregel lehnt ab: wir zeigen das Formular erneut an, die Meldung am Seitenende
            return form(model, "Add a person", "/persons/add", input, e.getMessage());
        }
    }

    @GetMapping("/persons/{id:\\d+}/edit")
    public String editForm(@PathVariable int id, Model model, RedirectAttributes redirect) {
        try {
            Person p = business.read(id);
            PersonForm values = new PersonForm();
            values.setFirstName(p.getFirstName());
            values.setLastName(p.getLastName());
            values.setAge(p.getAge());
            values.setVersion(p.getVersion());
            return form(model, "Edit a person", "/persons/" + id + "/edit", values, null);
        } catch (BusinessException e) {
            redirect.addFlashAttribute("error", e.getMessage());
            return "redirect:/persons";
        }
    }

    @PostMapping("/persons/{id:\\d+}/edit")
    public String edit(@PathVariable int id, @Valid @ModelAttribute("person") PersonForm input,
            BindingResult result, Model model, RedirectAttributes redirect) {
        String action = "/persons/" + id + "/edit";
        if (result.hasErrors()) {
            return form(model, "Edit a person", action, input, null);
        }
        try {
            PersonData data = new PersonData(input.getFirstName(), input.getLastName(), input.getAge());
            Person p = business.edit(id, input.getVersion(), data);
            redirect.addFlashAttribute("success", p.getFirstName() + " " + p.getLastName() + " has been edited.");
            return "redirect:/persons";
        } catch (BusinessException e) {
            return form(model, "Edit a person", action, input, e.getMessage());
        }
    }

    @PostMapping("/persons/{id:\\d+}/delete")
    public String delete(@PathVariable int id, RedirectAttributes redirect) {
        try {
            Person p = business.delete(id);
            redirect.addFlashAttribute("success", p.getFirstName() + " " + p.getLastName() + " has been deleted.");
        } catch (BusinessException e) {
            // kein Formular erneut anzuzeigen: der Fehler reist ebenfalls als Flash-Attribut
            redirect.addFlashAttribute("error", e.getMessage());
        }
        return "redirect:/persons";
    }

    // das Modell der Formular-View: Titel, Zieladresse zum Senden, Werte, globaler Fehler
    private String form(Model model, String title, String action, PersonForm values, String error) {
        model.addAttribute("title", title);
        model.addAttribute("action", action);
        model.addAttribute("person", values);
        model.addAttribute("error", error);
        return "persons/form";
    }
}

Schauen wir uns diesen Code im Einzelnen an:

  • Zeilen 26–30: Der Controller kennt nur die Geschäftsschicht;
  • Zeilen 33–36: Von den empfangenen Zeichenfolgen werden führende und nachfolgende Leerzeichen entfernt, und eine leere Zeichenfolge wird zu [null] (siehe Beispiel 19);
  • Zeilen 38–41: Die Wurzel der Site leitet auf die Liste um;
  • Zeilen 54–68: das Hinzufügen in drei Schritten: Formularvalidierung (Fehler: Formular erneut anzeigen), Aufruf der Geschäftsschicht (Erfolg: Flash-Meldung und Umleitung; siehe Beispiel 20), bei [BusinessException] (erneut anzeigen mit der Meldung am Seitenende). Eine andere Exception wird nicht abgefangen: Das ist eine Anomalie, die zu einem 500-Fehler führt;
  • Zeile 70: [{id:\\d+}]: eine durch einen regulären Ausdruck eingeschränkte Pfadvariable (siehe Beispiel 02): [\d+] steht für eine Folge von Ziffern (der Backslash wird im [Java]-String verdoppelt). [/persons/abc/edit] entspricht keiner Aktion: Fehler 404;
  • Zeilen 70–84: das Aktualisierungsformular, vorausgefüllt mit dem aus der Datenbank gelesenen Datensatz einschließlich seiner Version;
  • Zeilen 86–101: gleiche Struktur wie beim Hinzufügen; die vom Formular zurückgegebene Version wird an die Geschäftsschicht übergeben;
  • Zeilen 103–113: das Löschen. Es gibt kein Formular, das erneut angezeigt werden müsste: Etwaige Fehler werden ebenfalls über das Flash-Attribut übergeben;
  • Zeilen 116–122: das View-Template des Formulars, das sowohl zum Hinzufügen als auch zum Ändern von Datensätzen dient: unterschiedlicher Titel und Übermittlungsadresse, Formularwerte und Fehler der Geschäftsschicht.

Die Datei [templates/persons/form.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3" th:text="${title}">Add a person</h1>
  <form method="post" th:action="${action}" th:object="${person}" novalidate>
    <!--/* die Version des gelesenen Datensatzes: sie kommt mit dem Formular zurück */-->
    <input type="hidden" th:field="*{version}">
    <div th:replace="~{fragments/field :: field(name='firstName', label='First name', type='text')}"></div>
    <div th:replace="~{fragments/field :: field(name='lastName', label='Last name', type='text')}"></div>
    <div th:replace="~{fragments/field :: field(name='age', label='Age', type='number')}"></div>
    <button class="btn btn-primary" type="submit">Save</button>
    <a class="btn btn-link" href="/persons">Cancel</a>
  </form>
</main>
</body>
</html>
  • Zeile 6: [th:object] bezeichnet das Formularobjekt; [th:action] erhält die vom Controller bereitgestellte Übermittlungsadresse;
  • Zeile 8: das versteckte Feld, das die Version des Datensatzes trägt: [th:field="*{version}"] erzeugt seine Attribute [name] und [value] (siehe Beispiel 19);
  • Zeilen 9–11: die drei Felder, die vom Fragment [field] aus Beispiel 19 erzeugt werden.

Die Datei [templates/layout.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(content)">
<head>
  <meta charset="utf-8">
  <title>Persons</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 40rem">
    <!--/* die Erfolgsmeldung (Flash-Attribut, nach einer Weiterleitung): oben */-->
    <div class="alert alert-success" role="status" th:if="${success != null}" th:text="${success}">success</div>
    <main th:replace="${content}"></main>
    <!--/* der Fehler: aus der aktuellen Anfrage oder von vor der Weiterleitung (Flash-Attribut) */-->
    <div class="error-area" role="alert" th:if="${error != null}" th:text="${error}">error</div>
  </div>
  <div th:replace="~{fragments/confirmation :: confirmation}"></div>
  <script src="/js/app.js"></script>
</body>
</html>
  • Zeile 12: die Erfolgsmeldung am Seitenanfang;
  • Zeile 15: die Fehlermeldung am Seitenende: entweder die der aktuellen Anfrage (im Template platziert durch [form]) oder die vor einer Umleitung als Flash-Attribut gespeicherte. In beiden Fällen ist es das Attribut [error] des View-Templates;
  • Zeilen 17–18: das Bestätigungsfenster und sein Skript (siehe Beispiel 21).

Die View [persons/list.html] hat dieselbe Struktur wie die Kontaktliste in Beispiel 21: Für jede Person gibt es einen Link zum Bearbeitungsformular und ein POST-Löschformular, dessen Absenden bestätigt wird. Das Fragment [fragments/field.html] ist dasselbe wie in Beispiel 19, während das Fenster [fragments/confirmation.html] und das Skript [static/js/app.js] dieselben sind wie in Beispiel 21, ohne Änderungen.

9.1.7. Ausführung

Wenn die Werte in [application.properties] nicht passen (zum Beispiel ein Passwort für [root]), können sie – ohne die Datei zu ändern – durch Umgebungsvariablen ersetzt werden: Der Name der Eigenschaft wird in Großbuchstaben geschrieben, wobei Punkte durch Unterstriche ersetzt werden. Unter [Windows] ([PowerShell]):

$env:SPRING_DATASOURCE_PASSWORD="secret"; ..\mvnw spring-boot:run

Beim Start mit [MariaDB] zeigt [Hibernate] eine Warnung an:

... WARN ... org.hibernate.orm.core : HHH000511: The 5.5.5 version for [org.hibernate.dialect.MySQLDialect] is no longer supported, hence certain features may not work properly.The minimum supported version is 8.0.0. Check the community dialects project for available legacy versions.

Das hat keine Folgen: [MariaDB] meldet sich beim [MySQL]-Treiber mit der Versionsnummer „5.5.5“, die [Hibernate] als sehr altes [MySQL] interpretiert. Mit [MySQL] 8 erscheint sie nicht.

Die Liste unter der URL http://localhost:5000/:

Image

Ein ungültiges Formular:

Image

Ein Namensduplikat: Die Geschäftsregel erkennt es. [MySQL] lehnt beim Vergleich mit der Kollation der Datenbank ebenfalls [marie pelissier] – klein und ohne Akzente geschrieben – ab. Hier die Eingabe [Marie Pélissier]:

Image

Ein erfolgreiches Hinzufügen:

Image

Mit [spring.jpa.show-sql=true] in [application.properties] (oder, ohne die Datei zu ändern, [../mvnw spring-boot:run -Dspring-boot.run.arguments=--spring.jpa.show-sql=true]) zeigt die Konsole jeden von [Hibernate] gesendeten SQL-Befehl an. Hinzufügen einer Person, danach Anzeige der Liste nach der Umleitung:

1
2
3
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.first_name=? and p1_0.last_name=? and p1_0.id<>? limit ?
Hibernate: insert into persons (age,first_name,last_name,version) values (?,?,?,?)
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 order by p1_0.last_name,p1_0.first_name

Hier sehen wir die Suche nach einem Namensduplikat (die aus dem Namen [findFirstByFirstNameAndLastNameAndIdNot] abgeleitete Abfrage), das [INSERT] und anschließend das Lesen der Liste ([findAllByOrderByLastNameAscFirstNameAsc]). Die Werte werden getrennt als Parameter (die [?]) übergeben: Das schützt vor SQL-Injections. Transaktionsbefehle ([START TRANSACTION], [COMMIT]) werden nicht angezeigt. So ändern Sie einen Datensatz:

1
2
3
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.id=?
Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.first_name=? and p1_0.last_name=? and p1_0.id<>? limit ?
Hibernate: update persons set age=?,first_name=?,last_name=?,version=? where id=? and version=?

[UPDATE] schreibt die neue Version und prüft die alte ([where id=? and version=?]): Das ist die optimistische Sperre. Und bei einem Löschvorgang:

Hibernate: select p1_0.id,p1_0.age,p1_0.first_name,p1_0.last_name,p1_0.version from persons p1_0 where p1_0.id=?
Hibernate: delete from persons where id=? and version=?

[deleteById] hat den Datensatz nicht erneut gelesen: Er wurde seit dem Aufruf von [read] bereits in der Transaktion verfolgt.

Die optimistische Sperre: Zwei Formulare sind für denselben Datensatz geöffnet; das erste wird gespeichert (die Version wechselt von 0 auf 1); das zweite, das noch die Version 0 hat, wird abgelehnt:

Image

Löschen mit Bestätigung:

Image

Image