cn.easyproject.easycommons.commondao.CommonDAOImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of easycommondao-jpa-hibernate3 Show documentation
Java ORM Common DAO(Data Access Object), eliminate the interface and implements of DAO.
The newest version!
package cn.easyproject.easycommons.commondao;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Query;

import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.ejb.QueryHints;
import org.hibernate.jdbc.Work;
import org.hibernate.transform.Transformers;

import cn.easyproject.easycommons.commondao.util.EasyCriteria;
import cn.easyproject.easycommons.commondao.util.PageBean;
import cn.easyproject.easycommons.commondao.factory.JPAEntityManagerFactory;

/**
 * JPA CommonDAO implement.
 * 
 * 
 * @author Ray
 * @author [email protected]
 * @author easyproject.cn
 * @since 1.0.0
 * 
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class CommonDAOImpl implements CommonDAO {
	@Override
	public void batchUpdateSQL(final String sql, final Object[] values) {
		EntityManager entityManager = JPAEntityManagerFactory.getEntityManager();
		
		entityManager.unwrap(Session.class).doWork(new Work() {
			public void execute(Connection connection) throws SQLException {
				PreparedStatement pstmt = null;
				try {
					connection.setAutoCommit(false);// 手动提交
					pstmt = connection.prepareStatement(sql);// 预编译
					for (int i = 0; i < values.length; i++) {
						pstmt.setObject(1, values[i]);
						pstmt.addBatch();
					}
					pstmt.executeBatch();// 将参数加入到批处理
					connection.commit();// 提交
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					if (pstmt != null) {
						try {
							pstmt.close();
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}
				}
				try {
					if (connection != null && (!connection.isClosed())) {
						connection.close();
					}
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		});
		if (entityManager.isOpen()) {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}

	@Override
	public void batchUpdateSQL(final String sql, final Object[][] values) {
		EntityManager entityManager = JPAEntityManagerFactory.getEntityManager();
		entityManager.unwrap(Session.class).doWork(new Work() {
			public void execute(Connection connection) throws SQLException {
				PreparedStatement pstmt = null;
				try {

					connection.setAutoCommit(false);// 手动提交
					pstmt = connection.prepareStatement(sql);// 预编译

					for (Object[] row : values) {
						for (int i = 0; i < row.length; i++) {
							pstmt.setObject(i + 1, row[i]);
						}
						pstmt.addBatch();
					}
					pstmt.executeBatch();// 将参数加入到批处理
					connection.commit();// 提交
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					if (pstmt != null) {
						try {
							pstmt.close();
						} catch (SQLException e) {
							e.printStackTrace();
						}
					}
				}
				try {
					if (connection != null && (!connection.isClosed())) {
						connection.close();
					}
				} catch (SQLException e) {
					e.printStackTrace();
				}
			}
		});
		if (entityManager.isOpen()) {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}
	/**
	 * CommonDAO 内部方法，获得EntityManager，并开始事务
	 * @return EntityManager
	 */
	private EntityManager beginTransaction(){
		EntityManager entityManager = JPAEntityManagerFactory.getEntityManager();
		entityManager.getTransaction().begin();
		return entityManager;
	}
	/**
	 * CommonDAO 内部方法，关闭EntityManager
	 */
	private void close(){
		 JPAEntityManagerFactory.closeEntityManager();
	}
	/**
	 * CommonDAO 内部方法，提交事务
	 */
	private void commit(EntityManager entityManager){
		entityManager.getTransaction().commit();
	}
	/**
	 * CommonDAO 内部方法，NamedQuery
	 * @param entityManager entityManager
	 * @param name name
	 * @param cacheable cacheable
	 * @param cacheRegion cacheRegion
	 * @param values values
	 * @return Query对象
	 */
	private Query createNamedQuery(EntityManager entityManager,String name, boolean cacheable,String cacheRegion, Map values){
		Query query=entityManager.createNamedQuery(name.trim());
		if(cacheable){
			query.setHint(QueryHints.HINT_CACHEABLE, "true");
			if(cacheRegion!=null&&(!cacheRegion.equals(""))){
				query.setHint(QueryHints.HINT_CACHE_REGION, cacheRegion);
			}
		}
		if(values!=null && values.size()>0) {
			for (Entry e : values.entrySet()) {
				query.setParameter(e.getKey(), e.getValue());
			}
		}
		return query;
	}
	/**
	 * CommonDAO 内部方法, NativeQuery
	 * @param entityManager entityManager
	 * @param sql sql
	 * @param values values
	 * @return Query对象
	 */
	private Query createNativeQuery(EntityManager entityManager,String sql,Class resultClass, boolean mapResult, Map values){
		Query query=null;
		if(resultClass!=null){
			 query=entityManager.createNativeQuery(sql, resultClass);
		}else{
			 query=entityManager.createNativeQuery(sql);
		}
		// 封装为Map结果
		if(mapResult){
			query.unwrap(org.hibernate.Query.class)
			.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
		}
		
		if(values!=null && values.size()>0) {
			for (Entry e : values.entrySet()) {
				query.setParameter(e.getKey(), e.getValue());
			}
		}
		return query;
	}
	
	/**
	 * CommonDAO 内部方法，Query
	 * @param entityManager entityManager
	 * @param jpql jqpl
	 * @param cacheable cacheable
	 * @param cacheRegion cacheRegion
	 * @param values values
	 * @return Query对象
	 */
	private Query createQuery(EntityManager entityManager,String jpql, boolean cacheable,String cacheRegion, Map values){
		Query query=entityManager.createQuery(jpql);
		if(cacheable){
			query.setHint(QueryHints.HINT_CACHEABLE, "true");
			if(cacheRegion!=null&&(!cacheRegion.equals(""))){
				query.setHint(QueryHints.HINT_CACHE_REGION, cacheRegion);
			}
		}
		if(values!=null && values.size()>0) {
			for (Entry e : values.entrySet()) {
				query.setParameter(e.getKey(), e.getValue());
			}
		}
		return query;
	}
	
	
	@Override
	public void delete(Class clazz, Serializable id) {
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		    
		    entityManager.remove( entityManager.find(clazz, id) );
		    
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
	}

	@Override
	public void delete(Object o) {
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		    entityManager.remove( o );
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
	}

	@Override
	public Integer deleteByValues(Class cls, String idFieldName,
			String[] values) {
		int res=0;
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		    	
		    StringBuilder ins=new StringBuilder();
		    ins.append("'");
		    for (String v : values) {
		    	ins.append(v).append("','");
			}

			String jpql = "delete from " + cls.getSimpleName() + " where "
					+ idFieldName + " in(" + ins.substring(0, ins.length()-2) + ")";
			res=entityManager.createQuery(jpql).executeUpdate();
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
		return res;
	}

	@Override
	public void deleteCascadeByValues(Class cls, String fieldName, String[] values) {
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		    	
		    StringBuilder ins=new StringBuilder();
		    ins.append("'");
		    for (String v : values) {
		    	ins.append(v).append("','");
			}
			String jpql = "from " + cls.getSimpleName() + " where "
					+ fieldName + " in(" + ins.substring(0, ins.length()-2) + ")";
			for (Object o : entityManager.createQuery(jpql).getResultList()) {
				entityManager.remove(o);
			}
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
	
		
	}
	
	@Override
	public void evict(Class c) {
		JPAEntityManagerFactory.getEntityManagerFactory().getCache().evict(c);
	}

	@Override
	public void evict(Class c, Serializable id) {
		JPAEntityManagerFactory.getEntityManagerFactory().getCache().evict(c, id);
	}

	@Override
	public void evictAll() {
		JPAEntityManagerFactory.getEntityManagerFactory().getCache().evictAll();
	}
	
	@Override
	public void evictCollectionRegion(String collectionRegion) {
		JPAEntityManagerFactory.getEntityManager().unwrap(Session.class).getSessionFactory().getCache()
		.evictCollectionRegion(collectionRegion);
	}

	@Override
	public void evictCollectionRegion(String collectionRegion, Serializable id) {
		JPAEntityManagerFactory.getEntityManager().unwrap(Session.class).getSessionFactory().getCache()
		.evictCollection(collectionRegion, id);

	}

	@Override
	public void evictQueries() {
		if (null != DEFAULT_QUERY_CACHE_REGION || (!"".equals(DEFAULT_QUERY_CACHE_REGION))) {
			JPAEntityManagerFactory.getEntityManager().unwrap(Session.class).getSessionFactory().getCache()
					.evictQueryRegion(DEFAULT_QUERY_CACHE_REGION);
		} else {
			JPAEntityManagerFactory.getEntityManager().unwrap(Session.class).getSessionFactory().getCache()
					.evictQueryRegions();
		}
	}



	@Override
	public void evictQueries(String queryCacheRegion) {
		JPAEntityManagerFactory.getEntityManager().unwrap(SessionFactory.class).getCache().evictQueryRegion( queryCacheRegion );
	}
	
	@Override
	public List find(String jpql){
		return find(jpql, new HashMap());
	}
	@Override
	public List find(String jpql,EasyCriteria easyCriteria){
		if(easyCriteria!=null){
			return find(jpql+" "+easyCriteria.getCondition(), easyCriteria.getValues());
		}else{
			return find(jpql, new HashMap());
		}
		
	}
	@Override
	public List find(String jpql, Map values) {
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
		    Query q=createQuery(entityManager, jpql, false, null, values);
			List list = q.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
		
	}

	@Override
	public List findAll(Class cls) {
		EntityManager entityManager = null;
		try {
		    entityManager = JPAEntityManagerFactory.getEntityManager();
		    String queryString = "from " + cls.getName();
			List list = entityManager.createQuery(queryString).getResultList();
			initialize(list);
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}
	@Override
	public List findByCache(String jpql){
		return findByCache(jpql, new HashMap());
	}
	@Override
	public List findByCache(String jpql, EasyCriteria easyCriteria){
		
		if(easyCriteria!=null){
			return findByCache(jpql+" "+easyCriteria.getCondition(), easyCriteria.getValues());
		}else{
			return findByCache(jpql, new HashMap());
		}
	}

	@Override
	public List findByCache(String jpql, Map values) {
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
			
			String cacheRegion=null;
			if (null != DEFAULT_QUERY_CACHE_REGION
					|| (!"".equals(DEFAULT_QUERY_CACHE_REGION))) {
				cacheRegion=DEFAULT_QUERY_CACHE_REGION;
			}
		    Query q=createQuery(entityManager, jpql, true, cacheRegion, values);
			List list = q.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}
	@Override
	public List findByCache(String jpql, String queryCacheRegion, EasyCriteria easyCriteria){
		
		if(easyCriteria!=null){
			return findByCache(jpql+" "+easyCriteria.getCondition(), queryCacheRegion, easyCriteria.getValues());
		}else{
			return findByCache(jpql, queryCacheRegion, new HashMap());
		}
	}
	
	@Override
	public List findByCache(String jpql, String queryCacheRegion) {
		return findByCache(jpql, queryCacheRegion, new HashMap());
	}

	@Override
	public List findByCache(String jpql, String queryCacheRegion,
			Map values) {
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
			
		    Query q=createQuery(entityManager, jpql, true, queryCacheRegion, values);
			List list = q.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}
	@Override
	public void findByPage(PageBean pageBean) {
		this.findByPage(pageBean,new HashMap());
	}

	@Override
	public void findByPage(PageBean pageBean, EasyCriteria easyCriteria) {
		if(easyCriteria!=null){
			pageBean.setCondition(easyCriteria.getCondition());
			this.findByPage(pageBean,easyCriteria.getValues());
		}else{
			this.findByPage(pageBean);
		}
	}
	
	@Override
	public void findByPage(PageBean pageBean, Map values) {
		String jpql = pageBean.getAutoQuery();
		
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
		    Query query=createQuery(entityManager, jpql, false, null, values);
		    query.setFirstResult(pageBean.getRowStart());
			query.setMaxResults(pageBean.getRowsPerPage());
			
			pageBean.setData(query.getResultList());
			
			String queryString = "";
			int end = jpql.length();
			if (jpql.indexOf("order by") != -1) {
				end = jpql.indexOf("order by");
			}
			if (jpql.toUpperCase().indexOf("SELECT") != -1) {
				int i = jpql.toUpperCase()
						.indexOf("FROM");
				queryString = "select count(1) " + jpql.substring(i, end);
			} else {
				queryString = "select count(1) " + jpql.substring(0, end);
			}
			
			// 去掉ORDER BY 的部分
			int j = queryString.toUpperCase().lastIndexOf("ORDER");
			if (j != -1) {
				queryString = queryString.substring(0, j);
			}
			Query cquery = createQuery(entityManager, queryString, false, null, values);
			
			int maxRow = (Integer.valueOf(cquery.getSingleResult().toString())).intValue();
			pageBean.setRowsCount(maxRow);
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
		
		
		
	}

	@Override
	public List findByProperty(Class cls, String propertyName, Object value) {
			String queryString = "from " + cls.getName()
					+ " model where model." + propertyName + "= :propetyName";
			Map values=new HashMap();
			values.put("propetyName", value);
			
			return find(queryString, values);
	}

	@Override
	public List findByPropertyIgnoreCase(Class cls, String propertyName,
			String value) {
			String queryString = "from " + cls.getName()
					+ " model where lower(model." + propertyName + ")= :propetyName";
			
			Map values=new HashMap();
			values.put("propetyName", value);
			return find(queryString, values);
	}
	
	
	@Override
	public List findBySQL(String sql, Class resultClass) {
		return findBySQL(sql, resultClass, new HashMap());
	}
	
	
	@Override
	public List findBySQL(String sql, Class resultClass, EasyCriteria easyCriteria) {
		if(easyCriteria!=null){
			return findBySQL(sql+" "+easyCriteria.getCondition(), resultClass, easyCriteria.getValues());
		}else{
			return findBySQL(sql, resultClass, new HashMap());
		}
	}
	
	@Override
	public List findBySQL(String sql, Class resultClass, Map values) {
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
			
		    Query q=createNativeQuery(entityManager, sql, resultClass, false, values);
			List list = q.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	
	}
	@Override
	public List findBySQL(String sql) {
			return findBySQL(sql,new HashMap());
	}
	
	@Override
	public List findBySQL(String sql, EasyCriteria easyCriteria) {
		if(easyCriteria!=null){
			return findBySQL(sql+" "+easyCriteria.getCondition(), easyCriteria.getValues());
		}else{
			return findBySQL(sql,new HashMap());
		}
	}
	
	@Override
	public List findBySQL(String sql, Map values) {
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
			
		    Query q=createNativeQuery(entityManager, sql,null,false,values);
			List list = q.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}

	@Override
	public int findCount(String jpql) {
		return findCount(jpql,new HashMap());
	}
	@Override
	public int findCount(String jpql,EasyCriteria easyCriteria) {
		if(easyCriteria!=null){
			return findCount(jpql+" "+easyCriteria.getCondition(), easyCriteria.getValues());
		}else{
			return findCount(jpql,new HashMap());
		}
	}
	@Override
	public int findCount(String jpql, Map values) {

		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
		    Query q=createQuery(entityManager, jpql, false, null, values);
		    return Integer.valueOf(q.getSingleResult().toString());
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
		
	}
	

	public List findMapResultBySQL(String sql){
		return findMapResultBySQL(sql, new HashMap());
	}
	
	
	public List findMapResultBySQL(String sql,EasyCriteria easyCriteria){
		if(easyCriteria!=null){
			return findMapResultBySQL(sql+" "+easyCriteria.getCondition(), easyCriteria.getValues());
		}else{
			return findMapResultBySQL(sql, new HashMap());
		}
	}

	public List findMapResultBySQL(String sql, Map values){
		
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
			
		    Query q=createNativeQuery(entityManager, sql,null,true,values);
			List list = q.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}

	@Override
	public int findMaxPage(String jpql, int rowsPerPage) {
		return (this.findCount(jpql, new HashMap()) - 1) / rowsPerPage + 1;
	}
	
	@Override
	public int findMaxPage(String jpql, int rowsPerPage, EasyCriteria easyCriteria) {
		return (this.findCount(jpql, easyCriteria) - 1) / rowsPerPage + 1;
	}

	@Override
	public int findMaxPage(String jpql, int rowsPerPage, Map values) {
		return (this.findCount(jpql, values) - 1) / rowsPerPage + 1;
	}

	
	@Override
	public List findNamedQuery(String name) {

		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
		    Query q=createNamedQuery(entityManager, name, false, null, new HashMap());
		    return q.getResultList();
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}
	
	@Override
	public List findNamedQuery(String name, Map values) {
		
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
			Query q=createNamedQuery(entityManager, name, false, null, values);
			return q.getResultList();
		} catch (RuntimeException e) {
			throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}


	@Override
	public List findNamedQueryByCache(String name, String queryCacheRegion, Map values) {
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
		    Query q=createNamedQuery(entityManager, name, true, queryCacheRegion, values);
		    return q.getResultList();
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}

	@Override
	public List findTop( String jpql, int topCount){
		return findTop(jpql, topCount, new HashMap());
	}
	
	@Override
	public List findTop( String jpql, int topCount,  EasyCriteria easyCriteria){
		
		if(easyCriteria!=null){
			return findTop(jpql+" "+easyCriteria.getCondition(), topCount, easyCriteria.getValues());
		}else{
			return findTop(jpql, topCount, new HashMap());
		}
	}

	@Override
	public List findTop(String jpql,  int topCount,
			 Map values) {
		
		EntityManager entityManager = null;
		try {
			entityManager = JPAEntityManagerFactory.getEntityManager();
		    Query query=entityManager.createQuery(jpql);
		    query.setFirstResult(0);
		    query.setMaxResults(topCount);
			
			
			if(values!=null && values.size()>0) {
				for (Entry e : values.entrySet()) {
					query.setParameter(e.getKey(), e.getValue());
				}
			}
			
			List list = query.getResultList();
		    return list;
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}

	@Override
	public  T findVal(String jpql) {
		List list = this.find(jpql, new HashMap());
		return (T) (list.size() > 0 ? list.get(0) : null);
	}
	
	@Override
	public  T findVal(String jpql,  EasyCriteria easyCriteria) {
		List list = this.find(jpql, easyCriteria);
		return (T) (list.size() > 0 ? list.get(0) : null);
	}
	@Override
	public  T findVal(String jpql, Map values) {
		List list = this.find(jpql, values);
		return (T) (list.size() > 0 ? list.get(0) : null);
	}

	@Override
	public  T find(Class clazz, Serializable id) {
		EntityManager entityManager = null;
		try {
			entityManager=JPAEntityManagerFactory.getEntityManager();
			return (T) entityManager.find(clazz, id);
		} catch (RuntimeException e) {
		    throw e;
		} finally {
			JPAEntityManagerFactory.closeEntityManager();
		}
	}

	@Override
	public EntityManager getCurrentEntityManager() {
		return JPAEntityManagerFactory.getEntityManager();
	}

	@Override
	public EntityManagerFactory getEntityManagerFactory() {
		return JPAEntityManagerFactory.getEntityManagerFactory();
	}
	@Override
	public void initialize(Object proxy) {
		if (!Hibernate.isInitialized(proxy)) {
			Hibernate.initialize(proxy);
		}
	}

	@Override
	public void initializeDeep(Collection collection) {

		if (collection == null) {
			return;
		}

		for (Object obj : collection) {
			Method[] methods = obj.getClass().getMethods();
			if (methods != null) {
				for (int j = 0; j < methods.length; j++) {
					String getName = methods[j].getName();
					if (getName.length() > 3 && getName.startsWith("get")) {
						String getFix = getName.substring(3, getName.length());
						for (int k = 0; k < methods.length; k++) {
							String setName = methods[k].getName();
							if (setName.length() > 3
									&& setName.startsWith("set")) {
								String setFix = setName.substring(3,
										setName.length());
								if (getFix.equals(setFix)) {
									try {
										Object o = methods[j].invoke(obj,
												new Object[0]);
										if (o != null) {
											Hibernate.initialize(o);
											methods[k].invoke(obj, o);
										}

									} catch (IllegalArgumentException e) {
										e.printStackTrace();
									} catch (IllegalAccessException e) {
										e.printStackTrace();
									} catch (InvocationTargetException e) {
										e.printStackTrace();
									}
								}
							}
						}
					}

				}
			}

		}
	}
	@Override
	public void merge(Object o) {
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		    entityManager.merge(o);
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
	}

	/**
	 * CommonDAO 内部方法，回滚事务
	 */
	private void rollback(EntityManager entityManager){
		EntityTransaction txn=entityManager.getTransaction();
		if ( txn != null && txn.isActive()) txn.rollback();
	}

	@Override
	public void persist(Object o) {
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		    entityManager.persist(o);
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
	}
	
	@Override
	public void updateByJpql(String jpql) {
		updateByJpql(jpql,new HashMap());
	}
	@Override
	public void updateByJpql(String jpql, Map values) {
		EntityManager entityManager = null;
		try {
		    entityManager = beginTransaction();
		   Query query=entityManager.createQuery(jpql);
		   if(values!=null && values.size()>0) {
				for (Entry e : values.entrySet()) {
					query.setParameter(e.getKey(), e.getValue());
				}
			}
		    query.executeUpdate();
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}
	}
	
	@Override
	public void updateBySQL(String sql) {
		updateBySQL(sql, new HashMap());
	}

	@Override
	public void updateBySQL(String sql, Map values) {
		EntityManager entityManager = null;
		try {
		   entityManager = beginTransaction();
		   Query query=entityManager.createNativeQuery(sql);
		   if(values!=null && values.size()>0) {
				for (Entry e : values.entrySet()) {
					query.setParameter(e.getKey(), e.getValue());
				}
			}
		   query.executeUpdate();
		    commit(entityManager);
		} catch (RuntimeException e) {
		    rollback(entityManager);
		    throw e;
		} finally {
			close();
		}

	}
}