So verwalten Sie Java-Code, der automatisch von jOOQ & Flyway generiert wird
TL;DR
- Der von jOOQ automatisch generierte Java-Quellcode für die O / R-Zuordnung darf nicht von git verwaltet werden. Machen wir es zum Ziel von .gitignore.
- Andernfalls können während der Teamentwicklung Konflikte auftreten, und Sie können den Widerstand von jOOQ gegen DB-Änderungen (Ergänzungen, Änderungen usw. von Tabellen und Spalten) nicht nutzen.
- Das Obige kann leicht realisiert werden, indem eine lokale Entwicklungsumgebung eingerichtet wird, dh mit Docker, Gradle-Jooq-Plugin, Flyway-Gradle-Plugin richtig eingerichtet wird.
- Im Sinne von DDD (Domain-Driven Design) ist es übrigens schlecht, die von jOOQ automatisch generierte Entitätsklasse als Domain-Klasse zu verwenden. Auch wenn es problematisch ist, füllen wir den Wert mit Ihrer eigenen Domänenklasse auf.
- Klicken Sie hier für Beispielcode
- Die Lesung von jOOQ ist "Juke".
Detail
Auf der JJUG-CCC (Community Community Conference der Japan Java Users Group) im Dezember 2018 Über O / R-Mapper und DB-Migration beim Vergleich von Tools sprechen ) Wurde der Titel gegeben.
Unter den vielen O / R-Mappern und DB-Migrationstools war der Inhalt die jOOQ-Empfehlung und die Flyway-Empfehlung. Auf der anderen Seite scheint es, obwohl es eine Geschichte ist, die ich von Leuten auf den Straßenblogs höre, dass es viele Fälle gibt, in denen sie leicht falsch verwendet werden. ** Besonders schlimm ist der Fall, in dem der von jOOQ automatisch generierte Java-Quellcode als Commit-Ziel von git versioniert wird. Du solltest es besser aufhalten. ** Wenn mehrere Entwickler versehentlich gleichzeitig Spalten zur gleichen Tabelle hinzufügen, führt eine große Menge an Java-Code, der automatisch von jOOQ generiert wird, immer zu einem Konflikt.
jOOQ liest die Struktur des angegebenen DB-Schemas genau und unvergleichlich und generiert automatisch Java-Code, der die O / R-Zuordnung erleichtert. ** Dies bedeutet, dass die DB-Schemadefinition, dh die sogenannten DDL-Anweisungen wie CREATE TABLE und ALTER TABLE, genau und nicht übereinstimmend versioniert werden sollte. Flyway macht das möglich. ** **.
Da jOOQ automatisch Java-Code generiert, ist es verlockend, das Ausgabeziel unter src / main / java anzugeben, aber das ist die Gefahr. Wenn Sie gradle verwenden, geben Sie den Speicherort des Quellcodes an, nachdem Sie das Ausgabeziel des automatisch generierten Codes von jOOQ unter build / angegeben haben. Die Kompilierung wird dann übergeben. Bei IntelliJ IDEA gibt es kein Problem. Ich weiß jedoch nichts über die alte Waffe namens Eclipse.
Versuchen Sie, den Beispielcode auszuführen
Bereiten Sie einfach einen PC mit git, JDK8 oder höher und Docker vor und führen Sie den folgenden Befehl aus.
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 im Browser://localhost:Öffnen Sie 8080
Versuchen Sie, den Beispielcode als Projekt in IntelliJ IDEA zu importieren
- Führen Sie die obigen Schritte aus, um sh setup.sh auszuführen
- File -> New -> Project from existing sources
- Öffnen Sie, indem Sie build.gradle direkt im Verzeichnis jooq-flyway-spboot-sample angeben
- Aktivieren Sie die Option Auto-Import verwenden und klicken Sie auf OK
- Klicken Sie im pj-web-Projekt auf SampleApplication.java, um es zu starten
- Öffnen Sie http: // localhost: 8080 in Ihrem Browser
Punkte zur Verwendung von Docker
- Offizielles Bild von PostgreSQL, [Docker-Entrypoint-Initdb.d-Verzeichnis](https://github.com/nabedge/jooq-flyway-spboot-sample/tree/master/docker/postgresql/docker-entrypoint-initdb. d) Verwenden Sie die Datei * .sql darunter, um die Funktion auszuführen.
- Es wird jedoch nur die Datenbank selbst für die Anwendung und ihre Datenbankbenutzer erstellt.
- Mit anderen Worten, die Anwendung wird unter der Annahme entwickelt, dass nur die leere Datenbank und der DB-Benutzer für die Anwendung, auf die zugegriffen werden darf, bereits vorhanden sind.
Punkte zur Verwendung von Flyway
- Laut Theorie [src / main / resources / db / migration](https://github.com/nabedge/jooq-flyway-spboot-sample/tree/master/pj-db/src/main/resources/db/ Bereiten Sie unter Migration eine * .sql-Datei mit einer bestimmten Benennungsmethode vor. Der Inhalt ist CREATE TABLE-Anweisung usw.
- Selbst in einer lokalen Entwicklungsumgebung ist es für die eigentliche Entwicklungsarbeit sehr unpraktisch, wenn nicht einige Testdaten in der Tabelle gespeichert sind. Daher unter src / test / resources / testdata Bereiten wir eine Datei vor, in der INSERT-Anweisungen zur Eingabe von Testdaten angeordnet sind.
- Ich möchte ungefähr 100 Testdaten, aber das Schreiben einer 100-zeiligen INSERT-Anweisung ist mühsam. Dann unter src / test / java / testdata Schreiben wir Java-Code, der Testdaten einfügt, während eine entsprechende Schleife ausgeführt wird. Dies ist die Java Based Migration-Funktion von ** Flyway **.
- In PostgreSQL unter Docker wird die Tabelle automatisch mit dem Befehl ./gradlew flywayMigrate -p pj -db erstellt. Flyway führt SQL aus, indem es genau erfasst, "Welche SQL (DDL) -Anweisung wurde in der Ziel-DB ausgeführt?". Dieser Befehl kann also auch in der Produktionsumgebung ausgeführt werden.
- Wenn Sie Flyway in der Mitte einer Datenbank / Anwendung installieren möchten, die bereits in Produktion ist, Flyway in der Mitte % B8% AD% E3% 81% 8B% E3% 82% 89 Flyway) Lassen Sie uns googeln. Verschiedene Dinge werden herauskommen.
- Testdaten werden mit ./gradlew flywayMigrate -Dflyway.locations = classpath: testdata gefüllt. Wenn Sie die Option -Dflyway.locations nicht explizit angeben, funktionieren die Skripte unter diesen nicht, sodass Sie Unfälle, bei denen Testdaten in die Produktionsumgebung gelangen, vollständig verhindern können.
Punkte zur Verwendung von jOOQ
- Es scheint hartnäckig zu sein, aber wie man jOOQ liest, ist Juke.
- Bei Projekten, die jOOQ und Flyway verwenden, müssen die Bibliotheken für den DB-Zugriff, auf die sie abzielen, als Teilprojekte getrennt werden. Wenn Sie es mit normalem Anwendungscode verwechseln, wird die Build-Definitionsdatei (build.gradle) unnötig kompliziert und kann den Beginn eines langjährigen Krieges bedeuten. ** Immer Multiprojektkonfiguration. Das ist grundlegend. ** **.
- Im Beispielprojekt sind pj-db und pj-db-custom-Strategy Unterprojekte für den DB-Zugriff. Die Hauptanwendung, pj-web, sollte in Abhängigkeit von pj-db entwickelt werden.
- Ein Beispiel für die Ausgabe von SQL-Anweisungen durch jOOQ ist BookRepository.java. Beispiel / web / BookRepository.java).
- Verwenden Sie gradle-jooq-plugin, damit jOOQ automatisch Java-Code generiert.
- Dieser Bereich von pj-db / build.gradle sagt jooqRuntime Es gibt eine unbekannte Definition. Dadurch kann jOOQ auf die Datenbank zugreifen, alle dort ausgedehnten Tabellendefinitionen entschlüsseln und Java-Code für die O / R-Zuordnung generieren.
jOOQ und build.gradle
Lassen Sie uns etwas mehr von [around] erklären (https://github.com/nabedge/jooq-flyway-spboot-sample/blob/master/pj-db/build.gradle#L35).
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)
}
- Stellen Sie sich den Wert "sample" als den abstrakten Namen der DB-Definition in diesem Beispielcode vor. Dies ist der Aufgabenname generateSampleJooqSchemaSource.
- Da generateSampleJooqSchemaSource als Voraussetzung (abhängig von) für die compileJava-Task vorhanden ist, versucht gradle immer, sie nach der automatischen Generierung des Codes zu kompilieren. Aufgrund von sourceSets.main.java.srcDirs (jooqDestDir) ist der Speicherort des Quellcodes am Anfang definiert anstelle von src / main / java. -spboot-sample / blob / master / pj-db / build.gradle # L5) Der Quellcode wird automatisch in build / jooq-gen generiert.
- ** Natürlich **, Das "Build" -Verzeichnis selbst ist in .gitignore angegeben
Fügen Sie dem Klassennamen des von jOOQ automatisch generierten Codes Präfix / Suffix hinzu
Wie in Rund 50 Seiten der tatsächlichen O / R-Mapper- und DB-Migration beim Vergleich von Tools erwähnt, ist jOOQ standardmäßig der Tabellenname Erstellt eine Java-Klasse mit genau demselben Namen wie. ** Benutzerdefiniert wird dringend empfohlen. ** Klassennamenkonflikte können während des Codierungsprozesses zu erheblichen Belastungen führen.
Also dieser Teil von build.gradle oben
strategy {
name = 'com.example.db.jooq.generator.SamplePrefixGeneratorStrategy'
}
Wird wichtig. Diese Klasse ist die einzige Klasse im Teilprojekt mit dem Namen pj-db-custom-Strategy Es ist implementiert als /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;
}
Wie Sie sehen können, haben alle von jOOQ automatisch generierten Java-Klassenpräfixe "J". Dies führt zu Actual DB Access Code. In 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());
auf diese Weise,
- Code für O / R-Mapper, der automatisch von jOOQ generiert wird (JBook.java)
- Auch automatisch generierte Entitätsklasse (BookVo.java)
- DDD-ähnliche Klasse, die Sie selbst erstellen sollten (Book.java)
Sie können diese Namenskonflikte vermeiden.
abschließend
- Material aus dem letzten Jahr Die aktuelle Situation der O / R-Mapper- und DB-Migration beim Vergleich von Tools
- [Beispielcode] erstellt diesen Monat (https://github.com/nabedge/jooq-flyway-spboot-sample)
- Dieser Blog
Wenn Sie das Beispiel beim Lesen verschieben und in die IDE importieren, können Sie die Punkte sehen. Happy Hacking !
Dieser Artikel wird vom Autor selbst aus seinem eigenen Blog nachgedruckt. -> https://nabedge.mixer2.org/2019/03/jooq-flyway-sample.html
Recommended Posts