JPA SPRING 泛型DAO

关注

最新推荐文章于 2026-09-05 15:34:12 发布 293 阅读 AI 写同款· GEO 优化 ›

package com.core.support.springSupportDao;

import java.io.Serializable;
import java.util.List;

/**
 * 此泛型DAO来自easyjweb
 * 泛型DAO接口
 */
public interface GenericDAO<T> {

	/**
	 * 根据Id查找一个类型为T的对象。
	 * 
	 * @param id
	 *            传入的ID的值
	 * @return 一个类型为T的对象
	 */
	T get(Serializable id);

	/**
	 * 持久化一个对象，该对象类型为T。
	 * 
	 * @param newInstance
	 *            需要持久化的对象，使用JPA标注。
	 */
	<T>T save(T newInstance);

	/**
	 * 根据对象id删除一个对象，该对象类型为T
	 * 
	 * @param id
	 *            需要删除的对象的id。
	 */
	void delete(Serializable id);

	/**
	 * 更新一个对象，主要用于更新一个在persistenceContext之外的一个对象。
	 * 
	 * @param transientObject
	 *            需要更新的对象，该对象不需要在persistenceContext中。
	 */
	void update(T transientObject);

	/**
	 * 根据对象的一个属性名和该属性名对应的值来查找一个对象。
	 * 
	 * @param propertyName
	 *            属性名
	 * @param value
	 *            属性名对应的值
	 * @return 一个对象，如果在该属性名和值的条件下找到多个对象，则抛出一个IllegalStateException异常
	 */
	T getBy(String propertyName, Object value);

	/**
	 * 根据一个查询条件及其参数，还有开始查找的位置和查找的个数来查找任意类型的对象。
	 * 
	 * @param queryName
	 *            命名查询的名字
	 * @param params
	 *            查询条件中的参数的值。使用Object数组，要求顺序和查询条件中的参数位置一致。
	 * @param begin
	 *            开始查询的位置
	 * @param max
	 *            需要查询的对象的个数
	 * @return 一个任意对象的List对象，如果没有查到任何数据，返回一个空的List对象。
	 */
	List executeNamedQuery(final String queryName, final Object[] params,
			final int begin, final int max);

	/**
	 * 根据一个查询条件及其参数，还有开始查找的位置和查找的个数来查找类型为T的对象。
	 * 
	 * @param query
	 *            查询的条件，使用位置参数，对象名统一为obj，查询条件从where后开始。比如：obj.name =
	 *            ?1 and obj.properties = ?2
	 * @param params
	 *            查询条件中的参数的值。使用Object数组，要求顺序和查询条件中的参数位置一致。
	 * @param begin
	 *            开始查询的位置
	 * @param max
	 *            需要查询的对象的个数
	 * @return 一个该类型对象的List对象，如果没有查到任何数据，返回一个空的List对象。
	 */
	List<T> find(String query, Object[] params, int begin, int max);

	/**
	 * 根据一个查询条件及其参数，还有开始查找的位置和查找的个数来查找任意类型的对象。
	 * 
	 * @param query
	 *            完整的查询语句，使用位置参数。比如：select user from User
	 *            user where user.name = ?1 and
	 *            user.properties = ?2
	 * @param params
	 *            查询条件中的参数的值。使用Object数组，要求顺序和查询条件中的参数位置一致。
	 * @param begin
	 *            开始查询的位置
	 * @param max
	 *            需要查询的对象的个数
	 * @return 一个任意对象的List对象，如果没有查到任何数据，返回一个空的List对象。
	 */
	List query(String query, Object[] params, int begin, int max);

	/**
	 * 根据jpql语句执行批量数据更新等操作
	 * 
	 * @param jpql
	 *            需要执行jpql语句
	 * @param params
	 *            语句中附带的参数
	 * @return
	 */
	int batchUpdate(String jpql, Object[] params);

	/**
	 * 执行SQL语句查询
	 * 
	 * @param nnq
	 * @return
	 */
	public List executeNativeNamedQuery(String nnq);

	List executeNativeQuery(final String nnq, final Object[] params,
			final int begin, final int max);

	/**
	 * 执行SQL语句
	 * 
	 * @param nnq
	 * @return
	 */
	public int executeNativeSQL(final String nnq);



/**
 *  flush()
 */
	public void flush();

}

package com.core.support.springSupportDao;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceException;
import javax.persistence.Query;

import org.springframework.orm.jpa.JpaCallback;
import org.springframework.orm.jpa.support.JpaDaoSupport;


import com.core.openstarbbsexception.JPAMothodParameterException;
import com.core.support.springSupportDao.GenericDAO;


public class GenericDAOImpl<T> extends JpaDaoSupport implements GenericDAO<T> {

	private Class<T> clazz;

	public GenericDAOImpl(Class<T> clazz) {
		this.clazz = clazz;
	}

	/*
	 * public void setClazz(Class<T> clazz) { this.clazz = clazz; } public
	 * Class<T> getClazz() { return clazz; }
	 */
	public T get(Serializable id) {
		if (id == null)
			return null;
		return this.getJpaTemplate().find(clazz,id);
	}

