{"id":10882,"date":"2017-12-29T17:30:51","date_gmt":"2017-12-29T15:30:51","guid":{"rendered":"https:\/\/techmoz.net\/?p=10882"},"modified":"2021-03-01T17:50:44","modified_gmt":"2021-03-01T15:50:44","slug":"java-data-access-objects-considerations-p-2","status":"publish","type":"post","link":"https:\/\/techmoz.net\/en\/java-data-access-objects-considerations-p-2\/","title":{"rendered":"Java – Data Access Objects – Considerations (p. 2)"},"content":{"rendered":"

I couldn’t let this year end without fulfilling my promise, so i had to publish this last episode of the Java – Data Access Objects – Considerations series<\/a>.<\/p>\n

We will be talking about a simple problem: when each method of a DAO opens a new connection to the database in order to fetch or modify data, a new concern pops up: how to handle transactions? How do we group DAO operations in a single ACID<\/a> transaction? Being a Javatic article, we will be assuming JDBC as the API used to interact with the database.<\/p>\n

Transacting on a JDBC connection
\nIn JDBC, transactions are bound to connections. In order to group multiple DML<\/a> statements in a transaction, we must disable the auto-commit<\/a> on the connection object we want to transact on and then we can start throwing DML statement at it and at the end we get to commit or rollback the transaction.<\/p>\n

If you take a pause and go back to our problem statements, upstairs, you might find out that we can already answer that question. We just found the answer. The answer is: the different DAO operations must share the connection object in order to have their DML statements grouped in a single transactional unit which will be later committed or rolled back.<\/p>\n

It’s important to make sure that the connection object is shared among the DAO operations only when we are in the middle of a transaction, otherwise, each operation should open it’s own connection.<\/p>\n

This means that we need a way to check if we are in the middle of a transaction or not, so that we can decide to use the shared connection object or to create a new connection.<\/p>\n

We will put the getConnection()<\/strong> method in our AbstractDAO<\/strong>, so that specific DAO classes are not aware (abstraction) of the existence of a shared connection and all that mambo-djambo.<\/p>\n

The CustomerDAO example<\/h3>\n

See below the code of the CustomerDAO,<\/strong> which extends the AbstractDAO<\/strong>, that we will soon be discussing.<\/p>\n

\r\npublic class CustomerDAO extends AbstractDAO {\r\n\r\n    \r\n    public void updateEmail(String personId, String email){\r\n        \r\n       \/\/TODO: Validate arguments\r\n        \r\n        Connection connection = this.getConnection();\r\n\r\n        try{\r\n\r\n            \/\/Execute the update operation here\r\n\r\n\r\n        }finally{\r\n\r\n           this.close(connection);\r\n\r\n        }\r\n\r\n    }\r\n\r\n\r\n    public void updateMobile(String personId, String mobile){\r\n        \r\n        \/\/TODO: Validate arguments\r\n        \r\n        Connection connection = this.getConnection();\r\n\r\n        try{\r\n\r\n            \r\n            \/\/Execute the update operation here\r\n\r\n        }finally{\r\n\r\n           this.close(connection);\r\n\r\n        }\r\n\r\n    }\r\n    \r\n\r\n}\r\n<\/pre>\n
Both methods close<\/strong> and getConnection<\/strong> belong to the AbstractDAO<\/strong> class.<\/p>\n
Abstract DAO<\/h3>\n
This would be the parent class of all our DAO classes. Providing the logic required to make the DAO objects transaction capable.<\/p>\n
\r\npublic abstract class AbstractDAO {\r\n\r\n     \r\n     private static ThreadLocal<Connection> sharedConnection = new ThreadLocal<>();\r\n\r\n\r\n     \/\/Returns the shared connection, if exists, \r\n     \/\/otherwise, creates a new one\r\n     protected Connection getConnection(){\r\n\r\n         Optional<Connection> optional = getSharedConnection();\r\n\r\n         if(optional.isPresent()) \r\n             return optional.get();\r\n         else return openNewConnection(); \r\n\r\n     }   \r\n\r\n\r\n     \/\/Keep the connection open in case it's shared\r\n     \/\/Close the connection if not shared\r\n     protected close(Connection connection){\r\n         \r\n         if(getSharedConnection().isPresent())\r\n             return;\r\n\r\n         connection.close();\r\n\r\n     }\r\n\r\n    \r\n     private Optional<Connection> getSharedConnection(){\r\n        return Optional.ofNullable(sharedConnection.get());\r\n     }\r\n\r\n     private static Connection openNewConnection(){\r\n         \/\/Open a new database connection here\r\n     } \r\n\r\n\r\n     \/\/Starts a new transaction (on the current Thread).\r\n     \/\/Creates a shared connection\r\n     \/\/with auto-commit disabled\r\n     public static void beginTransaction(){\r\n        Connection connection = openNewConnection();\r\n        connection.setAutoCommit(false);\r\n        sharedConnection.set(connection);\r\n     }\r\n     \r\n     \r\n\r\n     \/\/Commits the active-transaction\r\n     \/\/Closes and clears the shared connection\r\n     public static void commitTransaction(){\r\n\r\n         Optional<Connection> optional = getSharedConnection();\r\n         if(!optional.isPresent())\r\n             throw new IllegalStateException("No active transaction");\r\n\r\n         Connection connection = optional.get();\r\n\r\n         try{\r\n\r\n            connection.commit(); \r\n\r\n         }finally{\r\n\r\n            connection.close(); \/\/close the shared connection\r\n            sharedConnection.remove();\/\/remove the shared connection;\r\n \r\n         }\r\n         \r\n     }\r\n\r\n\r\n\r\n     \/\/Rolls back the active-transaction\r\n     \/\/Closes and clears the shared connection\r\n     public static void rollbackTransaction(){\r\n\r\n         Optional<Connection> optional = getSharedConnection();\r\n         if(!optional.isPresent())\r\n             throw new IllegalStateException("No active transaction");\r\n\r\n         Connection connection = optional.get();\r\n\r\n         try{\r\n\r\n             connection.rollback();\r\n\r\n         }finally{\r\n\r\n             connection.close(); \/\/close\r\n             sharedConnection.remove(); \/\/remove\r\n\r\n         }\r\n        \r\n     }\r\n\r\n}\r\n<\/pre>\n
You might have noticed that the AbstractDAO<\/strong> class has a few static methods. That methods are intended to be invoked from the transaction-demarcation layer, which is the services-layer.<\/p>\n
In a nutshell, we could for example, have a service method that updates customer information as below:<\/p>\n
\r\npublic void updateCustomerDetails(String id, String email, String mobile){\r\n    \r\n     CustomerDAO dao = new CustomerDAO();\r\n\r\n     \/\/Start a new transaction\r\n     AbstractDAO.beginTransaction();\r\n\r\n     try{\r\n\r\n         \/\/Update the details\r\n         dao.updateEmail(id,email);\r\n         dao.updateMobile(id,mobile);\r\n         \r\n         \/\/Commit the transaction\r\n         AbstractDAO.commitTransaction();\r\n\r\n    }catch(RuntimeException ex){\r\n        \/\/Rollback the transaction\r\n        AbstractDAO.rollbackTransaction();\r\n        throw ex;\r\n\r\n    }\r\n     \r\n\r\n}\r\n<\/pre>\n
We made sure that all DAO operations executed in the same transaction will share the connection, while operations executed out of a transaction won’t share the connection object.<\/p>\n
We also made sure that multiple Threads executing transactions wont be sharing the connection object, meaning, each Thread will have its own connection object, thanks to the ThreadLocal<\/a> variable. In this model, one Thread can only execute one transaction per time, no chained transactions are supported. Despite the fact that it works, it’s worth asking if it’s the best way to deal with transactions across DAOs.<\/p>\n
Is it the best way?<\/h3>\n
While what we have done in this article is a good way to explain how transaction-demarcation works behind the scenes, it’s probably not the best way to deal with transactions across DAOs in a J2EE application. But what would the real cons be? Here they follow:<\/p>\n