Datenbank-CRUD-Operationen in Java 8 Streams

Hintergrund

Speedment ist ein Open-Source-Toolset, mit dem Java-Entitäten generiert und unser Kommunikationsprozess mit der Datenbank verwaltet werden kann. Sie können ein grafisches Tool verwenden, um eine Verbindung zur Datenbank herzustellen und einen vollständigen Satz ORM-Framework-Code zur Darstellung des Domänenmodells zu generieren. Aber Speedment ist mehr als nur ein Codegenerator, es ist ein Laufzeitprogramm, das in Ihre Anwendung eingebunden werden kann und es ermöglicht, Ihren Java 8-Streaming-Code in optimierte SQL-Abfragen zu übersetzen. Dies ist auch ein Teil, auf den ich in diesem Artikel speziell eingehen werde.

Code generieren

Um Speedment in einem Maven-Projekt zu verwenden, müssen Sie die folgenden Codezeilen zu Ihrer pom.xml-Datei hinzufügen. In diesem Beispiel verwende ich MySQL, Sie können aber auch PostgreSQL oder MariaDB verwenden. Für Unternehmenskunden stehen proprietäre Datenbanken wie Oracle zur Verfügung.

Pom.xml

<properties>
  <speedment.version>3.0.1</speedment.version>
  <db.groupId>mysql</db.groupId>
  <db.artifactId>mysql-connector-java</db.artifactId>
  <db.version>5.1.39</db.version></properties><dependencies>
  <dependency>
    <groupId>com.speedment</groupId>
    <artifactId>runtime</artifactId>
    <version>${speedment.version}</version>
    <type>pom</type>
  </dependency>

  <dependency>
    <groupId>${db.groupId}</groupId>
    <artifactId>${db.artifactId}</artifactId>
    <version>${db.version}</version>
  </dependency></dependencies><build>
  <plugins>
    <plugin>
      <groupId>com.speedment</groupId>
      <artifactId>speedment-maven-plugin</artifactId>
      <version>${speedment.version}</version>

      <dependencies>
        <dependency>
          <groupId>${db.groupId}</groupId>
          <artifactId>${db.artifactId}</artifactId>
          <version>${db.version}</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins></build>

Jetzt haben Sie Zugriff auf eine Reihe neuer Maven-Repositories, die Ihnen die Verwendung dieses Toolkits erleichtern. Um die Speedment-Benutzeroberfläche zu starten, führen Sie den folgenden Befehl aus:

mvn speedment:tool

Dies führt Sie durch einen Prozess zum Herstellen einer Verbindung zur Datenbank und zum Konfigurieren der Codegenerierung. Der einfachste Einstieg besteht darin, es zunächst mit den Standardeinstellungen auszuführen. Wenn Sie auf die Schaltfläche „Generieren“ klicken, analysiert Speedment Ihre Datenbankmetadaten und fügt Ihrem Projekt Klassen wie Entitäten und Entitätsmanager hinzu.

Speedment initialisieren

Nachdem Ihr Domainmodell generiert wurde, ist das Einrichten von Speedment einfach. Erstellen Sie eine neue Main.java-Datei und fügen Sie die folgenden Codezeilen hinzu. Die angezeigten Klassen werden generiert und entsprechend dem Datenbankschema, den Tabellen- und Spaltennamen benannt.

Main.java

public class Main {  public static void main(String... param) {    final HaresApplication app = new HaresApplicationBuilder()
      .withPassword("password")
      .build();
  }
}

Der obige Code erstellt eine neue Anwendungsentität, die ein generiertes Konstruktormuster verwendet. Der Konstruktor ermöglicht das Festlegen beliebiger Laufzeitkonfigurationsdetails, beispielsweise des Datenbankkennworts.

Sobald wir eine Anwendungsentität haben, können wir diese verwenden, um auf den generierten Entitätsmanager zuzugreifen. Hier habe ich vier Tabellen in meiner Datenbank: „Hase“, „Karotte“, „Mensch“ und „Freund“.

final CarrotManager carrots = app.getOrThrow(CarrotManager.class);final HareManager hares     = app.getOrThrow(HareManager.class);final HumanManager humans   = app.getOrThrow(HumanManager.class);final FriendManager hares   = app.getOrThrow(FriendManager.class);

Jetzt können diese Entitätsmanager zur Durchführung aller CRUD-Operationen verwendet werden.

Entitäten erstellen

Das Erstellen von Entitäten ist sehr einfach. Wir verwenden einfach die Implementierung der Entitätsgenerierung, legen den Spaltenwert fest und behalten ihn in der Datenquelle bei.

hares.persist(  new HareImpl()    .setName("Harry")    .setColor("Gray")    .setAge(8)
);

Die Methode persist gibt eine (potenzielle) neue Instanz von Hare mit automatisch generierten Schlüsseln wie „id“ zurück, die bereits festgelegt sind. Wenn wir Harry nach der Persistenz weiterhin verwenden möchten, können wir dies verwenden, das von der Persist-Methode zurückgegeben wird:

final Hare harry = hares.persist(  new HareImpl()
    .setName("Harry")
    .setColor("Gray")
    .setAge(8)
);

Wenn die Persistenzoperation fehlschlägt, beispielsweise wenn ein Fremdschlüssel die Eindeutigkeitsbeschränkung verletzt, dann There wird eine SpeedmentException ausgelöst. Wir sollten dies überprüfen und eine Fehlermeldung anzeigen, wenn es etwas Implizites gibt, das uns daran hindern würde, diesen Hare-Datensatz beizubehalten.

