One of my major goals for Hibernate is to make sure we offer all sorts of performance improvements to reduce transaction response time and increase throughput. In Hibernate 5.2.10, we addressed the HHH-11542 Jira issue which allows you now to delay the database connection acquisition for resource-local transactions as well.
In this article, I’m going to explain how Hibernate acquires connections and why you want it to delay this process as long as possible.
Resource-local vs. JTA
In Hibernate, the database connection acquisition, as well as the connection release, are relative to the type of the currently running transaction:
- resource-local: For JDBC transactions, that operate with a single
Connectionis acquired right when the transaction starts and is closed when the transaction ends (either commit or rollback)
- JTA: For XA transactions, that span over multiple
Connectionis acquired upon executing the first
Statementand is released after each
Statementexecution. The aggressive connection release mechanism can be skipped if the underlying application server allows us to do so.
Delaying the resource-local connectcion acquisition
Our goal is to make the resource-local transaction behave like JTA and delay the connection acquisition until Hibernate needs to execute the first JDBC
Statement of the currently running unit-of-work.
The reason why resource-local transaction requires a database connection from the very beginning can be easily visualized in the following diagram:
Hibernate needs to check the underlying JDBC
Connection auto-commit status, and disable it if the
Connection is set to auto-commit. This way, Hibernate can control the transaction boundaries and make sure that the unit-of-work JDBC
Statement(s) are executed in the context of the same database transaction.
Although this behavior is correct since we cannot know if the auto-commit flag was set or not, we could hint Hibernate to skip this check since we already know that all JDBC
Connection(s) run in manual commit mode.
For instance, all enterprise applications already use a connection pooling solution which can disable the auto-commit mode when the database connection is firsts established.
HikariConfig hikariConfig = super.hikariConfig( dataSource ); hikariConfig.setAutoCommit( false );
For this reason, in Hibernate 5.2.10, we introduced the
hibernate.connection.provider_disables_autocommit configuration property which tells Hibernate that the underlying JDBC
Connection(s) already disabled the auto-commit mode.
To measure the performance advantage of delaying database connection acquisition, we are going to use a test case which emulates a resource-intensive XML document parsing which happens within the boundaries of the JPA transaction context.
If we don’t delay the connection acquisition, the XML parsing duration is going to be added to the database connection lease time. However, once we switch to the new connection delay mechanism, the connection lease time is reduced considerably as illustrated by the graph below.
Therefore, if you are using resource-local transactions (which is quite the norm when using Spring framework), you should definitely configure the connection pool (e.g. HikariCP) to disable the auto-commit commit, and provide the connection acquisition delay Hibernate configuration property:
<property name="hibernate.connection.provider_disables_autocommit" value="true" />
Hibernate is not just an ORM tool, but a full-blown data access framework. Because database connection management is very important for a high-performance enterprise application, Hibernate allows you to minimize the window of time required to execute a database transaction which leads to a higher transaction throughput as well.