I made it work using wrapped EntityManager, to get thread local entity
manager from factory. See attached files as example. It looks like a bit
overcomplicated, but I think that Spring is doing something similar deep
inside.
On Sunday, August 26, 2012 2:40:43 AM UTC+3, Markus Fischboeck wrote:
>
> Hi!
>
> I've been integrating Guice 3.0 into a desktop application.
> To access my database I use JPA together with EclipseLink. Everything is
> configured straight forward, using the JpaPersistModule guice provides.
> The application runs multiple threads and each thread is using the same
> data access object to read and write data in which the EntityManager is
> injected using constructor injection.
> However it appears that using the DAO within a thread, transactions are
> not commited and entities do not appear in the database.
>
> After inspecting that issue, I've seen that the EntityManager get's
> injected as a singleton, which is not suitable as it is not thread-safe. I
> then tried to inject the EntityManagerFactory instead, which bypasses the
> transaction interception somehow.
>
> Is there a general approach to get this working? Unfortunately I haven't
> found much about this topic especially in conjunction with guice on the
> web. Any help is greatly appreciated!
>
>
>
>
--
You received this message because you are subscribed to the Google Groups
"google-guice" group.
To view this discussion on the web visit
https://groups.google.com/d/msg/google-guice/-/ReK0bCfXsJ8J.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/google-guice?hl=en.
import com.google.inject.Inject;
import javax.persistence.EntityManager;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class TransactionalInterceptor implements MethodInterceptor {
@Inject
private EntityManagerProvider entityManagerProvider;
@Override
public Object invoke(MethodInvocation mi) throws Throwable {
EntityManager entityManager = entityManagerProvider.getEntityManager();
entityManager.getTransaction().begin();
try {
Object result = mi.proceed();
entityManager.getTransaction().commit();
return result;
}
catch (Exception e) {
entityManager.getTransaction().rollback();
throw e;
}
}
}
import com.google.inject.Inject;
import com.google.inject.Singleton;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
@Singleton
public class EntityManagerFlowFilter implements Filter {
private final EntityManagerProvider entityManagerProvider;
@Inject
public EntityManagerFlowFilter(EntityManagerProvider entityManagerProvider) {
this.entityManagerProvider = entityManagerProvider;
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
entityManagerProvider.init();
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
entityManagerProvider.create();
try {
chain.doFilter(request, response);
}
finally {
entityManagerProvider.close();
}
}
@Override
public void destroy() {
entityManagerProvider.destroy();
}
}
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class EntityManagerProvider {
private final String unitName;
private EntityManagerFactory entityManagerFactory;
private final ThreadLocal<EntityManager> threadLocalEntityManager;
public EntityManagerProvider(String unitName) {
this.unitName = unitName;
threadLocalEntityManager = new ThreadLocal<EntityManager>();
}
public EntityManager getEntityManager() {
EntityManager entityManager = threadLocalEntityManager.get();
if (entityManager == null) {
throw new IllegalStateException("Thread local entityManager is empty");
}
return entityManager;
}
public void init() {
entityManagerFactory = Persistence.createEntityManagerFactory(unitName);
// TODO find better place for this preparation block:
new UserPreparator().prepareUsers(entityManagerFactory.createEntityManager());
}
public void destroy() {
entityManagerFactory.close();
}
public void create() {
EntityManager entityManager = threadLocalEntityManager.get();
if (entityManager != null && entityManager.isOpen()) {
entityManager.close();
}
entityManager = entityManagerFactory.createEntityManager();
threadLocalEntityManager.set(entityManager);
}
public void close() {
EntityManager entityManager = threadLocalEntityManager.get();
if (entityManager != null) {
entityManager.close();
threadLocalEntityManager.remove();
}
}
}
import com.google.inject.Inject;
import com.google.inject.Singleton;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.FlushModeType;
import javax.persistence.LockModeType;
import javax.persistence.Query;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.metamodel.Metamodel;
@Singleton
public class EntityManagerWrapper implements EntityManager {
private final EntityManagerProvider entityManagerProvider;
@Inject
public EntityManagerWrapper(EntityManagerProvider entityManagerProvider) {
this.entityManagerProvider = entityManagerProvider;
}
@Override
public void persist(Object entity) {
entityManagerProvider.getEntityManager().persist(entity);
}
@Override
public <T> T merge(T entity) {
return entityManagerProvider.getEntityManager().merge(entity);
}
@Override
public void remove(Object entity) {
entityManagerProvider.getEntityManager().remove(entity);
}
@Override
public <T> T find(Class<T> entityClass, Object primaryKey) {
return entityManagerProvider.getEntityManager().find(entityClass, primaryKey);
}
@Override
public <T> T find(Class<T> entityClass, Object primaryKey, Map<String, Object> properties) {
return entityManagerProvider.getEntityManager().find(entityClass, primaryKey, properties);
}
@Override
public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode) {
return entityManagerProvider.getEntityManager().find(entityClass, primaryKey, lockMode);
}
@Override
public <T> T find(Class<T> entityClass, Object primaryKey, LockModeType lockMode, Map<String, Object> properties) {
return entityManagerProvider.getEntityManager().find(entityClass, primaryKey, lockMode, properties);
}
@Override
public <T> T getReference(Class<T> entityClass, Object primaryKey) {
return entityManagerProvider.getEntityManager().getReference(entityClass, primaryKey);
}
@Override
public void flush() {
entityManagerProvider.getEntityManager().flush();
}
@Override
public void setFlushMode(FlushModeType flushMode) {
entityManagerProvider.getEntityManager().setFlushMode(flushMode);
}
@Override
public FlushModeType getFlushMode() {
return entityManagerProvider.getEntityManager().getFlushMode();
}
@Override
public void lock(Object entity, LockModeType lockMode) {
entityManagerProvider.getEntityManager().lock(entity, lockMode);
}
@Override
public void lock(Object entity, LockModeType lockMode, Map<String, Object> properties) {
entityManagerProvider.getEntityManager().lock(entity, lockMode, properties);
}
@Override
public void refresh(Object entity) {
entityManagerProvider.getEntityManager().refresh(entity);
}
@Override
public void refresh(Object entity, Map<String, Object> properties) {
entityManagerProvider.getEntityManager().refresh(entity, properties);
}
@Override
public void refresh(Object entity, LockModeType lockMode) {
entityManagerProvider.getEntityManager().refresh(entity, lockMode);
}
@Override
public void refresh(Object entity, LockModeType lockMode, Map<String, Object> properties) {
entityManagerProvider.getEntityManager().refresh(entity, lockMode, properties);
}
@Override
public void clear() {
entityManagerProvider.getEntityManager().clear();
}
@Override
public void detach(Object entity) {
entityManagerProvider.getEntityManager().detach(entity);
}
@Override
public boolean contains(Object entity) {
return entityManagerProvider.getEntityManager().contains(entity);
}
@Override
public LockModeType getLockMode(Object entity) {
return entityManagerProvider.getEntityManager().getLockMode(entity);
}
@Override
public void setProperty(String propertyName, Object value) {
entityManagerProvider.getEntityManager().setProperty(propertyName, value);
}
@Override
public Map<String, Object> getProperties() {
return entityManagerProvider.getEntityManager().getProperties();
}
@Override
public Query createQuery(String qlString) {
return entityManagerProvider.getEntityManager().createQuery(qlString);
}
@Override
public <T> TypedQuery<T> createQuery(CriteriaQuery<T> criteriaQuery) {
return entityManagerProvider.getEntityManager().createQuery(criteriaQuery);
}
@Override
public <T> TypedQuery<T> createQuery(String qlString, Class<T> resultClass) {
return entityManagerProvider.getEntityManager().createQuery(qlString, resultClass);
}
@Override
public Query createNamedQuery(String name) {
return entityManagerProvider.getEntityManager().createNamedQuery(name);
}
@Override
public <T> TypedQuery<T> createNamedQuery(String name, Class<T> resultClass) {
return entityManagerProvider.getEntityManager().createNamedQuery(name, resultClass);
}
@Override
public Query createNativeQuery(String sqlString) {
return entityManagerProvider.getEntityManager().createNativeQuery(sqlString);
}
@Override
public Query createNativeQuery(String sqlString, Class resultClass) {
return entityManagerProvider.getEntityManager().createNativeQuery(sqlString, resultClass);
}
@Override
public Query createNativeQuery(String sqlString, String resultSetMapping) {
return entityManagerProvider.getEntityManager().createNativeQuery(sqlString, resultSetMapping);
}
@Override
public void joinTransaction() {
entityManagerProvider.getEntityManager().joinTransaction();
}
@Override
public <T> T unwrap(Class<T> cls) {
return entityManagerProvider.getEntityManager().unwrap(cls);
}
@Override
public Object getDelegate() {
return entityManagerProvider.getEntityManager().getDelegate();
}
@Override
public void close() {
//entityManagerProvider.getEntityManager().close();
// reporting usage of close methods:
Logger.getLogger(getClass().getName()).log(Level.WARNING, "EntityManager.close() method is used", new Exception());
}
@Override
public boolean isOpen() {
return entityManagerProvider.getEntityManager().isOpen();
}
@Override
public EntityTransaction getTransaction() {
//Logger.getLogger(getClass().getName()).log(Level.WARNING, "EntityManager.getTransaction() method is used", new Exception());
return entityManagerProvider.getEntityManager().getTransaction();
}
@Override
public EntityManagerFactory getEntityManagerFactory() {
return entityManagerProvider.getEntityManager().getEntityManagerFactory();
}
@Override
public CriteriaBuilder getCriteriaBuilder() {
return entityManagerProvider.getEntityManager().getCriteriaBuilder();
}
@Override
public Metamodel getMetamodel() {
return entityManagerProvider.getEntityManager().getMetamodel();
}
}