try {  final Hare harry = hares.persist(
    new HareImpl()
      .setName("Harry")
      .setColor("Gray")
      .setAge(8)
  );
} catch (final SpeedmentException ex) {  System.err.println(ex.getMessage());  return;
}

Entitäten lesen

Das coolste Feature der Speedment-Laufzeit ist die Möglichkeit, die Stream-API von Java 8 zum Streamen von Daten in der Datenbank zu verwenden. „Warum sollte das cool sein?“ fragen Sie sich vielleicht. „Sogar Hibernate unterstützt heutzutage Streaming-Operationen!“ war die Antwort.

Das Beste an der Verwendung von Speedment-Streaming-Vorgängen ist, dass sie sowohl die Zwischen- als auch die Abschlussaktionen berücksichtigen, die den Stream aufbauen. Das heißt, wenn Sie dem Stream nach seiner Erstellung einen Filter hinzufügen, wird dieser Filter auch beim Erstellen der SQL-Anweisung berücksichtigt.

Hier ist ein Beispiel, in dem wir die Gesamtzahl der Hasendatensätze in der Datenbank zählen möchten.

final long haresTotal = hares.stream().count();System.out.format("There are %d hares in total.%n", haresTotal);

Die von diesem Code generierte SQL-Abfrage lautet wie folgt:

SELECT COUNT(id) FROM hares.hare;

Die Beendigungsoperation hier ist .count(), sodass Speedment weiß, dass ein SELECT COUNT( …) erstellt werden muss. Stellungnahme. Es weiß auch, dass der Primärschlüssel der „hare“-Tabelle die „id“-Spalte ist, sodass es möglich ist, die gesamte an die Datenbank gesendete Anweisung auf diese zu reduzieren.

Ein komplexeres Beispiel könnte darin bestehen, die Anzahl der Kaninchen zu ermitteln, deren Name mit „rry“ beginnt und deren Alter 5 oder älter ist. Dies kann wie folgt geschrieben werden:

final long complexTotal = hares.stream()
  .filter(Hare.NAME.endsWith("rry"))
  .filter(Hare.AGE.greaterOrEqual(5))
  .count();

Wir definieren den Filter mithilfe des von Speedment für uns generierten On-Site-Builders. Dies ermöglicht es uns, den Stream programmgesteuert zu analysieren und ihn auf eine SQL-Anweisung wie diese zu reduzieren:

SELECT COUNT(id) FROM hares.hareWHERE hare.name LIKE CONCAT("%", ?)AND hare.age >= 5;

Wenn wir eine Speedment-Operation hinzufügen, die den Stream nicht optimieren kann, sieht er wie normale Java 8-Streams aus werden abgewickelt. Wir werden die Verwendung generierter Standort-Builder niemals einschränken, da diese den Streaming-Betrieb effizienter machen können.

final long inefficientTotal = hares.stream()
  .filter(h -> h.getName().hashCode() == 52)
  .count();

Der obige Code erzeugt eine äußerst ineffiziente Anweisung wie folgt, kann aber trotzdem ausgeführt werden.

SELECT id,name,color,age FROM hares.hare;

Aktualisieren von Entitäten

Das Aktualisieren vorhandener Entitäten ist dem Lesen und Beibehalten von Entitäten sehr ähnlich. Änderungen an der lokalen Kopie der Entität wirken sich erst dann auf den Datenbankinhalt aus, wenn wir die Methode update() aufrufen.

Unten nehmen wir den Harry, den wir zuvor mit Hare erstellt haben, und ändern seine Farbe in Braun:

harry.setColor("brown");final Hare updatedHarry = hares.update(harry);

如果更新被接受了，那么管理器会返回hare的一个新的拷贝，因为我们在后面会继续使用这个实例。就想做“创建”的例子中，更新可能会失败。也许颜色被定义为“值唯一”，棕色已经存在于hare中。那样的话，会抛出一个SpeedmentException异常.

我们也可以通过合并多个实体到一个流中来同时更新他们。加入我们想将所有名字为Harry的hare变为棕色，我们可以这样做：

hares.stream()
  .filter(Hare.NAME.equal("Harry"))
  .map(Hare.COLOR.setTo("Brown"))
  .forEach(hares.updater()); // 更新流中存在的元素

我们还应该使用try-catch语句来确保在运行过程中有失败发生时警告用户。

try {
  hares.stream()
    .filter(Hare.NAME.equal("Harry"))
    .map(Hare.COLOR.setTo("Brown"))
    .forEach(hares.updater());
} catch (final SpeedmentException ex) {  System.err.println(ex.getMessage());  return;
}

实体删除

我们需要知道的最后一个 CRUD 操作就是从数据库中删除实体。这个操作几乎和“更新”操作时等同的。假如说我们要把年龄超过10岁的兔子的记录都删除，就要这样做:

try {
  hares.stream()
    .filter(Hare.AGE.greaterThan(10))
    .forEach(hares.remover()); // Removes remaining hares} catch (final SpeedmentException ex) {  System.err.println(ex.getMessage());  return;
}

总结

通过阅读本文你已经了解了如何在一个 Maven 工程中对 Speedment 进行设置，还有如何使用 Java 8 的 Stream API 来从数据库中创建、更新、读取以及删除实体。这是你可以利用 Speedment 所能进行的操作的一个小的子集, 但已经是一个能让你上手的好的开始了。更多的示例以及更加高级的使用场景可以在 GitHub-page 上找到。

更多Java 8 Streams 中的数据库 CRUD 操作相关文章请关注PHP中文网！