我們可以使用JPA outsite EJB容器嗎？

我的應用程序在JBoss 4.0.5 GA運行，需要升級到在JBoss 7.1.1最終運行。 JSF頁面中的所有內容，業務邏輯都解決了。但是我們面臨的關鍵是：在jboss4中的舊應用程序中，我們不使用JPA，而是直接使用hibernate會話。並通過threadlocal管理hibernate會話。我們應用了3層應用程序：[UI後端bean]調用[EJB執行業務]調用[DAO對象通過hibernate會話獲取和更新數據庫]。
這個設計已經壞了，現在！因爲我們無法找到像hibernate會話那樣在threadlocal中管理實體管理器的方式。可能我是個壞開發者。
請幫幫我，我們可以使用jpa outsite EJB。我想要一個名爲DAOUtil的靜態類來管理和獲取實體管理器，同時執行保存或更新數據。任何人都會告訴我如何做到這一點。 datasource（xa-datasource）怎麼樣，怎麼樣persistent.xml？
這是類訪問到DATABSE：我們可以使用JPA outsite EJB容器嗎？

package com.esilicon.dao.hibernate; 

import java.io.Serializable; 
import java.sql.Connection; 
import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 

import javax.persistence.EntityManager; 

import org.hibernate.Criteria; 
import org.hibernate.HibernateException; 
import org.hibernate.Query; 
import org.hibernate.SQLQuery; 
import org.hibernate.Session; 
import org.hibernate.Transaction; 
import org.hibernate.criterion.Example; 
import org.hibernate.engine.spi.SessionImplementor; 

public class HibernateDAOSession extends DAOSession { 


    /** 
    * @associates Class 
    */ 
    private static HashMap implementations = new HashMap(); 
    private Session hibernateSession; 
    // private Transaction tx; 
    private boolean JTAEnvironment; 
    private EntityManager em; 

    public HibernateDAOSession(Session s, boolean jta) { 
     this.hibernateSession = s; 
     this.JTAEnvironment = false; 
    } 

    public HibernateDAOSession(Session s, boolean jta, EntityManager em) { 
     this.hibernateSession = s; 
     this.JTAEnvironment = false; 
     this.em = em; 
    } 

