JPA 无交易活动

Question

我正在使用 JPA 框架来实现信息的数据库持久性。

这就是我使用我创建的类的方式：

public class ManageConnection {

 private static EntityManagerFactory emf = null;
 private static EntityManager em = null;
 private static String persitenceName="locationtracker";

 public static EntityManager getEntityManager(){
    if(emf==null || !emf.isOpen())
        emf =  Persistence.createEntityManagerFactory(persitenceName);
    if(em==null || !em.isOpen())
        em=emf.createEntityManager();

    return em;
 }
 public static void closeEntityManager(){
    if(em!=null && em.isOpen())
        em.close()
 }
}

然后在我的 servlet 中我是这样使用的：

public void doPost(blablah){   
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    .
    for(blah blah){

         Manageconnection.getEntityManager().getTransaction().begin();
            <PersistenceObject> objName = new <PersistenceObject>();
                 //properties of the objName to persist
         ManageConnection.getEntityManager().persist(<objName>);
         Manageconnection.getEntityManager().getTransaction().commit();
    }

    Manageconnection.closeEntityManager();
}

现在我的问题是，当我将值传递给我的 Servlet 时，我得到 Transaction is already active 异常，同样的代码在没有 Servlet 的情况下也能完美运行，我的意思是在测试中使用 main 方法class 它运行起来像魅力，但是在 Servlet 中运行时会抛出异常。

请帮帮我............ ;( 提前致谢， 安库尔

Answer 1

您的所有EntityManagerFactory 和EntityManagerFactory 都使用static。它是类级别，适用于ManageConnection 的所有实例。首先，如果创建了ManageConnection 的实例，它将共享ManageConnection 的其他实例。我的建议是尝试不使用static。

Answer 2

1. 我假设您不想使用 EJB，而是想使用 POJO。
   （注意有一个简单的解决方案，会话 Bean 执行 JPA 操作，Servlet 调用 EJB - 更少的代码，更少的丑陋，做你想要的。）

2. 每个 servlet 会话都应该有自己的实体管理器实例。从类 ManageConnection 中删除所有“静态”情况。然后在您的 servlet 中，当您创建 HttpSession 时，另外创建一个 ManageConnection 实例并将其作为属性存储在会话中。

   公共类 MyServlet 扩展 HttpServlet {

   private ManageConnections getManageConnections(HttpSession sess) {
       ManageConnection manageConnection = 
           (ManageConnection)sess.getAttribute("userManageConnection");
       if (manageConnection == null) {
           ManageConnection manageConnection = new ManageConnection();
           sess.setAttribute("userManageConnection", manageConnection);
       }
   }
   
   public void doPost(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException {
      this.processRequest(req, resp);
   }
   
   public void processRequest(HttpServletRequest req, HttpServletResponse resp) 
        throws ServletException, IOException {
       HttpSession sess = req.getSession(true);
       ManageConnections manageConnections = this.getManageConnections(sess);
       // remaining JPA operations
   }
   

   }

3. 获取 EntityManager：

   // inside processRequest() above
   EntityManager em = manageConnection.getEntityManager();
   

4. 开始Tx，做实体操作，结束Tx

   // inside processRequest() above
    em.getTransaction().begin();
    <PersistenceObject> objName = new <PersistenceObject>();
    //properties of the objName to persist
    em.persist(<objName>);
    em.getTransaction().commit();
   

5. 在用户完成会话之前关闭 EntityManager。这很重要，因为如果没有它，某些实现将需要经常重新启动 - 特别是在开发期间，当您经常重建和重新部署时（我在看你，Glassfish 上的 EclipseLink，使用 netbeans 模块部署）。

    make servlet:  extends HttpSessionListener
   
    // add the following methods, so we get a callback to sessionDestroyed when the 
    // session is closed via user logout (terminateSession) or session timeout:
   
    public void init(ServletConfig config) throws ServletException {
       config.getServletContext().addListenter(this.class.getName());
    }
   
   
    public void sessionCreated(HttpSessionEvent se) {
    }
   
    public void sessionDestroyed(HttpSessionEvent se) {
          ManageConnections manageConnections = this.getManageConnections();
          manageConnections.getEntityManager().close();
          manageConnections.getEntityManagerFactor().close();
    }
   

正如我所说 - 有点难看，因为我们在无状态 Servlet 中使用了一个非常有状态的应用程序托管实体管理器。在无状态会话 Bean 中使用事务范围实体管理器或在有状态会话 Bean 中使用扩展范围（或应用程序管理）实体管理器要干净得多...... 相当多的 JPA，但比听起来容易。 :-)

Answer 3

我创建了两个这样的类：

 //This class has the EntityManagerFactory instance that is going to be shared between the classes
 public class ManageConnection {

  protected static EntityManagerFactory emf = null;
  private static String persitenceName="locationtracker";

  //Anonymous Block that is going to be called (beofre) on every call for constructor of this class
  //whether through inheritance or normal instantiation
  {
    if(emf==null || !emf.isOpen())
        emf =  Persistence.createEntityManagerFactory(persitenceName);
  }


  public static EntityManagerFactory getEntityManagerFactory(){
    return ManageConnection.emf;
  }
}
//This class actually handles the trasactional management
 public class ManageTransaction extends ManageConnection{

   /**
    * 
    */
   public ManageTransaction() {
    super();
    this.entityManager = emf.createEntityManager();
    this.transaction = this.entityManager.getTransaction();

   }

   /**
    * @param entityManager
    * @param transaction
    */
   public ManageTransaction(EntityManager entityManager,EntityTransaction transaction) {
    super();
    this.entityManager = entityManager;
    this.transaction = transaction;
   }

   private EntityManager entityManager;
   private EntityTransaction transaction;

   /**
    * @return the entityManager
    */
   public EntityManager getEntityManager() {
    return entityManager;
   }

   /**
    * @param entityManager the entityManager to set
    */
   public void setEntityManager(EntityManager entityManager) {
    this.entityManager = entityManager;
   }

   /**
    * @return the transaction
    */
   public EntityTransaction getTransaction() {
    return transaction;
   }

   /**
    * @param transaction the transaction to set
    */
   public void setTransaction(EntityTransaction transaction) {
    this.transaction = transaction;
   }

   public void closeEntityManager(){
    if(entityManager!=null && entityManager.isOpen()){
        entityManager.close();
    }
   }

   public void close(){
    this.closeEntityManager();
   }

   public void flush(){
    entityManager.flush();
   }

   public void begin(){
    this.transaction.begin();
   }

   public void commit(){
    this.flush();
    this.transaction.commit();
   }

   public void persist(Object objToPersist){
    this.entityManager.persist(objToPersist);
   }
 }//end of ManageTransaction class

现在如果我想使用它，我会这样使用：

.
.
.
.
.
.
ManageTransaction mt = new ManageTransaction();

场景 1

 mt.getEntityManager().find(blah,blah);//works perfectly

场景 2

mt.begin();
<PersistenceObject> objName = new <PersistenceObject>();
mt.persist(objName);
mt.close();

场景 3

String jpaquery = "blah blah";
TypedQuery<ClassType> tq = mt.getEntityManager().createQuery(jpaquery,<Class>.class);
List<ClassType> all = tq.getResultList();

通过这种方式，每次不需要创建新事务时，我只需创建一个事务并在我的类中的每个位置使用该事务，最后关闭它。

这样我共享 EntityManager 的问题就解决了，因此在任何情况下都不会抛出 Exception。

:)