How to use jOOQ code generation with Gradle? - gradle

Question

I am reading this tutorial of jOOQ
It shows me how I can use jOOQ code-generation from inside Gradle.
Based on this tutorial I modified my build.gradle file and it looks like this:
group 'com.abhi'
version '1.0-SNAPSHOT'
apply plugin: 'java'
apply plugin: 'org.flywaydb.flyway'
sourceCompatibility = 1.8
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.flywaydb:flyway-gradle-plugin:3.2.1'
classpath 'org.jooq:jooq-codegen:3.7.1'
classpath 'com.h2database:h2:1.4.177'
}
}
repositories {
mavenCentral()
}
dependencies {
compile group: 'org.jooq', name: 'jooq', version: '3.7.1'
compile group: 'org.jooq', name: 'jooq-meta', version: '3.7.1'
compile group: 'org.jooq', name: 'jooq-codegen', version: '3.7.1'
runtime group: 'com.h2database', name: 'h2', version: '1.4.177'
}
flyway {
url = 'jdbc:h2:file:target/foobar'
user = 'sa'
}
But the part I am not able to understand is that the tutorial also provides some code:
def writer = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(writer)
.configuration('xmlns': 'http://www.jooq.org/xsd/jooq-codegen-3.7.0.xsd') {
jdbc() {
driver('org.h2.Driver')
url('jdbc:h2:~/test-gradle')
user('sa')
password('')
}
generator() {
database() {
}
generate() {
}
target() {
packageName('org.jooq.example.gradle.db')
directory('src/main/java')
}
}
}
// Run the code generator
// ----------------------
org.jooq.util.GenerationTool.generate(
javax.xml.bind.JAXB.unmarshal(new StringReader(writer.toString()), org.jooq.util.jaxb.Configuration.class)
)
Where should I put this code and how shall I execute it?
This code looks like Groovy code but I am writing a Java project. So how and where does this fit into my project?
My objective is that every time I build the project, all the code generation is done by Gradle itself so that I don't have to run any tools manually.
Does it mean that I copy and paste this code inside of my build.gradle file?

Answer 1

You can e.g. add generate task that will be defined as follows:
task generate << {
def writer = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(writer)
.configuration('xmlns': 'http://www.jooq.org/xsd/jooq-codegen-3.7.0.xsd') {
jdbc() {
driver('org.h2.Driver')
url('jdbc:h2:~/test-gradle')
user('sa')
password('')
}
generator() {
database() {
}
generate() {
}
target() {
packageName('org.jooq.example.gradle.db')
directory('src/main/java')
}
}
}
org.jooq.util.GenerationTool.generate(
javax.xml.bind.JAXB.unmarshal(new StringReader(writer.toString()), org.jooq.util.jaxb.Configuration.class)
)
}

Answer 2