    public BaseDAO getDAO(Class clazz) { 
     try { 
      Class impl = getImplementationClass(clazz); 
      HibernateDAO dao = (HibernateDAO) impl.newInstance(); 
      // dao.setCurrentSession(this.getHibernateSession()); 
      // session will be provided by DAOUtil from a threadlocal variable. 
      return dao; 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
     return null; 
    } 

    private Class getImplementationClass(Class clazz) throws ClassNotFoundException { 
     Class impl = (Class) implementations.get(clazz); 
     if (impl == null) { 
      String name = clazz.getName(); 
      String packageName = clazz.getPackage().getName(); 
      String className = name.substring(packageName.length() + 1); 
      StringBuffer implClassName = new StringBuffer(packageName).append(".hibernate.").append(className).append("DAO"); 
      impl = Class.forName(implClassName.toString()); 
      implementations.put(clazz, impl); 
     } 
     return impl; 
    } 

    public void close() { 
     if (this.JTAEnvironment) 
      return; 
     try { 
      Session s = this.getHibernateSession(); 
      if (s != null && s.isOpen() && this.getEm() != null) { 
       s.close(); 
       this.setHibernateSession(null); 
       /* 
       * this.getEm().clear(); this.getEm().close(); 
       */ 
       this.setEm(null); 
      } 

      /*if (s != null && s.isOpen()) { 

      }*/ 

     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 

    } 

    public void beginTransaction() { 
     try { 
      /*if (getHibernateSession().getTransaction() == null) { 
       this.getHibernateSession().beginTransaction(); 
      } else if (!getHibernateSession().getTransaction().isActive() || getHibernateSession().getTransaction().wasCommitted()) { 
       getHibernateSession().getTransaction().begin(); 
      }*/ 
      //return getHibernateSession().getTransaction(); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public void commit() { 
     //this.getHibernateSession().flush(); 
     /*if (this.JTAEnvironment) 
      return; 
     try { 
      if (getHibernateSession().getTransaction() != null && getHibernateSession().getTransaction().isActive()) { 
       getHibernateSession().getTransaction().commit(); 
      } 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      rollback(); 
      throw new HibernateDAOException(e); 
     }*/ 
    } 

    public void rollback() { 
     // TODO: should we allow rolback on session in JTAEnvironment ? 
     /*try { 
      if (getHibernateSession().getTransaction() != null && getHibernateSession().getTransaction().isActive()) { 
       getHibernateSession().getTransaction().rollback(); 
      } 
     } finally { 
      // close(); 
      DAOUtil.closeEntityManager(); 
     }*/ 
    } 

    public Transaction getCurrentTransaction() { 
     return getHibernateSession().getTransaction(); 
    } 

    private Query prepareQuery(Query q, int start, int count, Map params) { 
     String[] namedParams = q.getNamedParameters(); 
     if (namedParams.length > 0 && params != null) { 
      for (int i = 0; i < namedParams.length; i++) { 
       if (params.get(namedParams[i]) instanceof java.util.List) { 
        q.setParameterList(namedParams[i], (List) params.get(namedParams[i])); 
       } else { 
        q.setParameter(namedParams[i], params.get(namedParams[i])); 
       } 
      } 
     } 
     if (start >= 0) 
      q.setFirstResult(start); 
     if (count >= 0) 
      q.setMaxResults(count); 
     return q; 
    } 

    public Session getHibernateSession() { 
     return hibernateSession; 
    } 

    public void setHibernateSession(Session hibernateSession) { 
     this.hibernateSession = hibernateSession; 
    } 

    public Object update(Object o) { 
     try { 
      this.getHibernateSession().update(o); 
      return o; 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 

    } 

    public boolean isJTAEnvironment() { 
     return JTAEnvironment; 
    } 

    public Object save(Object o) { 
     try { 
      this.getHibernateSession().save(o); 
      return o; 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public Object saveOrUpdate(Object o) { 
     try { 
      this.getHibernateSession().saveOrUpdate(o); 
      return o; 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 

    } 

    public void flush() { 
     try { 
      this.getHibernateSession().flush(); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public Object refresh(Object o) { 
     try { 
      this.getHibernateSession().refresh(o); 
      return o; 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public void evict(Object o) { 
     try { 
      this.getHibernateSession().evict(o); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public Object query(String query, Map map, boolean uniqueResult) { 
     try { 
      Query q = this.getHibernateSession().createQuery(query); 
      prepareParameters(q, map); 
      if (uniqueResult) { 
       return q.uniqueResult(); 
      } else { 
       return q.list(); 
      } 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    private void prepareParameters(Query q, Map map) { 
     if (map == null) 
      return; 
     String[] params = q.getNamedParameters(); 
     for (int i = 0; i < params.length; i++) { 
      if (map.get(params[i]) instanceof java.util.List) { 
       q.setParameterList(params[i], (List) map.get(params[i])); 
      } else { 
       q.setParameter(params[i], map.get(params[i])); 
      } 
     } 
    } 

    public Connection getConnection() { 
     SessionImplementor si = (SessionImplementor) getHibernateSession(); 
     //this.connection = si.connection(); 
     return si.connection(); 
    } 

    public void delete(Object o) { 
     try { 
      this.getHibernateSession().delete(o); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 

    } 

    public Object findUniqueEntityByID(Class entityClass, Serializable id) { 
     try { 
      return this.getHibernateSession().get(entityClass, id); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public int executeUpdate(String query, Map params) { 
     try { 
      Query q = this.getHibernateSession().createQuery(query); 
      prepareParameters(q, params); 
      return q.executeUpdate(); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public Object nativeQuery(String query, Map map, boolean uniqueResult) { 
     try { 
      Query q = this.getHibernateSession().createSQLQuery(query); 
      prepareParameters(q, map); 
      if (uniqueResult) { 
       return q.uniqueResult(); 
      } else { 
       return q.list(); 
      } 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public int executeNativeUpdate(String query, Map params) { 
     try { 
      Query q = this.getHibernateSession().createSQLQuery(query); 
      prepareParameters(q, params); 
      return q.executeUpdate(); 
     } catch (HibernateException e) { 
      e.printStackTrace(); 
      throw new HibernateDAOException(e); 
     } 
    } 

    public EntityManager getEm() { 
     return em; 
    } 

    public void setEm(EntityManager em) { 
     this.em = em; 
    } 

    @Override 
    public Query createQuery(String hqlQuery) { 
     return getHibernateSession().createQuery(hqlQuery); 
    } 

    @Override 
    public SQLQuery createSQLQuery(String nativeQuery) { 
     // TODO Auto-generated method stub 
     return getHibernateSession().createSQLQuery(nativeQuery); 
    } 

    @Override 
    public void disconnect() { 
     // TODO Auto-generated method stub 
     getHibernateSession().disconnect(); 
    } 

    @Override 
    public Object get(Class<?> clazz, Serializable id) { 
     // TODO Auto-generated method stub 
     return getHibernateSession().get(clazz, id); 
    } 

    @Override 
    public Object load(Class<?> clazz, Serializable id) { 
     // TODO Auto-generated method stub 
     return getHibernateSession().load(clazz, id); 
    } 

    @Override 
    public Object merge(Object o) { 
     // TODO Auto-generated method stub 
     return getHibernateSession().merge(o); 
    } 

    @Override 
    public Query getNamedQuery(String nameQuery) { 
     // TODO Auto-generated method stub 
     return getHibernateSession().getNamedQuery(nameQuery); 
    } 
}

類來管理HibernateSessionDAO

package com.esilicon.dao; 

import java.sql.Connection; 
import java.util.HashMap; 
import java.util.Map; 

import javax.naming.InitialContext; 
import javax.sql.DataSource; 

import org.hibernate.Session; 
import org.hibernate.proxy.HibernateProxy; 

import com.esilicon.dao.hibernate.HibernateDAOSession; 
import com.esilicon.util.logging.Logger; 

public class DAOUtil { 
    public static final String PERSISTENT_UNIT = "vms4_jboss7"; 

    static ThreadLocal<DAOSession> threadLocalDAOEntityManager = new ThreadLocal<DAOSession>(); 
    static Logger logger = Logger.getLogger(DAOUtil.class.getName()); 

    public static DAOSession openEntityManager(DAOEntityManagerFactory factory) { 
     DAOSession entityManager = (DAOSession) threadLocalDAOEntityManager.get(); 
     if (entityManager != null && entityManager.isOpen()) { 
      return entityManager; 
     } 
     try { 
      entityManager = factory.getEntityManager(); 
     } catch (Exception e) { 
      // e.printStackTrace(); 
      entityManager = factory.openEntityManager(); 
     } 
     threadLocalDAOEntityManager.set(entityManager); 
     return entityManager; 
    } 

    public static DAOSession openSession(DAOSessionFactory factory) { 

     DAOSession daoSession = (DAOSession) threadLocalDAOEntityManager.get(); 
     if (daoSession != null && daoSession.isOpen()) { 
      return daoSession; 
     } 
     try { 
      threadLocalDAOEntityManager.remove(); 
      daoSession = factory.getSession(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
      daoSession = factory.openSession(); 
     } 
     threadLocalDAOEntityManager.set(daoSession); 
     return daoSession; 
    } 

    public static DAOSession openSession(DAOEntityManagerFactory factory) { 

     return openEntityManager(factory); 
    } 

    public static DAOSession getEntityManager() { 
     DAOSession entityManager = (DAOSession) threadLocalDAOEntityManager.get(); 
     if (entityManager == null || !entityManager.isOpen()) { 
      entityManager = DAOUtil.openEntityManager(DAOEntityManagerFactory.getInstance(null)); 
     } 
     return entityManager; 
    } 

    public static DAOSession getSession() { 
     return getEntityManager(); 
    } 

    public static void closeEntityManager() { 
     DAOSession entityManager = (DAOSession) threadLocalDAOEntityManager.get(); 
     if (entityManager != null) { 
      entityManager.close(); 
      logger.debug("EntityManager Closed for Thread " + Thread.currentThread().getName()); 
      threadLocalDAOEntityManager.remove(); 
     } 
    } 

    public static void closeSession() { 
     closeEntityManager(); 
    } 

    public static void beginTransaction() { 
     DAOSession entityManager = (DAOSession) threadLocalDAOEntityManager.get(); 
     logger.debug("--- BeginTransaction --- Thread " + Thread.currentThread().getName()); 
     if (entityManager == null) { 
      entityManager = openEntityManager(DAOEntityManagerFactory.getInstance(null)); 
     } 
     entityManager.beginTransaction(); 
    } 

    public static void commitTransaction() { 
     DAOSession entityManager = (DAOSession) threadLocalDAOEntityManager.get(); 
     logger.debug("--- CommitTransaction --- Thread " + Thread.currentThread().getName()); 
     entityManager.commit(); 
    } 

    public static void rollbackTransaction() { 
     DAOSession entityManager = (DAOSession) threadLocalDAOEntityManager.get(); 
     if (entityManager != null && entityManager.isOpen()) { 
      entityManager.rollback(); 
     } 
    } 

    public static BaseDAO getDAO(Class clazz) { 
     return getEntityManager().getDAO(clazz); 
    } 

    public static Object narrow(Object proxy) { 

     try { 
      return ((HibernateProxy) proxy).getHibernateLazyInitializer().getImplementation(); 
     } catch (Exception e) { 
      return proxy; // not a proxy 
     } 

    } 

    public static void closeConnection(Connection con) { 
     try { 
      if (con != null && !con.isClosed()) { 
       con.close(); 
      } 
     } catch (Exception ex) { 
      ex.printStackTrace(); 
     } 
    } 

    public static Connection getNonXAConnection() { 
     try { 
      InitialContext context = new InitialContext(); 
      DataSource dataSource = (DataSource) context.lookup(JNDILookup.PURE_CONNECTION_JNDI); 
      return dataSource.getConnection(); 
     } catch (Exception e) { 
      e.printStackTrace(); 
      logger.fatal(e.getMessage(), e.getCause()); 
     } 
     return null; 
    } 
}

來源

2014-11-21 duykaka

你如何管理你的交易？使用UserTransaction或EntityManager的事務？你使用線程本地解決了什麼問題？你是否使用它來初始化Servlet過濾器中的事務+ EntityManager？ – 2014-11-21 10:03:09

你可以看到，我有EntityManager的對象，但我不能使用它，因爲與管理事務有關的錯誤。我必須通過解包hibernate會話來解決這個問題。在我的實現中，如何使用EntityManager而不是HibernateSession？ – duykaka 2014-11-21 10:18:52

看來你正在使用entitymanager管理交易。嘗試從persistence.xml中禁用容器管理事務。見http://tomee.apache.org/jpa-concepts.html信息如何配置持久性單元使用RESOURCE_LOCAL交易 – 2014-11-21 11:33:06

使用依賴注入來注入實體管理器到你的DAO類：

例如：

@PersistenceContext 
private EntityManager entityManager;

來源

2014-11-21 09:33:20 Stefan

DAO類不是一個EJB，只是一個純粹的Java類。但是，如果我可以注入實體管理器，我認爲我不能手動執行保存/更新。 – duykaka 2014-11-21 09:36:36

無論如何，DAO類需要進行管理。你如何創建一個新的實例？只需將該類標記爲：@Singleton（name =「myDaoObject」）。如果你想編寫一個自定義的sql語句，enity管理器擁有諸如persist，remove，find等方法或者createQuery。 DAO中的 – Stefan 2014-11-21 09:40:20

林核心，我有一個命名對象是HibernateSessionDAO，通過theadlocal其管理。我使用的情況下，我從threadlocal得到這個對象。這個對象有屬性作爲EntityManager的，但我不能沒有錯誤堅持：java.sql.SQLException中：通過導致連接不以組織與管理co[email protected]22b4e311 相關.jboss.jca.adapters.jdbc.WrappedConnection.lock（WrappedConnection.java:154）在org.jboss.jca.adapters.jdbc.WrappedConnection.prepareStatement（WrappedConnection.java:394） – duykaka 2014-11-21 09:53:22

我們可以使用JPA outsite EJB容器嗎？

回答

相關問題