Play2 Comment gérer la transaction de la couche de service au lieu de la couche d'action?

Question

J'utilise Java avec Play2.1.1 JPA2.0 avec la mise en œuvre de mise en veille prolongée.

pour contrôler la transaction par le code au lieu d'utiliser @Transactional comme ci-dessous est le style normal de code JPA, est-il un moyen de travailler comme ci-dessous au jeu? ou comment utiliser JPA.withtranaction() à faire? Je l'ai essayé, aucune idée de comment passer dans le paramètre, je ne suis pas familier avec le code fonctionnel. Merci beaucoup. S'il vous plaît donnez-moi un exemple de code basé sur ci-dessous. Maintenant, je change mon code ci-dessous pour commencer la transaction à partir de la couche de service, il ne semble pas efficace, y at-il un autre moyen d'écrire? grâce

private void internalCreateActor(String email, String psw) throws ActorException { 
     if (StringUtils.isEmpty(email) || StringUtils.isEmpty(psw)) 
      throw new ActorException(CODE.INVALIDE_PARAMETER); 
     try { 
      this.dbActor.setEmail(email); 
      this.dbActor.setCredential(psw); 
      this.dbActor.setCreateD(new Date()); 
      JPA.em().persist(this.dbActor); 
     } catch (Exception e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
      throw new ActorException(CODE.UNKNOWN, e); 
     } 
    } 

public void createActor(final String email, final String psw, final String cellPhone, final Actor.TYPE type) 
      throws Throwable { 

     JPA.withTransaction(new Callback0() { 
      @Override 
      public void invoke() throws Throwable { 
       internalCreateActor(email, psw, cellPhone, type); 
      } 
     }); 
    } 

Answer 1

Après quelques recherches, j'écrire une méthode JPAUtil référant à JPA fourni par Play qui peut utiliser normalement pour contrôler la transaction manuellement à partir de la couche de service effectivement partout.

public class JPAUtil { 

    static ThreadLocal<EntityManager> currentEntityManager = new ThreadLocal<EntityManager>(); 

    /** 
    * Get the EntityManager for specified persistence unit for this thread. 
    */ 
    public static EntityManager em(String key) { 
     Application app = Play.application(); 
     if (app == null) { 
      throw new RuntimeException("No application running"); 
     } 

     JPAPlugin jpaPlugin = app.plugin(JPAPlugin.class); 
     if (jpaPlugin == null) { 
      throw new RuntimeException("No JPA EntityManagerFactory configured for name [" + key + "]"); 
     } 

     EntityManager em = jpaPlugin.em(key); 
     if (em == null) { 
      throw new RuntimeException("No JPA EntityManagerFactory configured for name [" + key + "]"); 
     } 

     bindForCurrentThread(em); 

     return em; 
    } 

    /** 
    * Get the default EntityManager for this thread. 
    */ 
    public static EntityManager em() { 
     EntityManager em = currentEntityManager.get(); 
     if (em == null) { 
      return em(Constants.DATASOURCEKEY); 
     } 
     return em; 
    } 

    /** 
    * Bind an EntityManager to the current thread. 
    */ 
    public static void bindForCurrentThread(EntityManager em) { 
     currentEntityManager.set(em); 
    } 

    public static void closeEM() { 
     EntityManager em = currentEntityManager.get(); 
     if (em != null) { 
      em.close(); 
     } 
     bindForCurrentThread(null); 
    } 

    public static void beginTransaction() { 
     em().getTransaction().begin(); 
    } 

    public static void commitTransaction() { 
     em().getTransaction().commit(); 
    } 

} 

Answer 2

quelque chose comme ceci:

public static User getUserByIdentity(final AuthUserIdentity identity) { 
    try { 
     return JPA.withTransaction(new play.libs.F.Function0<User>() { 
      public User apply() {  
       return User.findByAuthUserIdentity(identity); 
      } 
     }); 
    } catch (Throwable t) { 
     throw new RuntimeException(t); 
    }  
}