	public List<T> find(final String queryStr, final Object[] params,
			final int begin, final int max) {
		// TODO Auto-generated method stub
		List<T> ret = (List<T>) this.getJpaTemplate().execute(
				new JpaCallback() {

					public Object doInJpa(EntityManager em)
							throws PersistenceException {
						// TODO Auto-generated method stub
						String clazzName = clazz.getName();
						StringBuffer sb = new StringBuffer("select obj from ");
						sb.append(clazzName).append(" obj").append(" where ")
								.append(queryStr);
						Query query = em.createQuery(sb.toString());
						int parameterIndex = 1;
						if (params != null && params.length > 0) {
							for (Object obj : params) {
								query.setParameter(parameterIndex++, obj);
							}
						}
						if (begin >= 0 && max > 0) {
							query.setFirstResult(begin);
							query.setMaxResults(max);
						}
						if (begin >= 0 && max > 0) {
							query.setFirstResult(begin);
							query.setMaxResults(max);
						}
						return query.getResultList();
					}
				});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList<T>();
		}
	}

	public List query(final String queryStr, final Object[] params,
			final int begin, final int max) {
		// TODO Auto-generated method stub
		List ret = (List) this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				// TODO Auto-generated method stub
				Query query = em.createQuery(queryStr);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				if (begin >= 0 && max > 0) {
					query.setFirstResult(begin);
					query.setMaxResults(max);
				}
				/*
				 * if (begin >= 0 && max > 0) { query.setFirstResult(begin);
				 * query.setMaxResults(max); }
				 */
				return query.getResultList();
			}
		});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList();
		}
	}

	public void delete(Serializable id){
		if (id == null)
			try {
				throw new JPAMothodParameterException();
			} catch (JPAMothodParameterException e1) {
				e1.printStackTrace();
			}
		T object = this.get(id);
		if (object != null) {
			try {
				this.getJpaTemplate().remove(object);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public <T> T save(T instance) {
		// TODO Auto-generated method stub
		this.getJpaTemplate().persist(instance);
		return instance;
	}

	public T getBy(final String propertyName, final Object value) {
		if (propertyName == null || "".equals(propertyName) || value == null)
			try {
				throw new JPAMothodParameterException();
			} catch (JPAMothodParameterException e) {
				e.printStackTrace();
			}

		// TODO Auto-generated method stub
		List<T> ret = (List<T>) this.getJpaTemplate().execute(
				new JpaCallback() {

					public Object doInJpa(EntityManager em)
							throws PersistenceException {
						// TODO Auto-generated method stub
						String clazzName = clazz.getName();
						StringBuffer sb = new StringBuffer("select obj from ");
						sb.append(clazzName).append(" obj");
						Query query = null;
						if (propertyName != null && value != null) {
							sb.append(" where obj.").append(propertyName)
									.append(" = :value");
							query = em.createQuery(sb.toString()).setParameter(
									"value", value);
						} else {
							query = em.createQuery(sb.toString());
						}
						return query.getResultList();
					}
				});
		if (ret != null && ret.size() == 1) {
			return ret.get(0);
		} else if (ret != null && ret.size() > 1) {
			throw new java.lang.IllegalStateException(
					"worning  --more than one object find!!");
		} else {
			return null;
		}
	}

	public List executeNamedQuery(final String queryName,
			final Object[] params, final int begin, final int max) {
		List ret = (List) this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNamedQuery(queryName);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				if (begin >= 0 && max > 0) {
					query.setFirstResult(begin);
					query.setMaxResults(max);
				}
				return query.getResultList();
			}
		});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList();
		}
	}

	public void update(T instance) {
		// TODO Auto-generated method stub
		this.getJpaTemplate().merge(instance);
	}

	public void setClazzType(Class clazz) {
		this.clazz = clazz;
	}

	public Class getClassType() {
		return this.clazz;
	}

	public List executeNativeNamedQuery(final String nnq) {
		Object ret = this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNativeQuery(nnq);
				return query.getResultList();
			}
		});
		return (List) ret;
	}

	public List executeNativeQuery(final String nnq, final Object[] params,
			final int begin, final int max) {
		List ret = (List) this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNativeQuery(nnq);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				if (begin >= 0 && max > 0) {
					query.setFirstResult(begin);
					query.setMaxResults(max);
				}
				return query.getResultList();
			}
		});
		if (ret != null && ret.size() >= 0) {
			return ret;
		} else {
			return new ArrayList();
		}
	}

	public int executeNativeSQL(final String nnq) {
		Object ret = this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createNativeQuery(nnq);
				return query.executeUpdate();
			}
		});
		return (Integer) ret;
	}

	public int batchUpdate(final String jpql, final Object[] params) {
		Object ret = this.getJpaTemplate().execute(new JpaCallback() {

			public Object doInJpa(EntityManager em) throws PersistenceException {
				Query query = em.createQuery(jpql);
				int parameterIndex = 1;
				if (params != null && params.length > 0) {
					for (Object obj : params) {
						query.setParameter(parameterIndex++, obj);
					}
				}
				return query.executeUpdate();
			}
		});
		return (Integer) ret;
	}


	public void flush() {
		this.getJpaTemplate().execute(new JpaCallback() {
		public Object doInJpa(EntityManager em) throws PersistenceException {
			em.getTransaction().commit();
			return null;
			}
		});
	}
}

package com.core.openstarbbsexception;

/**
 * OpenStarBBS自定义异常。
 * @author treblesoftware
 *
 */
public class JPAMothodParameterException extends Exception {

	public JPAMothodParameterException(){
	super("JPA ORM SUPPORT EXCEPTION:com.core.support.dao.GenericDAOImpl 方法参数为NULL。错误"?);
	}
}