Some changes to session management and how that is handled in the JPA plugin

Author: graemerocher

Diff for: grails-datastore-gorm-jpa/src/main/groovy/org/grails/datastore/gorm/jpa/JpaGormEnhancer.groovy

@@ -30,6 +30,8 @@ import org.springframework.orm.jpa.JpaCallback
 import org.springframework.orm.jpa.JpaTemplate
 import org.springframework.transaction.PlatformTransactionManager
 import static org.grails.datastore.mapping.validation.ValidatingEventListener.*
+import org.grails.datastore.mapping.jpa.JpaDatastore
+import org.grails.datastore.mapping.core.VoidSessionCallback
 
 /**
  * Extends the default {@link GormEnhancer} adding supporting for JPQL methods
@@ -57,10 +59,26 @@ class JpaGormEnhancer extends GormEnhancer {
 }
 
 class JpaInstanceApi<D> extends GormInstanceApi<D> {
+    
+    
 
     JpaInstanceApi(Class<D> persistentClass, Datastore datastore) {
         super(persistentClass, datastore)
     }
+    
+
+    @Override
+    protected void execute(VoidSessionCallback callback) {
+        def session = datastore.connect()
+        callback.doInSession(session)
+    }
+
+    @Override
+    protected def <T> T execute(SessionCallback<T> callback) {
+        def session = datastore.connect()
+        callback.doInSession(session)
+    }
+
 
     D merge(instance, Map params) {
         def merged
@@ -128,6 +146,20 @@ class JpaStaticApi<D> extends GormStaticApi<D> {
         })
     }
 
+    @Override
+    protected void execute(VoidSessionCallback callback) {
+        def session = datastore.connect()
+        callback.doInSession(session)
+    }
+
+    @Override
+    protected def <T> T execute(SessionCallback<T> callback) {
+        def session = datastore.connect()
+        callback.doInSession(session)
+    }
+
+
+
     @Override
     List<D> executeQuery(String query) {
         doQuery query

Diff for: grails-datastore-gorm-jpa/src/main/groovy/org/grails/datastore/gorm/jpa/support/JpaPersistenceContextInterceptor.java

@@ -14,38 +14,76 @@
  */
 package org.grails.datastore.gorm.jpa.support;
 
-import org.grails.datastore.gorm.support.DatastorePersistenceContextInterceptor;
-import org.grails.datastore.mapping.core.DatastoreUtils;
-import org.grails.datastore.mapping.core.Session;
+import org.codehaus.groovy.grails.support.PersistenceContextInterceptor;
 import org.grails.datastore.mapping.jpa.JpaDatastore;
-import org.grails.datastore.mapping.transactions.SessionHolder;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
+import org.grails.datastore.mapping.jpa.JpaSession;
+import org.springframework.orm.jpa.EntityManagerFactoryUtils;
+import org.springframework.orm.jpa.JpaCallback;
+import org.springframework.orm.jpa.JpaTemplate;
+
+import javax.persistence.EntityManager;
+import javax.persistence.FlushModeType;
+import javax.persistence.PersistenceException;
 
 /**
  * @author Graeme Rocher
  * @since 1.0
  */
