公共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接口的实现类便可。