Comment gérer le code Java généré automatiquement par l'exemple jOOQ et Flyway

TL;DR

Le code source Java pour le mappage O / R généré automatiquement par jOOQ ne doit pas être géré par git. Faisons-en la cible de .gitignore.
Sinon, des conflits sont susceptibles de survenir lors du développement de l'équipe, et vous ne pourrez pas profiter de la résistance de jOOQ aux changements de DB (ajouts, changements, etc. de tables et de colonnes).
Ce qui précède peut être facilement réalisé en mettant en place un environnement de développement local, c'est-à-dire en utilisant correctement Docker, gradle-jooq-plugin, flyway-gradle-plugin.
Incidemment, dans le sens de DDD (conception pilotée par domaine), il est mauvais d'utiliser la classe d'entité générée automatiquement par jOOQ telle quelle en tant que classe de domaine. Même si cela est gênant, remplissons la valeur avec votre propre classe de domaine.
Cliquez ici pour un exemple de code
La lecture de jOOQ est "Juke".

Detail

À JJUG-CCC (Japan Java Users Group Cross Community Conference) en décembre 2018 Parlons du mappeur O / R et de la migration de base de données tout en comparant les outils ) A reçu le titre.

Parmi les nombreux mappeurs O / R et outils de migration de base de données, il s'agissait de la recommandation jOOQ et de la recommandation Flyway. D'un autre côté, bien que ce soit une histoire que j'entends des gens sur les blogs de rue, il semble qu'il y ait de nombreux cas où ils sont utilisés légèrement de manière incorrecte. ** Le cas où le code source Java généré automatiquement par jOOQ est géré par version en tant que cible de validation git est particulièrement grave. Tu ferais mieux de l'arrêter. ** Si plusieurs développeurs ajoutent par inadvertance des colonnes à la même table en même temps, une grande quantité de code Java généré automatiquement par jOOQ provoquera toujours un conflit.

jOOQ lit la structure du schéma de base de données spécifié de manière précise et incomparable, et génère automatiquement du code Java qui facilite le mappage O / R. ** Cela signifie que c'est la définition du schéma de base de données, c'est-à-dire les instructions dites DDL telles que CREATE TABLE et ALTER TABLE, qui doivent être gérées avec précision et sans correspondance. Flyway rend cela possible. ** **

Puisque jOOQ génère automatiquement du code Java, vous voudrez spécifier la destination de sortie sous src / main / java, mais c'est le piège. Si vous utilisez gradle, spécifiez l'emplacement du code source après avoir spécifié la destination de sortie du code généré automatiquement de jOOQ sous build /, et la compilation passera. Il n'y a aucun problème sur IntelliJ IDEA. Cependant, je ne connais pas l'ancienne arme appelée Eclipse.

Essayez d'exécuter l'exemple de code

Préparez simplement un PC avec git, JDK8 ou supérieur, et docker et exécutez la commande suivante.

git clone [email protected]:nabedge/jooq-flyway-spboot-sample.git
cd jooq-flyway-spboot-sample
sh setup.sh
sh ./gradlew run -p pj-web
Http dans le navigateur://localhost:Ouvrir 8080

Essayez d'importer l'exemple de code dans IntelliJ IDEA en tant que projet

Suivez les étapes ci-dessus pour exécuter sh setup.sh
File -> New -> Project from existing sources
Ouvrez en spécifiant build.gradle directement sous le répertoire jooq-flyway-spboot-sample
Cochez utiliser l'importation automatique et appuyez sur le bouton OK
Cliquez sur SampleApplication.java dans le projet pj-web pour le lancer
Ouvrez http: // localhost: 8080 dans votre navigateur

Points sur la façon d'utiliser Docker