You can create a task and use the org.jooq.meta.jaxb.Configuration class to configure code generation:
In your build.gradle file, you will want to place the following on the very top of the file (this will allow you to use the jOOQ classes (such as the org.jooq.meta.jaxb.Configuration class inside your Gradle file).
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath group: 'org.jooq', name: 'jooq', version: '3.13.4'
classpath group: 'org.jooq', name: 'jooq-meta', version: '3.13.4'
classpath group: 'org.jooq', name: 'jooq-codegen', version: '3.13.4'
classpath group: 'org.postgresql', name: 'postgresql', version: '42.2.16'
}
}
Next, create a new file (you can also do it inside build.gradle, but I like to separate it for better organization) called jooq.gradle, or whatever you would like to call it.
The following file is adapted from here with some minor modifications.
At the top of your program, you will want to add the following imports that will let us work with jOOQ (they may show up as red or invalid, but we'll fix that in just a bit):
import org.jooq.codegen.GenerationTool
import org.jooq.meta.jaxb.Database
import org.jooq.meta.jaxb.Generator
import org.jooq.meta.jaxb.Jdbc
import org.jooq.meta.jaxb.Target
Great!, now we can define some variables after this for better organization (not required):
ext.db = [
url: 'jdbc:postgresql://localhost:5432/postgres',
user: 'postgres',
password: 'postgres',
schema: 'public',
driver: 'org.postgresql.Driver',
jooqDbImpl: 'org.jooq.meta.postgres.PostgresDatabase',
packageName: 'samplepackage'
]
ext.genpath = new File("${projectDir}/build/generated-src/jooq/main")
For the above snippet, you will want to change the variables according to your configuration.
Next, we can add our buildscript again for this file:
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath group: 'org.jooq', name: 'jooq', version: '3.13.4'
classpath group: 'org.jooq', name: 'jooq-meta', version: '3.13.4'
classpath group: 'org.jooq', name: 'jooq-codegen', version: '3.13.4'
classpath group: 'org.postgresql', name: 'postgresql', version: '42.2.16'
}
}
After this, we can add genPath as a Java source file:
sourceSets.main.java.srcDirs += genpath.toString()
And we can finally start our generateCode() task!
Create the function definition as such:
task generateCode() {
}
Inside you will want to put this snippet of code, which will configure the generator. Feel free to modify this according to your needs, but I will be putting a snippet that works for me:
org.jooq.meta.jaxb.Configuration configuration = new
org.jooq.meta.jaxb.Configuration()
.withJdbc(new Jdbc()
.withDriver(db.driver)
.withUrl(db.url)
.withUser(db.user)
.withPassword(db.password)
)
.withGenerator(new Generator()
.withDatabase(new Database()
.withName(db.jooqDbImpl)
.withIncludes(".*")
.withExcludes("")
.withInputSchema(db.schema)
)
.withTarget(new Target()
.withPackageName(db.packageName)
.withDirectory(genpath.toString())
)
);
Finally, after all the hard work, you can execute this function, which will create your code using the configuration above:
GenerationTool.generate(configuration);
If you would like to have a function to delete the generated code, you can use the following snippet:
task deleteGeneratedCode(type: Delete) {
delete genpath
}
And here is the following, completed jooq.gradle file:
import org.jooq.codegen.GenerationTool
import org.jooq.meta.jaxb.Database
import org.jooq.meta.jaxb.Generator
import org.jooq.meta.jaxb.Jdbc
import org.jooq.meta.jaxb.Target
ext.db = [
url: 'jdbc:postgresql://localhost:5432/postgres',
user: 'postgres',
password: 'postgres',
schema: 'limehrm',
driver: 'org.postgresql.Driver',
jooqDbImpl: 'org.jooq.meta.postgres.PostgresDatabase'
packageName: 'limehrm'
]
ext.genpath = new File("${projectDir}/build/generated/source/jooq/main")
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath group: 'org.jooq', name: 'jooq', version: '3.13.4'
classpath group: 'org.jooq', name: 'jooq-meta', version: '3.13.4'
classpath group: 'org.jooq', name: 'jooq-codegen', version: '3.13.4'
classpath group: 'org.postgresql', name: 'postgresql', version: '42.2.16'
}
}
sourceSets.main.java.srcDirs += genpath.toString()
task generateCode() {
if (!genpath.exists()) {
genpath.mkdirs()
}
org.jooq.meta.jaxb.Configuration configuration = new
org.jooq.meta.jaxb.Configuration()
.withJdbc(new Jdbc()
.withDriver(db.driver)
.withUrl(db.url)
.withUser(db.user)
.withPassword(db.password)
)
.withGenerator(new Generator()
.withDatabase(new Database()
.withName(db.jooqDbImpl)
.withIncludes(".*")
.withExcludes("")
.withInputSchema(db.schema)
)
.withTarget(new Target()
.withPackageName(db.packageName)
.withDirectory(genpath.toString())
)
);
GenerationTool.generate(configuration);
}
task deleteGeneratedCode(type: Delete) {
delete genpath
}

Answer 3

#Opal's answer works great (thanks!) with a couple of tweaks. Thought I'd share to spare anyone the hassle with newer versions of jOOQ & Gradle.
The changes:
<< removed from the first line and doLast added.
jOOQ .xsd updated to 3.9.2
org.jooq.util.GenerationTool.generate(writer.toString()) to generate the code
task generate {
doLast {
def writer = new StringWriter()
def xml = new groovy.xml.MarkupBuilder(writer)
.configuration('xmlns': 'http://www.jooq.org/xsd/jooq-codegen-3.9.2.xsd') {
jdbc() {
driver('org.h2.Driver')
url('jdbc:h2:~/test-gradle')
user('sa')
password('')
}
generator() {
database() {
}
generate() {
}
target() {
packageName('org.jooq.example.gradle.db')
directory('src/main/java')
}
}
}
org.jooq.util.GenerationTool.generate(writer.toString())
}
}