-public class JpaPersistenceContextInterceptor extends DatastorePersistenceContextInterceptor {
+public class JpaPersistenceContextInterceptor implements PersistenceContextInterceptor {
 
     private JpaDatastore jpaDatastore;
+    private EntityManager entityManager;
 
     public JpaPersistenceContextInterceptor(JpaDatastore datastore) {
-        super(datastore);
-        this.jpaDatastore = datastore;
+        this.jpaDatastore= datastore;
+    }
+
+    @Override
+    public void init() {
+        entityManager = EntityManagerFactoryUtils.getTransactionalEntityManager(jpaDatastore.getEntityManagerFactory());
     }
 
     @Override
-    protected Session getSession() {
-        SessionHolder sessionHolder = (SessionHolder)TransactionSynchronizationManager.getResource(jpaDatastore);
-        if (sessionHolder != null) {
-            return sessionHolder.getSession();
+    public void destroy() {
+        entityManager = null;
+    }
+
+    @Override
+    public void disconnect() {
+        if(entityManager != null) {
+            EntityManagerFactoryUtils.closeEntityManager(entityManager);
         }
 
-        return DatastoreUtils.bindSession(jpaDatastore.connect());
+    }
+
+    @Override
+    public void reconnect() {
+        entityManager = EntityManagerFactoryUtils.getTransactionalEntityManager(jpaDatastore.getEntityManagerFactory());
     }
 
     @Override
     public void flush() {
-        // do nothing
+        if(JpaSession.hasTransaction())
+            entityManager.flush();
+    }
+
+    @Override
+    public void clear() {
+        entityManager.clear();
+    }
+
+    @Override
+    public void setReadOnly() {
+        entityManager.setFlushMode(FlushModeType.COMMIT);
+    }
+
+    @Override
+    public void setReadWrite() {
+        entityManager.setFlushMode(FlushModeType.AUTO);
+    }
+
+    @Override
+    public boolean isOpen() {
+        return entityManager != null && entityManager.isOpen();
     }
 }

Diff for: grails-datastore-gorm-jpa/src/main/resources/org/grails/datastore/gorm/jpa/AddErrors.script

@@ -5,7 +5,10 @@ import org.codehaus.groovy.ast.ClassNode;
 import org.codehaus.groovy.ast.FieldNode;
 import org.codehaus.groovy.ast.AnnotatedNode;
 import org.codehaus.groovy.ast.AnnotationNode;
-
+import org.codehaus.groovy.ast.ASTNode;
+import org.codehaus.groovy.ast.expr.ConstantExpression;
+import java.lang.reflect.Modifier
+import org.springframework.validation.Errors
 
 def errorsHelper = new ASTValidationErrorsHelper() {
     protected void addErrorsField(ClassNode paramTypeClassNode) {

Diff for: grails-datastore-jpa/src/main/groovy/org/grails/datastore/mapping/jpa/JpaDatastore.java

@@ -35,6 +35,7 @@ public class JpaDatastore extends AbstractDatastore {
 
     private EntityManagerFactory entityManagerFactory;
     private JpaTransactionManager transactionManager;
+    private JpaTemplate jpaTemplate;
 
     public JpaDatastore(MappingContext mappingContext,
             EntityManagerFactory entityManagerFactory,
@@ -43,6 +44,7 @@ public JpaDatastore(MappingContext mappingContext,
         super(mappingContext, null, applicationContext);
         this.entityManagerFactory = entityManagerFactory;
         this.transactionManager = transactionManager;
+        this.jpaTemplate = new JpaTemplate(entityManagerFactory);
         initializeConverters(mappingContext);
     }
 
@@ -59,8 +61,13 @@ public JpaTransactionManager getTransactionManager() {
         return transactionManager;
     }
 
+
+    public JpaTemplate getJpaTemplate() {
+        return jpaTemplate;
+    }
+
     @Override
     protected Session createSession(Map<String, String> connDetails) {
-        return new JpaSession(this, new JpaTemplate(entityManagerFactory), transactionManager);
+        return new JpaSession(this, jpaTemplate, transactionManager);
     }
 }

Diff for: grails-datastore-jpa/src/main/groovy/org/grails/datastore/mapping/jpa/query/JpaQuery.java

@@ -74,6 +74,8 @@ public void add(Criterion criterion) {
     @Override
     protected List executeQuery(final PersistentEntity entity, final Junction criteria) {
         final JpaTemplate jpaTemplate = getSession().getJpaTemplate();
+        if(!JpaSession.hasTransaction())
+            jpaTemplate.setFlushEager(false);
 
         return (List)jpaTemplate.execute(new JpaCallback<Object>() {
             public Object doInJpa(EntityManager em) throws PersistenceException {
@@ -85,6 +87,8 @@ public Object doInJpa(EntityManager em) throws PersistenceException {
     @Override
     public Object singleResult() {
         final JpaTemplate jpaTemplate = getSession().getJpaTemplate();
+        if(!JpaSession.hasTransaction())
+            jpaTemplate.setFlushEager(false);
         try {
             return jpaTemplate.execute(new JpaCallback<Object>() {
                 public Object doInJpa(EntityManager em) throws PersistenceException {