EntityManager ThreadLocal-pattern mit JPA in JSE

Während der letzten paar Tage habe ich entwickelt, eine mögliche Lösung. Was ich versucht habe, zu konstruieren, mit der BookUnitSession Klasse war eigentlich die EntityManagerHelper Klasse:

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();
    } 
}

Diese Klasse sorgt dafür, dass jeder thread (d.h., jede Anfrage) erhalten Sie einen eigenen EntityManager Instanz. Folglich, jedes DAO-Objekt können Sie den korrekten EntityManager Instanz durch aufrufen EntityManagerHelper.getEntityManager()

Entsprechend der session-per-request-pattern muss jede Anforderung öffnen und schließen Ihre eigenen EntityManager Instanz, die verantwortlich für die Kapselung der erforderlichen Einheit in einer Transaktion. Diese kann getan werden, durch ein drittes filter implementiert als 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();
            }
    }
}

Erlaubt dieser Ansatz auch die Ansicht (z.B. eine JSP-Seite) an die fetch-Einheit auf den Feldern, auch wenn Sie lazy initialisiert (Open Session in View pattern).
In einer JSE Umfeld der EntityManagerFactory muss explizit geschlossen werden, wenn der servlet-container beendet. Dies kann erfolgen, indem ein ServletContextListener Objekt:

public class EntityManagerFactoryListener implements ServletContextListener {

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

    @Override
    public void contextInitialized(ServletContextEvent e) {}

}

Den web.xml deployment-descriptor:

<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>