A jOOQ-CodeGenerator to create vertx-ified DAOs and POJOs!
Perform all CRUD-operations asynchronously and convert your POJOs from/into a io.vertx.core.json.JsonObject
using the API and
driver of your choice.
executeAny
-methods in ReactiveQueryExecutor
-implementations.TEXT
and needs to be mapped to a
user defined enum)PgConverter
for the reactive modules. This gives users finally the opportunity to use custom POJOs
instead of JsonObjects
. The generators are also properly used in the fromJson
and toJson
-methods.BuildOptions
when creating a code generator using VertxGeneratorBuilder
. Currently one flag
can be set which determines whether to use singletons (default) for converters or
instantiate them every time. When set to SINGLETON
-mode, this will create two classes
with references to all Converters
and Bindings
that are used.findManyBy
-methods now take Collection
as argument
https://github.com/jklingsporn/vertx-jooq/milestone/18?closed=1
Before you start generating code using vertx-jooq, you have to answer these questions:
io.vertx.core.Future
-based API. This is vertx-jooq-classic
.vertx-jooq-rx
.java.util.concurrent.CompletableFuture
for all async DAO operations. This is vertx-jooq-completablefuture
.-jdbc
suffix.-async
modules.-reactive
modules.When you made your choice, you can start to configure the code-generator. This can be either done programmatically or using a maven- / gradle-plugin (recommended way). Please check the documentation in the module of the API of your choice how to set it up:
vertx-jooq-classic-async
vertx-jooq-classic-jdbc
vertx-jooq-classic-reactive
vertx-jooq-rx-async
vertx-jooq-rx-jdbc
vertx-jooq-rx-reactive
vertx-jooq-completablefuture-async
vertx-jooq-completablefuture-jdbc
vertx-jooq-completablefuture-reactive
Once the generator is set up, it will create DAOs like in the code snippet below (classic-API, JDBC, no dependency injection):
//Setup your jOOQ configuration
Configuration configuration = ...
//setup Vertx
Vertx vertx = Vertx.vertx();
//instantiate a DAO (which is generated for you)
SomethingDao dao = new SomethingDao(configuration,vertx);
//fetch something with ID 123...
dao.findOneById(123)
.setHandler(res->{
if(res.succeeded()){
vertx.eventBus().send("sendSomething", res.result().toJson())
}else{
System.err.println("Something failed badly: "+res.cause().getMessage());
}
});
//maybe consume it in another verticle
vertx.eventBus().<JsonObject>consumer("sendSomething", jsonEvent->{
JsonObject message = jsonEvent.body();
//Convert it back into a POJO...
Something something = new Something(message);
//... change some values
something.setSomeregularnumber(456);
//... and update it into the DB
Future<Integer> updatedFuture = dao.update(something);
});
//or do you prefer writing your own type-safe SQL? Use the QueryExecutor from the DAO...
ClassicQueryExecutor queryExecutor = dao.queryExecutor();
//... or create a new one when there is no DAO around :)
queryExecutor = new JDBCClassicGenericQueryExecutor(configuration,vertx);
Future<Integer> updatedCustom = queryExecutor.execute(dslContext ->
dslContext
.update(Tables.SOMETHING)
.set(Tables.SOMETHING.SOMEREGULARNUMBER,456)
.where(Tables.SOMETHING.SOMEID.eq(something.getSomeid()))
.execute()
);
//check for completion
updatedCustom.setHandler(res->{
if(res.succeeded()){
System.out.println("Rows updated: "+res.result());
}else{
System.err.println("Something failed badly: "+res.cause().getMessage());
}
});
The generator will omit datatypes that it does not know, e.g. java.sql.Timestamp
. To fix this, you can subclass the generator, handle these types and generate the code using your generator.
See the handleCustomTypeFromJson
and handleCustomTypeToJson
methods in the AbstractVertxGenerator
or checkout the CustomVertxGenerator
from the tests.
This library comes without any warranty - just take it or leave it. Also, the author is neither connected to the company behind vertx nor the one behind jOOQ.