CDI @Produces for JDBC Connections
The combination of the CDI @Produces feature with @RequestScoped or @TransactionalScoped is an interesting patter that lets you easily manage connections by skipping the old try-finally block entirely. Like the @Pooled beans, it reduces complexity by avoiding try-finally, and more importantly makes the application more testable. In theory, to test the try-finally pattern, you need a test with a forced exception to verify that the finally actually exists, or more importantly that some future refactoring doesn’t remove the finally by mistake.
The resource proxy pattern of CDI uses the @NormalScope with @Produces. A @NormalScope like @RequestScoped or @TransactionalScoped injects a proxy to the resource, not the resource itself. For JDBC Connections, each thread gets its own actual Connection, while all threads share the same Connection proxy through injection.
Using it is trivial: just inject the Connection. In this example, I’m assuming an application @Qualifier @User, as if the application has a separate @User database distinct from other databases. As usual with CDI, if you only have a single database, you can just use the @Default qualifier.
public class MyServlet extends GenericServlet {
@Inject @User
private Connection _userConnection;
void doUserLookup()
{
Statement stmt = connection.createStatement();
...
}
}
When the connection.createStatement() executes, Resin will create a new instance of the actual connection and use it to return the statement. Any further uses of the connection in this thread will use the same connection. When the request completes, i.e. the @RequestScoped finishes, the factory will close the connection instance, returning it to the pool.
The factory for the connection is just a matched pair of a @Produces method and a @Disposes method to allocate the actual connection and free the connection. The proxy generation happens automatically because of the @RequestScoped (or any @NormalScoped) scope.
import javax.inject.*;
import javax.enterprise.inject.*;
public class MyJdbcFactory {
@Inject @User DataSource _dataBase;
@Produces @User @RequestScoped
public Connection create()
throws SQLException
{
return _dataBase.getConnection();
}
public void free(@Disposes @User Connection conn)
throws SQLException
{
conn.close();
}
}
Since Resin’s CDI itself guarantees that free will be called for any connection, it’s replacing all of our finally blocks. We’re using the @User qualifier to select the database, because the DataSource we’re injecting is also a @User database to match the @User connection.
This proxy factory pattern extends to any resource that has a create/free pattern. Refactoring multiple create/free calls into a single CDI factory simplifies the code, and more importantly improves the testability and reliability of your application.