generichibernatedao.java

这是本人开发过程项目的一部分

package com.zdvictory.platform.common;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.Example;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Example.PropertySelector;
import org.hibernate.transform.Transformers;
import org.hibernate.type.Type;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;

import com.zdvictory.platform.common.PageObject;
import com.zdvictory.platform.util.GenUtil;

/**
 * <p>Title: Co-Up网络协同办公平台</p>
 *
 * <p>Description:通用DAO接口实现类,扩展该类以实现常用的CURD操作</p>
 *
 * <p>Copyright: Copyright (c) 2007</p>
 *
 * <p>Company: zdvictory</p>
 *
 * @author jerrie
 * @version 1.0
 */
public abstract class GenericHibernateDAO<T, PK extends Serializable> implements
        GenericDAO<T , PK> {

    /**HibernateTemplate对象,可以通过该对象操作数据库记录*/
    private HibernateTemplate hibernateTemplate;

    /**泛型类,代表实际应用中的POJO*/
    private Class<T> type;

    public GenericHibernateDAO() {
        this.type = (Class<T>) ((ParameterizedType) (this.getClass().
                getGenericSuperclass()))
                .getActualTypeArguments()[0];
    }

    /**
     * 创建一个新的实例对象到数据库
     * @param newInstance T  泛型类,即实际应用中的POJO
     * @return boolean
     */
    public boolean create(T newInstance) throws Exception {
        boolean bFlag = false;
        getHibernateTemplate().save(newInstance);
        bFlag = true;
        return bFlag;
    }
    /**
     *
     * Description：创建一个新的实例对象到数据库
     * @param newInstance T  泛型类,即实际应用中的POJO
     * @return 返回 Object 主键值
     * @throws Exception
     */
    public Object createObject(T newInstance) throws Exception{
    	 Object t = getHibernateTemplate().save(newInstance);
    	 return t;
    }

    /**
     * 从数据库删除实例
     * @param condition String  删除操作的条件
     * @return boolean
     */
    public boolean delete(String condition) throws Exception {
        boolean bFlag = false;
        String SQL = "delete from " + this.type.getSimpleName() + " " +
                     condition;
        getSession().createQuery(SQL).executeUpdate();
        bFlag = true;
        return bFlag;
    }

    /**
     * 根据ID和类型从数据库删除数据
     * @param id PK 主键
     * @param T 泛型类,代表实际应用中的POJO
     * @return T
     * @throws Exception
     */
    public T delete(PK id, Class<T> T) throws Exception {
        T obj = null;
        obj = (T)this.hibernateTemplate.get(T, id);
        this.hibernateTemplate.delete(obj);
        return obj;
    }

    /**
     *
     * @param model T 泛型类,代表实际应用中的POJO
     * @return boolean 返回布尔类型变量
     * @throws Exception
     */
    public boolean delete(T model) throws Exception {
        boolean bFlag = false;
        this.hibernateTemplate.delete(model);
        bFlag = true;
        return bFlag;
    }

    /**
     * 从数据库删除实例
     * @param SQL String
     * @return boolean
     */
    public boolean deleteBySQL(String SQL) throws Exception {
        boolean bFlag = false;
        getSession().createSQLQuery(SQL).executeUpdate();
        bFlag = true;
        return bFlag;
    }


    /**
     * 更新一个实例对象到数据库
     * @param newInstance T 泛型类,即实际应用中的POJO
     * @return boolean
     */
    public boolean update(T newInstance) throws Exception {
        boolean bFlag = false;
        getHibernateTemplate().update(newInstance);
        bFlag = true;
        return bFlag;
    }

    /**
     * 根据主键查找实例对象
     * @param id PK  主键
     * @return T
     */
    public T findById(PK id) throws Exception {
        return (T) getHibernateTemplate().get(type, id);
    }

    /**
     * 根据SQL查找实例对象
     * @param SQL String
     * @return T
     */
    public T findBySQL(String SQL) throws Exception {
        Object object = null;
        Query query = getSession().createSQLQuery(SQL).
                      setResultTransformer(
                              Transformers.ALIAS_TO_ENTITY_MAP);
        Iterator iter = query.list().iterator();
        while (iter.hasNext()) {
            object = this.type.newInstance();
            GenUtil.copyProperty(object, (Map) iter.next());
        }
        return (T) object;
    }

    /**
     * 查找所有实例对象
     * @return List
     */

    public List<T> findAll() throws Exception {
        String HQL = "from " + this.type.getSimpleName();
        return (List<T>) getHibernateTemplate().find(HQL);
    }

    /**
     * 根据SQL查找对象列表
     * @param SQL String
     * @return List
     */
    public List<T> findAllBySQL(String SQL) throws Exception {
        Query query = getSession().createSQLQuery(SQL).
                      setResultTransformer(
                              Transformers.ALIAS_TO_ENTITY_MAP);
        Iterator iter = query.list().iterator();
        List list = new ArrayList();
        while (iter.hasNext()) {
            Object object = this.type.newInstance();
            GenUtil.copyProperty(object, (Map) iter.next());
            list.add(object);
        }
        return list;
    }

    /**
     * 分页显示实例对象信息列表,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition String  查询条件
     * @return List  实例对象列表
     */
    public List<T> findPageList(int currentPage, int pageSize, String condition) throws
            Exception {
        String HQL = "from " + this.type.getSimpleName();
        if (condition != null)
            HQL += condition;
        Query query = getSession().createQuery(HQL);
        query.setFirstResult((currentPage - 1) * pageSize);
        query.setMaxResults(pageSize);
        return (List<T>) query.list();
    }

    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @return List  实例对象列表
     */
    public List findPageListBySQL(int currentPage, int pageSize, String SQL) throws
            Exception {
        Query query = getSession().createSQLQuery(SQL).
                      setResultTransformer(
                              Transformers.ALIAS_TO_ENTITY_MAP);
        query.setFirstResult((currentPage - 1) * pageSize);
        query.setMaxResults(pageSize);
        Iterator iter = query.list().iterator();
        List list = new ArrayList();
        while (iter.hasNext()) {
            Object object = this.type.newInstance();
            GenUtil.copyProperty(object, (Map) iter.next());
            list.add(object);
        }
        return list;
    }

    /**
     * 分页显示实例对象信息列表,该方法对所有操作有效
     * @param currentPage int 当前页码
     * @param pageSize int 每页显示的记录数
     * @param SQL String SQL语句
     * @param values Object[] SQL语句的条件参数
     * @return List
     */
    public List findPageListBySQL(final int currentPage, final int pageSize,
                                  final String SQL, final Object[] values) throws
            Exception {
        HibernateCallback selectCallback = new HibernateCallback() {
            public Object doInHibernate(Session session) {
                Query query = session.createQuery(SQL).setResultTransformer(
                        Transformers.ALIAS_TO_ENTITY_MAP);
                if (values != null) {
                    for (int i = 0; i < values.length; i++) {
                        query.setParameter(i, values[i]);
                    }
                }
                return query.setFirstResult((currentPage - 1) * pageSize)
                        .setMaxResults(pageSize).list();
            }
        };
        return (List) getHibernateTemplate().executeFind(selectCallback);
    }


    public List findListByHQL(String hql, Object[] values) throws Exception {
        return this.getHibernateTemplate().find(hql, values);
    }


    /**
     * 查找分页信息,该方法只针对单表操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param condition String  查询条件
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfo(int currentPage, int pageSize,
                                 String condition) throws Exception {
        PageInfo pageInfo = new PageInfo();
        String SQL = "select count(*) as amount from " +
                     this.type.getSimpleName();
        if (condition != null)
            SQL += condition;
        Query query = getSession().createQuery(SQL);
        List<Long> list = (List<Long>) query.list();
        pageInfo.setCurrentPage(currentPage);
        pageInfo.setPageSize(pageSize);
        pageInfo.setTotalCount(((Long) list.get(0)).intValue());
        return pageInfo;
    }

    /**
     * 查找分页信息,该方法对所有操作有效
     * @param currentPage int  当前页码
     * @param pageSize int  每页显示的记录数
     * @param SQL String  SQL语句
     * @return PageInfo  分页信息对象
     */
    public PageInfo findPageInfoBySQL(int currentPage, int pageSize,
                                      String SQL) throws Exception {
        PageInfo pageInfo = new PageInfo();
        Query query = getSession().createSQLQuery(SQL);
        List<BigDecimal> list = (List<BigDecimal>) query.list();
        pageInfo.setCurrentPage(currentPage);
        pageInfo.setPageSize(pageSize);
        BigDecimal dec = (BigDecimal) list.get(0);
        pageInfo.setTotalCount(dec.intValue());
        return pageInfo;
    }

    /**
     * 通过hibernate的Example查找
     * zeng weishao
     */
    public PageObject<T> findPageByExample(int currentPage, int pageSize,
                                           T model) throws Exception {
        if (model == null)
            throw new IllegalArgumentException("model不能为null值！");
        final int curpage = currentPage;
        final int size = pageSize;
        final T m = model;
        final boolean isPage = (curpage > -1 && size > -1);
        HibernateCallback action = new HibernateCallback() {

            public Object doInHibernate(Session session) throws
                    HibernateException, SQLException {
                PageObject<T> po = new PageObject<T>();

                Criteria criteria = session.createCriteria(type);
                final PropertySelector ps = new PropertySelector() {

                    public boolean include(Object value, String name, Type type) {
                        return (value != null &&
                                !value.toString().trim().equals("")) &&
                                (!(value instanceof Number) ||
                                 ((Number) value).longValue() < 1);
                    }

                    private Object readResolve() {
                        return this;
                    }
                };
                Example example = Example.create(m).ignoreCase().enableLike(
                        MatchMode.ANYWHERE).setPropertySelector(ps);
                criteria.add(example);
                if (isPage)
                    criteria.setFirstResult((curpage - 1) *
                            size).setMaxResults(size);
                List<T> data = (List<T>) criteria.list();
                po.setData(data);

                if (isPage) {
                    Criteria countCriteria = session.createCriteria(type);
                    countCriteria.setProjection(Projections.rowCount());
                    countCriteria.add(example);
                    List<Integer> counts = (List<Integer>) countCriteria.list();
                    PageInfo pageInfo = new PageInfo();
                    pageInfo.setCurrentPage(curpage);
                    pageInfo.setPageSize(size);
                    pageInfo.setTotalCount(counts.get(0));
                    po.setPageInfo(pageInfo);
                }

                return po;
            }

        };
        return (PageObject<T>)this.getHibernateTemplate().execute(action);
    }

    /**
     * 设置HibernateTemplate对象
     * @param hibernateTemplate HibernateTemplate
     */
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

    /**
     * 获取HibernateTemplate对象
     * @return HibernateTemplate
     */
    public HibernateTemplate getHibernateTemplate() {
        return hibernateTemplate;
    }

    /**
     * 获取Hibernate的Session对象
     * @return Session
     */
    protected Session getSession() {
        Session session = getHibernateTemplate().getSessionFactory().
                          getCurrentSession();
        return session;
    }
}