公共dao的抽取

package cn.sxx.dao;
 
import java.util.List;
 
import cn.sxx.model.Dep;
import cn.sxx.query.DepQuery;
 
public interface BaseDao<T,Q> {
 
    public void save(T t);
 
    public void update(T t);
 
    public T getObj(Integer id);
 
    public void delete(Integer id);
    public void delete(T t);
 
    public List<T> queryObjByCondition(Q q);
 
}

抽取公共Dao的原因是避免代码的重复。其实现类：

package cn.sxx.dao.impl;
 
import cn.sxx.dao.BaseDao;
import cn.sxx.model.Dep;
import cn.sxx.query.DepQuery;
 
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
 
public abstract class BaseDaoImpl<T,Q> extends HibernateDaoSupport implements BaseDao<T, Q> {
 
    @Override
    public void save(T t) {
        this.getHibernateTemplate().save(t);
    }
 
    @Override
    public void update(T t) {
        this.getHibernateTemplate().update(t);
    }
 
    @Override
    public T getObj(Integer id) {
        Class<?> class1 = getGenericClass();
        return (T) this.getHibernateTemplate().get(class1, id);
    }
 
    @Override
    public void delete(Integer id) {
        T obj = getObj(id);
        this.getHibernateTemplate().delete(obj);
    }
 
    @Override
    public List<T> queryObjByCondition(final Q q) {
        @SuppressWarnings("unchecked")
        List<?> listT =  this.getHibernateTemplate().executeFind(new HibernateCallback<List<T>>() {
            @Override
            public List<T> doInHibernate(Session session) throws HibernateException,SQLException {
                String hql = createHql(q);
                //创建查询对象
                Query query = session.createQuery(hql);
                setDynamicParam(query, q);
                List<T> list = query.list();
                return null;
            }
 
        });
        /*this.getHibernateTemplate().getSessionFactory().getCurrentSession();*/
        return (List<T>) listT;
    }
 
    public Class<?> getGenericClass() {
        //获得泛型的父类
        Type genericSuperclass = this.getClass().getGenericSuperclass();
        //把泛型的父类强制转换成ParameterizedType
        ParameterizedType pt = (ParameterizedType) genericSuperclass;
        //根据ParameterizedType获得当前类的所有泛型的类型
        Type[] actualTypeArguments = pt.getActualTypeArguments();
        //获得T的具体类
        Class<?> clazz = (Class<?>) actualTypeArguments[0];
        return clazz;
    }
 
    @Override
    public void delete(T t) {
        this.getHibernateTemplate().delete(t);
    }
    /**
     * 创建Hql
     * @param q
     * @return
     */
    public abstract String createHql(Q q);
 
    /**
     * 动态设置参数
     * @param query
     * @param q
     */
    public void setDynamicParam(Query query,Q q){
        //获得查询对象的列对象
        Class<? extends Object> class1 = q.getClass();
        //反向解析查询对象，列出查询对象的所有属性
        Field[] declaredFields = class1.getDeclaredFields();
        Field[] superFields = class1.getSuperclass().getDeclaredFields();
        List<Field> list1 = Arrays.asList(declaredFields);
        List<Field> list2 = Arrays.asList(superFields);
        //创建一个大的集合，存储查询对象的属性对象和它父类的属性对象
        List<Field> fList = new ArrayList<Field>();
        fList.addAll(list1);
        fList.addAll(list2);
        //遍历集合
        for(Field f : fList){
            //获得属性的名字
            String fieldName = f.getName();
            Object val = null;
            try {
                f.setAccessible(true);
                //获得属性的值
                val = f.get(q);
            } catch (IllegalArgumentException | IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            if(val != null){
                if(val.getClass() == String.class){
                    query.setParameter(fieldName, "%"+val+"%");
                }else{
                    query.setParameter(fieldName, val);
                }
            }
        }
    }
}

其他的Dao的接口只需要继承抽取的公共Dao接口；其他的Dao实现类继承公共Dao接口的实现类即可。