com.github.susom.database

Class DatabaseProviderVertx

java.lang.Object

com.github.susom.database.DatabaseProviderVertx

All Implemented Interfaces:

java.util.function.Supplier<Database>

public final class DatabaseProviderVertx
extends Object
implements java.util.function.Supplier<Database>

This is a lazy provider for Database instances. It helps avoid allocating connection or transaction resources until (or if) we actually need a Database. As a consequence of this laziness, the underlying resources require explicit cleanup by calling either commitAndClose() or rollbackAndClose().

Author:

garricko

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	DatabaseProviderVertx.Builder This builder is immutable, so setting various options does not affect the previous instance.

Constructor Summary

Constructors

Constructor and Description
DatabaseProviderVertx(io.vertx.core.Vertx vertx, javax.inject.Provider<Connection> connectionProvider, Options options)

Method Summary

Modifier and Type	Method and Description
void	commitAndClose()
DatabaseProviderVertx.Builder	fakeBuilder()
static DatabaseProviderVertx.Builder	fromPool(io.vertx.core.Vertx vertx, DatabaseProvider.Pool pool) Use an externally configured DataSource, Flavor, and optionally a shutdown hook.
Database	get()
static DatabaseProviderVertx.Builder	pooledBuilder(io.vertx.core.Vertx vertx, Config config) Configure the database from the following properties read from the provided configuration:
void	rollbackAndClose()
void	transact(DbCode code) Execute a transaction on the current thread, with default semantics (commit if the code completes successfully, or rollback if it throws an error).
void	transact(DbCodeTx code) Same as transact(DbCode), but your code block can explicitly manage the behavior of the transaction.
<T> void	transactAsync(DbCodeTyped<T> code, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> resultHandler) Execute a transaction on a Vert.x worker thread, with default semantics (commit if the code completes successfully, or rollback if it throws an error).
<T> void	transactAsync(DbCodeTypedTx<T> code, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> resultHandler) Execute a transaction on a Vert.x worker thread, with default semantics (commit if the code completes successfully, or rollback if it throws an error).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

DatabaseProviderVertx

public DatabaseProviderVertx(io.vertx.core.Vertx vertx,
                             javax.inject.Provider<Connection> connectionProvider,
                             Options options)

Method Detail

pooledBuilder

@CheckReturnValue
public static DatabaseProviderVertx.Builder pooledBuilder(io.vertx.core.Vertx vertx,
                                                                            Config config)

Configure the database from the following properties read from the provided configuration:

   database.url=...       Database connect string (required)
   database.user=...      Authenticate as this user (optional if provided in url)
   database.password=...  User password (optional if user and password provided in
                          url; prompted on standard input if user is provided and
                          password is not)
   database.pool.size=... How many connections in the connection pool (default 10).
   database.driver.class  The driver to initialize with Class.forName(). This will
                          be guessed from the database.url if not provided.
   database.flavor        One of the enumerated values in Flavor. If this
                          is not provided the flavor will be guessed based on the
                          value for database.url, if possible.
 

The database flavor will be guessed based on the URL.

A database pool will be created using HikariCP.

Be sure to retain a copy of the builder so you can call close() later to destroy the pool. You will most likely want to register a JVM shutdown hook to make sure this happens. See VertxServer.java in the demo directory for an example of how to do this.

fromPool

@CheckReturnValue
public static DatabaseProviderVertx.Builder fromPool(io.vertx.core.Vertx vertx,
                                                                       DatabaseProvider.Pool pool)

Use an externally configured DataSource, Flavor, and optionally a shutdown hook. The shutdown hook may be null if you don't want calls to Builder.close() to attempt any shutdown. The DataSource and Flavor are mandatory.

transact

public void transact(DbCode code)

Execute a transaction on the current thread, with default semantics (commit if the code completes successfully, or rollback if it throws an error). Note you will get a DatabaseException if you try to call this from the event loop thread. If the provided code block throws anything, it will be wrapped into a DatabaseException unless it was a ThreadDeath or was already a DatabaseException.

transactAsync

public <T> void transactAsync(DbCodeTyped<T> code,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> resultHandler)

Execute a transaction on a Vert.x worker thread, with default semantics (commit if the code completes successfully, or rollback if it throws an error). The provided result handler will be call after the commit or rollback, and will run on the event loop thread (the same thread that is calling this method).

transact

public void transact(DbCodeTx code)

Same as transact(DbCode), but your code block can explicitly manage the behavior of the transaction.

transactAsync

public <T> void transactAsync(DbCodeTypedTx<T> code,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<T>> resultHandler)

Execute a transaction on a Vert.x worker thread, with default semantics (commit if the code completes successfully, or rollback if it throws an error). The provided result handler will be call after the commit or rollback, and will run on the event loop thread (the same thread that is calling this method).

get

public Database get()

Specified by:

get in interface java.util.function.Supplier<Database>

fakeBuilder

public DatabaseProviderVertx.Builder fakeBuilder()

commitAndClose

public void commitAndClose()

rollbackAndClose

public void rollbackAndClose()