Opérations CRUD de base de données dans Java 8 Streams

Contexte

Speedment est un ensemble d'outils open source qui peut être utilisé pour générer des entités Java et gérer notre processus de communication avec la base de données. Vous pouvez utiliser un outil graphique pour vous connecter à la base de données et générer un ensemble complet de codes de framework ORM pour représenter le modèle de domaine. Mais Speedment est plus qu'un simple générateur de code, c'est un programme d'exécution qui peut être connecté à votre application, permettant de traduire votre code de streaming Java 8 en requêtes SQL optimisées. C’est aussi une partie dont je parlerai spécifiquement dans cet article.

Générer du code

Pour commencer à utiliser Speedment dans un projet Maven, vous devez ajouter les lignes de code suivantes à votre fichier pom.xml. Dans cet exemple, j'utilise MySQL, mais vous pouvez également choisir d'utiliser PostgreSQL ou MariaDB. Des bases de données propriétaires comme Oracle sont disponibles pour les entreprises clientes.

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>

Vous avez désormais accès à un certain nombre de nouveaux référentiels Maven qui vous faciliteront l'utilisation de cette boîte à outils. Pour démarrer l'interface utilisateur Speedment, exécutez la commande suivante :

mvn speedment:tool

Cela vous guidera à travers un processus pour vous connecter à la base de données et configurer la génération de code. Le moyen le plus simple de commencer est de l’exécuter d’abord avec les paramètres par défaut. Lorsque vous appuyez sur le bouton "Générer", Speedment analysera les métadonnées de votre base de données et ajoutera des classes telles que des entités et des gestionnaires d'entités à votre projet.

Initialiser Speedment

Une fois votre modèle de domaine généré, la configuration de Speedment est simple. Créez un nouveau fichier Main.java et ajoutez les lignes de code suivantes. Les classes que vous voyez sont générées, elles sont donc nommées en fonction des noms du schéma, des tables et des colonnes de la base de données.

Main.java

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

Le code ci-dessus crée une nouvelle entité d'application, qui utilise un modèle de constructeur généré. Le constructeur permet de définir tous les détails de configuration d'exécution, tels que le mot de passe de la base de données.

Une fois que nous avons une entité d'application, nous pouvons l'utiliser pour accéder au gestionnaire d'entités généré. Ici, j'ai quatre tables dans ma base de données : « lièvre », « carotte », « humain » et « ami » (vous pouvez trouver la définition complète de la base de données ici).

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);

Désormais, ces gestionnaires d'entités peuvent être utilisés pour effectuer toutes les opérations CRUD.

Création d'entités

La création d'entités est très simple. Nous utilisons simplement l'implémentation de la génération d'entités, définissons la valeur de la colonne et la conservons dans la source de données.

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

La méthode persist renverra une nouvelle instance (potentielle) de Hare avec des clés générées automatiquement comme "id" déjà définies. Si nous voulons continuer à utiliser Harry après la persistance, nous pouvons utiliser ceci renvoyé par la méthode persist :

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

Si l'opération de persistance échoue, par exemple, si une clé étrangère viole la contrainte d'unicité, alors Là sera une SpeedmentException levée. Nous devrions vérifier cela et s'il y a quelque chose d'implicite qui nous empêcherait de conserver cet enregistrement de lièvre, nous devrions afficher un message d'erreur.

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

Lecture des entités

La fonctionnalité la plus intéressante du runtime Speedment est la possibilité d'utiliser l'API Stream de Java 8 pour diffuser des données dans la base de données. « Pourquoi serait-ce cool ? » pourriez-vous vous demander. "Même Hibernate prend en charge les opérations de streaming de nos jours !"

La meilleure chose à propos de l'utilisation des opérations de streaming Speedment est qu'elles prennent en compte à la fois les actions intermédiaires et finales qui créent le flux. Cela signifie que si vous ajoutez un filtre au flux après sa création, le filtre sera également pris en compte lors de la construction de l'instruction SQL.

Voici un exemple où nous souhaitons compter le nombre total d'enregistrements de lièvres dans la base de données.

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

La requête SQL générée par ce code est la suivante :

SELECT COUNT(id) FROM hares.hare;

L'opération de terminaison ici est .count(), donc Speedment sait créer un SELECT COUNT( …) déclaration. Il sait également que la clé primaire de la table "hare" est la colonne "id", il est donc possible de réduire à cela l'intégralité de l'instruction envoyée à la base de données.

Un exemple plus complexe pourrait être de trouver le nombre de lapins dont le nom commence par "rry" et dont l'âge est de 5 ans ou plus. Cela peut s'écrire ainsi :

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

Nous définissons le filtre à l'aide du constructeur sur site généré pour nous par Speedment. Cela nous permet d'analyser le flux par programmation et de le réduire à une instruction SQL comme celle-ci :

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

Si nous ajoutons une opération Speedment qui ne peut pas optimiser le flux, cela ressemblera à des flux Java 8 normaux. sont manipulés. Nous ne limiterons jamais l’utilisation de générateurs de localisation générés, qui peuvent rendre les opérations de streaming plus efficaces.

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

Le code ci-dessus produira une instruction extrêmement inefficace comme suit, mais il peut toujours s'exécuter.

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

Mise à jour des entités

La mise à jour des entités existantes est très similaire à la lecture et à la persistance d'entités. Les modifications apportées à la copie locale de l'entité n'affecteront pas le contenu de la base de données jusqu'à ce que nous appelions la méthode update().

Ci-dessous, nous prenons le Harry que nous avons créé précédemment en utilisant Lièvre et changeons sa couleur en marron :

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中文网！