泛型写基础DAO

 

Java代码

/* 

 * Created on 2006-07-xx 

 * 

 */ 

package net.yigoware.common.dao.impl.hibernate;  

 

import java.io.Serializable;  

import java.util.List;  

import java.util.Map;  

 

import net.yigoware.common.dao._BaseDAO;  

import net.yigoware.common.exception.ObjectNotFoundException;  

import net.yigoware.common.util.MyBeanUtils;  

import net.yigoware.common.util.PageInfo;  

 

import org.apache.commons.logging.Log;  

import org.apache.commons.logging.LogFactory;  

import org.hibernate.Criteria;  

import org.hibernate.HibernateException;  

import org.hibernate.Session;  

import org.hibernate.criterion.DetachedCriteria;  

import org.hibernate.criterion.Example;  

import org.hibernate.criterion.Expression;  

import org.hibernate.criterion.Projections;  

import org.springframework.orm.hibernate3.HibernateCallback;  

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  

 

// 这个不能算是渗透哦，没办法，common beanutils没法解决  

// import com.opensymphony.util.BeanUtils;  

 

/** 

 *  

 * @author Yigo 

 * @createdate 2006-07-xx 

 * @param <T> 

 * @param <ID> 

 */ 

abstract public class _BaseDAOImplHibernate<T, ID extends Serializable> extends 

        HibernateDaoSupport implements _BaseDAO<T, ID> {  

    @SuppressWarnings("unused")  

    private static final Log log = LogFactory  

            .getLog(_BaseDAOImplHibernate.class);  

 

    private Class<T> objectClass;  

 

    private _BaseDAOImplHibernate() {  

 

    }  

 

    // protected abstract String getUniqueKeyName();  

 

    /** 

     * @param objectClass 

     */ 

    public _BaseDAOImplHibernate(Class<T> objectClass) {  

        this.objectClass = objectClass;  

    }  

 

    public T findById(ID id) throws ObjectNotFoundException {  

        // log.debug("getting instance with id: " + id);  

        try {  

            T instance = (T) getHibernateTemplate().get(objectClass, id);  

            if (null == instance) {  

                throw new ObjectNotFoundException(objectClass, id);  

            }  

            return instance;  

        } catch (RuntimeException re) {  

            log.error("get failed", re);  

            throw re;  

        }  

    }  

 

    public T findDetailsById(ID id) throws ObjectNotFoundException {  

        T instance = findById(id);  

        getHibernateTemplate().initialize(instance);  

        return instance;  

    }  

 

    public T findByUniqueKey(String keyName, Serializable key)  

            throws ObjectNotFoundException {  

        log.debug("read instance by uniquekey - " + keyName + ": " + key);  

        try {  

            DetachedCriteria detachedCriteria = DetachedCriteria  

                    .forClass(this.objectClass);  

            // log.debug("this.objectClass:" + this.objectClass);  

            detachedCriteria = detachedCriteria  

                    .add(Expression.eq(keyName, key));  

            List<T> list = this.getHibernateTemplate().findByCriteria(  

                    detachedCriteria);  

 

            // log.debug("list:" + list);  

            if (list.size() == 0) {  

                log.error("not found!");  

                throw new ObjectNotFoundException(this.objectClass, key);  

            } else if (list.size() > 1) {  

                // throw new NotUniqueKeyException();  

                // return null;  

                throw new RuntimeException("RuntimeException:NotUniqueKey");  

            } else {  

                return list.get(0);  

            }  

        } catch (RuntimeException e) {  

            log.error("readByUniqueKey failed", e);  

            throw e;  

        }  

    }  

 

    public List<T> findAll() {  

        // log.debug("findAll");  

        try {  

            return this.getHibernateTemplate().loadAll(this.objectClass);  

        } catch (RuntimeException e) {  

            log.error("findAll failed", e);  

            throw e;  

        }  

    }  

 

    /** 

     *  

     */ 

    public List<T> findByExample(Map<String, Object> values) {  

        // log.debug("finding instance by example");  

        try {  

            // List results =  

            // this.getHibernateTemplate().findByExample(instance);  

            // TODO 3.2 不需要不必要的初始化  

            Class<T> c = null;  

            T object = null;  

            try {  

                object = c.newInstance();  

            } catch (InstantiationException e) {  

                // TODO Auto-generated catch block  

                e.printStackTrace();  

            } catch (IllegalAccessException e) {  

                // TODO Auto-generated catch block  

                e.printStackTrace();  

            }  

            for (String key : values.keySet()) {  

                MyBeanUtils.setValue(object, key, values.get(key));  

            }  

            // List<T> results = getSession().createCriteria(  

            // this.objectClass.getName()).add(Example.create(instance))  

            // .list();  

            List<T> results = getSession().createCriteria(  

                    this.objectClass.getName()).add(Example.create(object))  

                    .list();  

            // log.debug("find by example successful, result size: "  

            // + results.size());  

            return results;  

        } catch (RuntimeException re) {  

            log.error("find by example failed", re);  

            throw re;  

        }  

    }  

 

    /** 

     * 根据查询条件查询的方法 

     */ 

    public List<T> findByCriteria(DetachedCriteria criteria) {  

        try {  

            List<T> results = getHibernateTemplate().findByCriteria(criteria);  

            // log.debug(results);  

            return results;  

        } catch (RuntimeException re) {  

            log.error("find by Criteria failed", re);  

            throw re;  

        }  

    }  

 

    /** 

     * 支持分页的查询,测试中 

     */ 

 

    // public List<T> findByCriteria(final DetachedCriteria detachedCriteria,  

    // final int pageSize, final int startIndex) {  

    // try {  

    // List<T> results = getHibernateTemplate().findByCriteria(  

    // detachedCriteria, pageSize, startIndex);  

    // return results;  

    // } catch (RuntimeException re) {  

    // log.error("find by Criteria failed", re);  

    // throw re;  

    // }  

    // }  

    // public List<T> findByCriteria(DetachedCriteria criteria, int firstResult,  

    // int maxResults);  

    public List<T> findByCriteria(final DetachedCriteria criteria,  

            final int pageSize, final int startIndex) {  

        try {  

            List<T> results = getHibernateTemplate().findByCriteria(criteria,  

                    startIndex, pageSize);  

            // log.debug(results);  

            return results;  

        } catch (RuntimeException re) {  

            log.error("find by Criteria failed", re);  

            throw re;  

        }  

    }  

 

    @SuppressWarnings("unchecked")  

    public PageInfo<T> findPageByCriteria(  

            final DetachedCriteria detachedCriteria, final int pageSize,  

            final int startIndex) {  

 

        // int totalCount = getHibernateTemplate()  

        // .findByCriteria(detachedCriteria).size();  

        // List<T> list =  

        // getHibernateTemplate().findByCriteria(detachedCriteria,  

        // startIndex, pageSize);  

        // return new PageInfo<T>(list, totalCount, pageSize, startIndex);  

 

        return (PageInfo<T>) getHibernateTemplate().execute(  

                new HibernateCallback() {  

                    @SuppressWarnings("unchecked")  

                    public PageInfo<T> doInHibernate(Session session)  

                            throws HibernateException {  

                        Criteria criteria = detachedCriteria  

                                .getExecutableCriteria(session);  

 

                        if (startIndex >= 0) {  

                            criteria.setFirstResult(startIndex);  

                        }  

                        if (pageSize > 0) {  

                            criteria.setMaxResults(pageSize);  

                        }  

                        List<T> list = criteria.list();  

 

                        criteria.setFirstResult(0);  

                        criteria.setMaxResults(999);  

 

                        // criteria.setFirstResult(0).setMaxResults(maxResults);  

                        int totalCount = ((Integer) criteria.setProjection(  

                                Projections.rowCount()).uniqueResult())  

                                .intValue();  

                        // criteria.setProjection(null);  

                        // log.debug(totalCount);  

                        // log.debug(pageSize);  

                        // log.debug(startIndex);  

                        PageInfo<T> ps = new PageInfo<T>(list, totalCount,  

                                pageSize, startIndex);  

                        return ps;  

                    }  

                }, true);  

    }  

 

    public void create(T transientInstance) {  

        log.debug("create... transientInstance" + transientInstance);  

        try {  

            getHibernateTemplate().save(transientInstance);  

            // log.debug("create successful");  

        } catch (RuntimeException re) {  

            log.error("create failed", re);  

            throw re;  

        }  

    }  

 

    public void update(ID id, Map<String, Object> values)  

            throws ObjectNotFoundException {  

        // log.debug("update transientInstance");  

        try {  

            T cacheObject = this.findById(id);  

            for (String key : values.keySet()) {  

                MyBeanUtils.setValue(cacheObject, key, values.get(key));  

            }  

            // Map<String, Object> map = MyBeanUtils.getValues(object,  

            // MyBeanUtils   

            // .getPropertyNames(object));  

            // for (String key : map.keySet()) {  

            // Object value = map.get(key);  

            // log.debug("key:::::::::::::::" + key);  

            // log.debug("value:::::::::::::::" + value);  

            // if (null != value) {  

            // MyBeanUtils.setValue(cacheObject, key, value);  

            // }  

            // }  

            this.getHibernateTemplate().update(cacheObject);  

        } catch (RuntimeException re) {  

            log.error("update failed", re);  

            throw re;  

        }  

 

        // 错了！原先的代码错了，DAO层不应该有隐含逻辑：只更新非空属性。  

        // 应该只是update。至于原来的webwork框架会从页面上读取的VO，只有部分属性的问题：  

        // 可以先根据load对象，再在web层把非空属性写入。  

        // 最后传到dao一起update。  

 

        // 再者！原先的ID和ObjectNotFoundException也不需要了，因为在业务层要把vo的值复制过去，就要根据id  

        // load一次了。  

        // 如果这里在load一次，为的是抛出ObjectNotFoundException的话，就load了两次。  

        // 只有对象的id在，就传给hibernate去处理吧。  

 

        // 以上好像又全错了，“更新”的概念可以这样理解：  

        // 给定一个主键ID的对象，更新属性为传来vo的非空。  

        // 而不是直接传一个什么都写好了的PO  

 

        // 他妈的全都错了，最后改成用map类型的values来记录哪些要改的属性，甚至包括设置成null。  

        // 至于这些属性的生产，在web层做，交给webwork，不行！（想了一下，因为没有FormBean）  

 

        // log.debug("update transientInstance");  

        // try {  

        // getHibernateTemplate().save(object);  

        // log.debug("save successful");  

        // } catch (RuntimeException re) {  

        // log.error("save failed", re);  

        // throw re;  

        // }  

    }  

 

    public void delete(ID id) throws ObjectNotFoundException {  

        // log.debug("deleting instance");  

        try {  

            getHibernateTemplate().delete(this.findById(id));  

            // log.debug("delete successful");  

        } catch (RuntimeException re) {  

            log.error("delete failed", re);  

            throw re;  

        }  

    }  

}