Question

我正在使用Struts 1.3 + JPA（Hibernate作为持久性提供程序）开发一个简单的“Book Store”项目。我无法切换到Spring或任何其他更复杂的开发环境（例如，Jboss），我不能使用任何特定于Hibernate的技术（例如，Session类）。

鉴于我在JSE环境中，我需要明确管理整个EntityManager的生命周期。

Book实体的定义如下：

@Entity
public class Book {

@Id private String isbn;
private String title;
private Date publishDate;

    // Getters and Setters
}

我定义了三个Action类，它们分别负责检索所有书籍实例，通过其ISBN检索单个书籍实例并将分离的书籍合并到数据库中。

为了增加业务逻辑代码和数据访问代码之间的关注点分离，我引入了一个简单的BookDAO对象，负责执行CRUD操作。理想情况下，应将所有与数据访问相关的调用委托给持久层。例如，ListBookAction定义如下：

public class ListBookAction extends Action {

    private BookDAO dao = new BookDAO();

    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {

        // Retrieve all the books
        List<Book> books = dao.findAll();

        // Save the result set
        request.setAttribute("books", books);

        // Forward to the view
        return mapping.findForward("booklist");
    }

}

BookDAO对象需要访问EntityManager实例才能执行任何操作。鉴于EntityManger不是线程安全的，我引入了一个名为BookUnitSession的辅助类，它将EntityManager封装在ThreadLocal变量中：

public class BookUnitSession {

    private static EntityManagerFactory emf = Persistence.createEntityManagerFactory("BookStoreUnit");
    private static final ThreadLocal<EntityManager> tl = new ThreadLocal<EntityManager>();

    public static EntityManager getEntityManager() {
        EntityManager em = tl.get();

        if (em == null) {
            em = emf.createEntityManager();
            tl.set(em);
        }
        return em;
    }

}

一切似乎都有效，但我仍有一些担忧。即：

这个解决方案最好吗？这种情况下最好的做法是什么？
我仍然需要明确地关闭EntityManager和EntityManagerFactory。我该怎么办？

由于

Answer 1

在过去的几天里，我设计了一个可能的解决方案。我试图用BookUnitSession类构建的实际上是EntityManagerHelper类：

public class EntityManagerHelper {

    private static final EntityManagerFactory emf; 
    private static final ThreadLocal<EntityManager> threadLocal;

    static {
        emf = Persistence.createEntityManagerFactory("BookStoreUnit");      
        threadLocal = new ThreadLocal<EntityManager>();
    }

    public static EntityManager getEntityManager() {
        EntityManager em = threadLocal.get();

        if (em == null) {
            em = emf.createEntityManager();
            threadLocal.set(em);
        }
        return em;
    }

    public static void closeEntityManager() {
        EntityManager em = threadLocal.get();
        if (em != null) {
            em.close();
            threadLocal.set(null);
        }
    }

    public static void closeEntityManagerFactory() {
        emf.close();
    }

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

    public static void rollback() {
        getEntityManager().getTransaction().rollback();
    }

    public static void commit() {
        getEntityManager().getTransaction().commit();
    } 
}

这样的类确保每个线程（即每个请求）将获得自己的EntityManager实例。因此，每个DAO对象都可以通过调用EntityManager

来获取正确的EntityManagerHelper.getEntityManager()实例

根据每个请求的会话模式，每个请求必须打开和关闭自己的EntityManager实例，该实例将负责封装事务中所需的工作单元。这可以通过实施为ServletFilter：

的拦截过滤器来完成

public class EntityManagerInterceptor implements Filter {

    @Override
    public void destroy() {}

    @Override
    public void init(FilterConfig fc) throws ServletException {}

    @Override
    public void doFilter(ServletRequest req, ServletResponse res,
            FilterChain chain) throws IOException, ServletException {

            try {
                EntityManagerHelper.beginTransaction();
                chain.doFilter(req, res);
                EntityManagerHelper.commit();
            } catch (RuntimeException e) {

                if ( EntityManagerHelper.getEntityManager() != null && EntityManagerHelper.getEntityManager().isOpen()) 
                    EntityManagerHelper.rollback();
                throw e;

            } finally {
                EntityManagerHelper.closeEntityManager();
            }
    }
}

这种方法还允许View（例如，JSP页面）获取实体的字段，即使它们已被延迟初始化（View模式中的Open Session）。在JSE环境中，当servlet容器关闭时，需要显式关闭EntityManagerFactory。这可以通过使用ServletContextListener对象来完成：

public class EntityManagerFactoryListener implements ServletContextListener {

    @Override
    public void contextDestroyed(ServletContextEvent e) {
        EntityManagerHelper.closeEntityManagerFactory();
    }

    @Override
    public void contextInitialized(ServletContextEvent e) {}

}

web.xml部署描述符：

<listener>
  <description>EntityManagerFactory Listener</description>
  <listener-class>package.EntityManagerFactoryListener</listener-class>
</listener>

<filter>
  <filter-name>interceptor</filter-name>
  <filter-class>package.EntityManagerInterceptor</filter-class>
</filter>

<filter-mapping>
  <filter-name>interceptor</filter-name>
  <url-pattern>*.do</url-pattern>
</filter-mapping>

Answer 2

我在Github中创建的

ScopedEntityManager辅助工具使用了类似的技术。我没有选择请求过滤器，而是选择了ServletRequestListener进行生命周期管理。另外，我没有使用threadlocal，因为如果没有仔细编程，他们就会习惯在J2EE容器中发生内存泄漏。 Tomcat确实有一些技巧可以解决某些人为错误。

在JSE中使用JPA的EntityManager ThreadLocal模式

2 个答案: