Question

I am using Guice, Guice Persist, Hibernate and Jersey. All my resource methods are annotated with @Transactional except for the methods that are annotated with @GET. Is this the correct way configure the transaction-per-request scope?

Answer 1

There is no “correct” way; it depends on what you are trying to achieve. There is a few separate issues involved in answering your question, as discussed below.

1. Data access pattern: The traditional pattern in enterprise Java is to have your controllers make calls to DAOs (Data Access Objects), which handle persistence. In this pattern, your transaction annotations would be placed on the DAO methods, not your controller methods. However, many people find DAOs to be overkill and prefer to have the entity manager injected into the controller. This is a perfectly acceptable alternative and, from what I can tell, this is the approach you have chosen.
2. Thread safety: You must be aware that entity manager instances are not thread safe, so your controllers must not be singletons and must be request-scoped. In other words, you cannot share an entity manager across multiple requests, so you must set your controllers to be re-created and have a new entity manager injected for every request.
3. Transactions: If your data retrieval operation only requires one query, you will not require a transaction. However, building a complete object graph generally requires many queries. In this circumstance, your retrieval must be transactional in order to guarantee consistency, because the data might change between queries. Some frameworks will actually require all database access to be transactional, or the entity manager will not be injected correctly.

In summary, your data access pattern is fine, as long as your controllers are request-scoped. However, your “GET” functions should be transactional if many queries will be involved in creating the object graph.