继承DaoSupport实现自己的DAO基类（三）

项目使用的hibernate基于hibernate3.5和spring3.0.5

配置自己的DAO基类

package com.juttec.core.dao;

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

import org.apache.commons.lang3.StringUtils;
import org.hibernate.Criteria;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Criterion;
import org.hibernate.metadata.ClassMetadata;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.support.DaoSupport;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
import org.springframework.util.Assert;

import com.juttec.common.util.XLogger;
import com.juttec.core.exception.InvalidDataException;
import com.juttec.core.exception.InvalidParamException;

public abstract class HibernateDao<T, PK extends Serializable> extends DaoSupport
{
    private Class<T> entityClass;
    private SessionFactory sessionFactory = null;
    private HibernateTemplate hibernateTemplate;

    public Class<T> getEntityClass()
    {
        return this.entityClass;
    }

    private SessionFactory getSessionFactory()
    {
        if (this.sessionFactory != null) return this.sessionFactory;

        if (getHibernateTemplate() != null) {
            return getHibernateTemplate().getSessionFactory();
        }
        return null;
    }

    public void setSessionFactory(SessionFactory sessFactory)
    {
        this.sessionFactory = sessFactory;

        if ((getHibernateTemplate() == null) || (sessFactory != getHibernateTemplate().getSessionFactory()))
        {
            HibernateTemplate hibTemplate = createHibernateTemplate(sessFactory);
            setHibernateTemplate(hibTemplate);
        }
    }

    public HibernateDao()
    {
        this.entityClass = ReflectionUtils.getSuperClassGenricType(getClass());
    }

    protected final void checkDaoConfig()
    {
        if (getHibernateTemplate() == null)
            throw new IllegalArgumentException("'sessionFactory' or 'hibernateTemplate' is required");
    }

    public void update(T entity)
    {
        Assert.notNull(entity, "entity不能为空");

        getHibernateTemplate().update(entity);
        this.logger.debug("update entity:" + entity);
    }

    public void flush()
    {
        getHibernateTemplate().flush();
    }

    public void clear()
    {
        getHibernateTemplate().clear();
    }

    public void save(T entity) {
        Assert.notNull(entity, "entity不能为空");
        getHibernateTemplate().save(entity);
        this.logger.debug("saveObj entity: " + entity);
    }

    public void saveOrUpdate(T entity)
    {
        Assert.notNull(entity, "entity不能为空");

        getHibernateTemplate().saveOrUpdate(entity);
        this.logger.debug("save entity: {}" + entity);
    }

    public void delete(T entity)
    {
        Assert.notNull(entity, "entity不能为空");

        getHibernateTemplate().delete(entity);
        this.logger.debug("delete entity:" + entity);
    }

    public void delete(PK id)
    {
        Assert.notNull(id, "id不能为空");
        delete(get(id));
        this.logger.debug("delete entity:" + this.entityClass.getSimpleName() + ", id:" + id);
    }

    public T get(PK id)
    {
        try
        {
            Assert.notNull(id, "id不能为空");
        } catch (AssertionError e) {
            return null;
        }

        Object o = getHibernateTemplate().get(this.entityClass, id);
        if (o == null) return null;
        return (T) o;
    }

    public T load(PK id)
    {
        try
        {
            Assert.notNull(id, "id不能为空");
        } catch (AssertionError e) {
            return null;
        }

        Object o = getHibernateTemplate().load(this.entityClass, id);
        if (o == null) return null;
        return (T) o;
    }

    //  public List<T> get(Collection<PK> ids)
    //  {
   
    //    return find(new Criterion[] { Restrictions.in(getIdName(), ids) });
    //  }

    public Object merge(T t)
    {
        if (t == null) return null;

        return getHibernateTemplate().merge(t);
    }

    public List<T> getAllObjects()
    {
        return getAllObjects("", true);
    }

    public List<T> getAllObjects(String orderByProperty, boolean isAsc)
    {
        String hql = "from " + getEntityClass().getName();

        if (orderByProperty.length() > 0) {
            hql = hql + " order by " + orderByProperty;
            if (isAsc)
                hql = hql + " ASC";
            else {
                hql = hql + " DESC";
            }
        }

        return retrieve(hql);
    }

    public List<T> findBy(String properName, Object propValue)
    {
        Assert.hasText(properName, "properName不能为空");

        String hql = "from " + getEntityClass().getName() + " where " + properName + " = :val";
        List results = getHibernateTemplate().findByNamedParam(hql, "val", propValue);
        return results;
    }

    public T findUniqueResult(String properName, Object propValue)
    {
        Assert.hasText(properName, "propertyName不能为空");

        String hql = "from " + getEntityClass().getName() + " where " + properName + " = :val";
        List results = getHibernateTemplate().findByNamedParam(hql, "val", propValue);
        if (results == null) {
            return null;
        }
        if (results.size() > 0) {
            return (T) results.get(0);
        }
        return null;
    }

    public <X> List<X> find(String hql, Object[] values)
    {
        return getHibernateTemplate().find(hql, values);
    }

    public <X> List<X> find(String hql, Map<String, ?> keyValueMap)
    {
        if (keyValueMap == null) {
            return find(hql, new Object[0]);
        }
        Object[] keyObjs = keyValueMap.keySet().toArray();
        String[] keys = new String[keyValueMap.size()];
        Object[] values = new Object[keyValueMap.size()];

        int i = 0;
        for (Object key : keyObjs) {
            keys[i] = ((String)key);
            values[i] = keyValueMap.get((String)key);
            i++;
        }

        return getHibernateTemplate().findByNamedParam(hql, keys, values);
    }

    public <X> X findUniqueResult(String hql, Object[] values)
    {
        List results = find(hql, values);
        if (results == null) {
            return null;
        }
        if (results.size() > 0) {
            return (X) results.get(0);
        }
        return null;
    }

    public <X> X findUnique(String hql, Map<String, ?> valueMap)
    {
        List results = find(hql, valueMap);
        if (results == null) {
            return null;
        }
        if (results.size() > 0) {
            return (X) results.get(0);
        }
        return null;
    }

    /**
     * 
     * 执行sql更新
     * <pre>
     * 执行sql更新
     * </pre>
     * 
     * @author 李晓东
     * @param sql
     */
    public void execSqlUpdate(String sql) throws Exception {
        getSession().createSQLQuery(sql).executeUpdate();

    }


    @SuppressWarnings("unchecked")
    public int execUpdate(final String hql, final Object[] values)
    {
        Integer result = (Integer)getHibernateTemplate().executeWithNativeSession(
                new HibernateCallback() {
                    public Object doInHibernate(Session session) {
                        Query query = session.createQuery(hql);
                        if (values != null) {
                            for (int i = 0; i < values.length; i++) {
                                query.setParameter(i, values[i]);
                            }
                        }
                        return Integer.valueOf(query.executeUpdate());
                    }
                });
        return result.intValue();
    }


    public int execUpdate(final String hql, final Map<String, ?> values)
    {
        Integer result = (Integer)getHibernateTemplate().executeWithNativeSession(new HibernateCallback() {
            public Object doInHibernate(Session session) {
                Query query = HibernateDao.this.createQuery(session, hql, values);

                return Integer.valueOf(query.executeUpdate());
            }
        });
        return result.intValue();
    }