Image officielle de PostgreSQL, [répertoire docker-entrypoint-initdb.d](https://github.com/nabedge/jooq-flyway-spboot-sample/tree/master/docker/postgresql/docker-entrypoint-initdb. d) Utilisez le fichier * .sql en dessous pour exécuter la fonction.
Cependant, il n'y a que la création de la base de données elle-même pour l'application et ses utilisateurs de base de données.
En d'autres termes, l'application est développée en partant du principe que seuls le DB vide et l'utilisateur DB de l'application autorisé à y accéder existent déjà.

Points sur l'utilisation de Flyway

Selon la théorie, [src / main / resources / db / migration](https://github.com/nabedge/jooq-flyway-spboot-sample/tree/master/pj-db/src/main/resources/db/ Sous migration), préparez un fichier * .sql avec une certaine méthode de dénomination. Le contenu est une instruction CREATE TABLE, etc.
Même dans un environnement de développement local, c'est très gênant pour le travail de développement réel à moins que certaines données de test ne soient stockées dans la table. Par conséquent, sous src / test / resources / testdata, Préparons un fichier dans lequel les instructions INSERT pour l'entrée des données de test sont organisées.
Je veux environ 100 données de test, mais écrire une instruction INSERT de 100 lignes est un problème. Ensuite, sous src / test / java / testdata Écrivons du code Java qui INSERT les données de test tout en bouclant de manière appropriée. Il s'agit de la fonction ** de migration basée sur Java ** de Flyway.
Dans PostgreSQL sur Docker, la table est automatiquement créée avec la commande ./gradlew flywayMigrate -p pj -db. Flyway exécute SQL en saisissant avec précision «Quelle instruction SQL (DDL) a été exécutée dans la base de données cible?». Cette commande peut donc être exécutée également en toute confiance dans l'environnement de production.
Si vous souhaitez installer Flyway au milieu d'une base de données / application qui est déjà en production, [Flyway in the middle](https://www.google.co.jp/search?hl=ja&q=%E9%80%94%E4 % B8% AD% E3% 81% 8B% E3% 82% 89 Flyway) Let's google. Diverses choses vont sortir.
Les données de test sont remplies avec ./gradlew flywayMigrate -Dflyway.locations = classpath: testdata. À moins que vous n'indiquiez explicitement l'option -Dflyway.locations, les scripts sous ceux-ci ne fonctionneront pas, vous pouvez donc éviter complètement les accidents où les données de test entrent dans l'environnement de production.

Points sur la façon d'utiliser jOOQ

Cela semble persistant, mais comment lire jOOQ est Juke.
Pour les projets qui utilisent jOOQ et Flyway, il est essentiel de séparer les bibliothèques d'accès à la base de données qu'elles ciblent en tant que sous-projets. Si vous le mélangez avec du code d'application normal, le fichier de définition de construction (build.gradle) devient inutilement compliqué et peut être le début d'une guerre de longue durée. ** Toujours configuration multi-projets. Ceci est basique. ** **
Dans l'exemple de projet, pj-db et pj-db-custom-strategy sont des sous-projets pour l'accès à la base de données. L'application principale, pj-web, devrait être développée en fonction de pj-db.
Un exemple d'émission d'instructions SQL par jOOQ est [BookRepository.java](https://github.com/nabedge/jooq-flyway-spboot-sample/blob/master/pj-web/src/main/java/com/ exemple / web / BookRepository.java).
Utilisez gradle-jooq-plugin pour que jOOQ génère automatiquement du code Java.
Cette zone de pj-db / build.gradle indique jooqRuntime Il existe une définition inconnue. Celles-ci permettront à jOOQ d'accéder à la base de données, de décrypter toutes les définitions de table qui y sont étendues et de générer du code Java pour le mappage O / R.

jOOQ et build.gradle

Expliquons un peu plus de par ici.

jooq {
    version = "${jooqVersion}"
    edition = 'OSS' // if you use oracle, you should pay :-)

    // the name "sample" -> task name "generateSampleJooqSchemaSource" . see below.
    sample (sourceSets.main) {
        jdbc {
            driver = "${jdbcDriver}"
            url = "${dbUrl}"
            user = "${dbUser}"
            password = "${dbPassword}"
        }
        generator {
            target {
                packageName = "${jooqDestPackage}"
                directory = "${jooqDestDir}"
            }
            strategy {
                name = 'com.example.db.jooq.generator.SamplePrefixGeneratorStrategy'
            }
            database() {
                name = 'org.jooq.meta.postgres.PostgresDatabase'
                inputSchema = "public"
            }
            generate() {
                daos = true
                immutablePojos = true
                pojosEqualsAndHashCode = true
            }
        }
    }
}

compileJava {
    dependsOn generateSampleJooqSchemaSource
    sourceSets.main.java.srcDirs(jooqDestDir)
}

Considérez la valeur "sample" comme le nom abstrait de la définition de base de données sur cet exemple de code. Ce sera le nom de la tâche generateSampleJooqSchemaSource.
Puisqu'il existe generateSampleJooqSchemaSource comme prérequis (dependOn) pour la tâche compileJava, gradle essaie toujours de le compiler après avoir généré automatiquement le code. De plus, en raison de sourceSets.main.java.srcDirs (jooqDestDir), l'emplacement du code source est défini au début au lieu de src / main / java. -spboot-sample / blob / master / pj-db / build.gradle # L5) Le code source est automatiquement généré dans build / jooq-gen.
** Bien sûr **, Le répertoire "build" lui-même est spécifié dans .gitignore

Ajouter un préfixe / suffixe au nom de classe du code généré automatiquement par jOOQ

Comme je l'ai mentionné dans Environ 50 pages de mappeur O / R réel et de migration de base de données ont parlé en comparant les outils, jOOQ est le nom de la table par défaut. Créera une classe Java avec exactement le même nom que. ** La personnalisation est fortement recommandée. ** Les conflits de nom de classe peuvent entraîner un stress considérable pendant le processus de codage.

Donc, cette partie de build.gradle ci-dessus

            strategy {
                name = 'com.example.db.jooq.generator.SamplePrefixGeneratorStrategy'
            }

Devient important. Cette classe est la seule classe du sous-projet appelée pj-db-custom-strategy Il est implémenté en tant que /src/main/java/com/example/db/jooq/generator/SamplePrefixGeneratorStrategy.java).

import org.jooq.codegen.DefaultGeneratorStrategy;
import org.jooq.meta.Definition;

public class SamplePrefixGeneratorStrategy extends DefaultGeneratorStrategy {

    @Override
    public String getJavaClassName(final Definition definition, final Mode mode) {

        String name = super.getJavaClassName(definition, mode);

        switch (mode) {
            case POJO:
                return name + "Vo";
            case DEFAULT:
                return 'J' + name;
        }

        return name;
    }

Comme vous pouvez le voir, tous les préfixes de classe Java générés automatiquement par jOOQ ont "J". Cela se traduira par [Code d'accès à la base de données réel](https://github.com/nabedge/jooq-flyway-spboot-sample/blob/master/pj-web/src/main/java/com/example/web/ Dans BookRepository.java)

        final JBook jBook = JBook.BOOK;
        final List<BookVo> selected = dslContext
                .select(
                        jBook.ISBN,
                        jBook.TITLE,
                        jBook.PUBLISH_DATE
                )
                .from(jBook)
                .orderBy(jBook.PUBLISH_DATE)
                .fetchInto(BookVo.class);
                // .fetchInto(Book.class); // or you can use original class directly !

        return selected
                .stream()
                .map(bookVo -> {
                    Book book = new Book();
                    book.setIsbn(bookVo.getIsbn());
                    book.setTitle(bookVo.getTitle());
                    book.setPublishDate(bookVo.getPublishDate().toLocalDate());
                    return book;
                })
                .collect(Collectors.toList());

de cette façon,

Code pour le mappeur O / R généré automatiquement par jOOQ (JBook.java)
Classe d'entité également générée automatiquement (BookVo.java)
Classe de type DDD que vous devriez créer vous-même (Book.java)

Vous pourrez éviter ces conflits de noms.

en conclusion

Matériel de l'année dernière La situation réelle du mappeur O / R et de la migration de la base de données a été discutée en comparant les outils
[Exemple de code] réalisé ce mois-ci (https://github.com/nabedge/jooq-flyway-spboot-sample)
Ce blog

Si vous déplacez l'échantillon tout en lisant chacun et que vous l'importez dans l'EDI, vous pouvez voir les points. Happy Hacking !

Cet article est réimprimé par l'auteur lui-même à partir de son propre blog. -> https://nabedge.mixer2.org/2019/03/jooq-flyway-sample.html