(project)利用接口，继承，泛型封装dao数据访问层

一般在建立工程的时候会根据不同的模块的功能来建包，

dao层的代码是用来访问数据库的，它通过操作domain领域层的对象，对数据库进行增删改查的操作。
但是，一般情况下，一个项目有多个表，对应到面向对象的语言就会相应的要创建多个类对象。进而根据对应的对象创建dao层的类，比如，有一个Person对象，如果要操作该对象的话，相应的就要创建PersonDaoImpl这个类来操作person这个对象，对它进行增删改查的操作，就要实现增删改查的代码。但是如果有十个，二十个对象，对应的要创建十个，二十个dao类，同时实现增删改查的代码，那么这样问题就来了，这些代码其实都是有相似的地方的，就是增删改查的代码都是一样的，只不过要操作的对象不一样吧了。
所以我们考虑到可以使用继承，接口的思想来实现代码的重用，抽出一个父类，ICommonDao是一个接口，CommonDaoImpl是该接口的实现。但是，是否要利用Object来指向所有的对象呢，其实这里我们使用的是泛型的技术来实现。
下面是给出的代码

public interface ICommonDao<T> {

    /**
     * <p>保存一条数据 </p>
     */
    void save(T entity);
    /**
     * 
     * <p>保存多条数据 </p>
     */
    void saveConllection(Collection<T> entities);
    /**
     * <p>删除一条数据 </p>
     */
    void deleteById(Serializable id);

    /**
     * <p>根据id数组删除多条数据 </p>
     */
    void deleteByIds(Collection<T> entities);

    /**
     * <p>更新一条数据 </p>
     */
    void update(T entity);
    /**
     * <p>更新一条数据 </p>
     */
    void partialRenewal(List<Object>keys,List<Object>params ,LinkedHashMap<String,Object> conditions);

    /**
     * <p>根据id查看一条数据 </p>
     */
    T findEntityById(Serializable id);

    /**
     * <p>根据id数组查找多条数据 </p><br/>
     * <P>由于数据库里面的实体是不能够重复的，所以这里使用Set集合</p>
     */
    Set<T> findEntitiesByIds(Serializable ... ids);

    /**
     * 
     * <p>查找所有对象</p>
     */
    Collection<T> findAll();
    /**
     * 
     *<p>根据多个条件查询数据</p>
     */
    List<T> findCollectionByConditionNoPage(String condition,
            Object[] params, LinkedHashMap<String, String> hashMap);
    /**
     * 
     *<p>根据多个条件查询数据,并且使用了二级缓存</p>
     */
    List<T> findCollectionByConditionNoPageWithCache(String condition,
            Object[] params, LinkedHashMap<String, String> hashMap);
}

上面定义一个公共的访问数据层的接口，已经抽取出公有的方法。
下面会定义一个类来实现这个接口。
public class CommonDaoImpl extends HibernateDaoSupport implements ICommonDao {

@SuppressWarnings("rawtypes")
private Class entityClass = GenericSuperClass.getActualTypeClass(this.getClass()) ;

//通过依赖注入SessionFactory类，获取hibernateTempalte对象
@Resource(name="sessionFactory")
public final void setSessionFactoryDI(SessionFactory sessionFactory){
    super.setSessionFactory(sessionFactory);
}
/**  
* @Name:        save
* @Description: 保存
* @Author:      张淼洁（作者）
* @Version:     V1.00 （版本号）
* @Create       Date: 2015-06-20 （创建日期）
* @Param        T entity 保存对象
*/
public void save(T entity) {
    this.getHibernateTemplate().save(entity);
}
/**  
* @Name:        deleteById
* @Description: 根据实体的id删除数据
* @Author:      张淼洁（作者）
* @Version:     V1.00 （版本号）
* @Create       Date: 2015-06-20 （创建日期）
* @Param        Serializable id 实体的id字段
*/
public void deleteById(Serializable id) {
    T entity = findEntityById(id);
    this.getHibernateTemplate().delete(entity);

}
/**  
* @Name:        deleteByIds
* @Description: 根据实体的id删除数据
* @Author:      张淼洁（作者）
* @Version:     V1.00 （版本号）
* @Create       Date: 2015-06-20 （创建日期）
* @Param        Serializable id 实体的id字段
*/
public void deleteByIds(Collection<T> entities) {
    this.getHibernateTemplate().deleteAll(entities);

}
public void update(T entity) {

    this.getHibernateTemplate().update(entity);
}

@SuppressWarnings("unchecked")
public T findEntityById(Serializable id) {
    return (T) this.getHibernateTemplate().get(entityClass, id);
}

@SuppressWarnings("unchecked")
public Set<T> findEntitiesByIds(Serializable... ids) {

    Set<T> set = new HashSet<T>();

    for(int id=0; id<ids.length; id++){
        set.add((T)this.getHibernateTemplate().get(entityClass, ids[id]));
    }

    return set;
}

@SuppressWarnings("unchecked")
public Collection<T> findAll() {

    return this.getHibernateTemplate().find("from " + entityClass.getName());
}

/**根据条件进行模糊查询*/
@SuppressWarnings("rawtypes")
@Override
public List<T> findCollectionByConditionNoPage(String condition,
        final Object[] params, LinkedHashMap<String, String> hashMap) {
    /*
     * web界面查询用户的信息，where默认为1=1，这样用户即使不选择任何条件,sql查询也不会出错。
     */
    String hql = "from "+entityClass.getSimpleName() +" o where 1=1";
    String orderby = "";
    //判断是否需要排序
    if(hashMap !=null){

        orderby = orderByHql(hashMap);
    }
    //from SystemGroupUser o where 1=1 and o.name like ? and o.principal = ? order by o.id desc 
    final String finalHql = hql + condition + orderby;
    System.out.println("hql : "+hql);
    @SuppressWarnings({ "unchecked" })
    List<T> list = (List<T>) this.getHibernateTemplate().execute(new HibernateCallback() {

        @Override
        public Object doInHibernate(Session session) throws HibernateException,
                SQLException {
            Query query = session.createQuery(finalHql);
            for(int i=0;params!=null && i<params.length;i++){
                query.setParameter(i, params[i]);
            }
            return  query.list();
        }
    });

    return list;
}
/**通过传递的排序集合语句（Map），获取对应的排序条件（String）*/
/**ORDER BY o.textDate ASC,o.textName DESC*/
private String orderByHql(LinkedHashMap<String, String> hashMap) {
    StringBuffer order = new StringBuffer("");
    if(hashMap != null && !hashMap.isEmpty()){
        order.append(" order by ");
        for(Map.Entry<String, String> map : hashMap.entrySet()){
            order.append(map.getKey()+" "+map.getValue()+" ,");
        }
        order.deleteCharAt(order.length()-1);//去掉最后一个逗号
    }   
    return order.toString();
}
/**  
* @Name: partialRenewal
* @Description: 根据业务层传递的条件和要更新的字段进行局部的更新
* @Author: 张淼洁（作者）
* @Version: V1.00 （版本号）
* @Create Date: 2015-06-20 （创建日期）
* @Param params     要更新的字段
*        condition  条件
*/
@Override
public void partialRenewal(List<Object>keys,List<Object>params ,LinkedHashMap<String,Object> conditions) {
    //字段和实际的值数量要一致
    if(keys.size()!=params.size()){
        throw new RuntimeException("字段的数量和更新的值的数量不一致！");
    }
    //将集合对象转换为数组对象
    Object[]keyArray = keys.toArray();
    Object[]paramArray = params.toArray();
    HibernateUtil hibernateUtil = HibernateUtil.getHibernateUtil();
    Session session = HibernateUtil.getSession();
    //定义查询的语句
    /*String hql = "update "+getTableName4ClassName()+" set ";*/
    String hql = "update "+ hibernateUtil.getTableName4ClassName(entityClass)+" set ";
    //组织查询语句的关键字段
    for(int i=0; i<keys.size(); i++){
        if(i==0){
            hql += ""+keyArray[i]+"= "+modifiedField(paramArray[i]) +"";

        }else{
            hql +=","+keyArray[i]+"= "+modifiedField(paramArray[i]) +"";
        }
    }
    hql +=updateConditionByHql(conditions);
    final String executeSQL = hql;
    System.out.println("hql :"+hql);

    session.beginTransaction();

    SQLQuery query = session.createSQLQuery(executeSQL);
    int result = query.executeUpdate();

    System.out.println("一共有"+result+"条数据被影响！");

    session.getTransaction().commit();
    HibernateUtil.closeSession(session);

    /*return result;    */

}
/**
 * @description:判断表字段的类型，从而是否进行字段的修饰
 * @param type
 * @return
 */
private String modifiedField(Object type){
    if(type == null){
        throw new RuntimeException("type 不能为空!");
    }
    StringBuffer sb = new StringBuffer();
    if(type instanceof String){
        String stringType = (String)type;
        sb.append("'");
        sb.append(stringType);
        sb.append("'");

        return new String(sb);
    }else if(type instanceof Date){
        String dateType =new SimpleDateFormat("yyyy-MM-dd").format(type); 
        sb.append("'");
        System.out.println("date  ==" +dateType);
        sb.append(dateType);
        sb.append("'");

        return new String(sb);
    }
    return type+"";
}
/**
 * @description 组织好更新的条件
 * @param conditions
 * @return
 */
private String updateConditionByHql(LinkedHashMap<String,Object> conditions){
    if(conditions == null || conditions.keySet().size()<=0){
        throw new RuntimeException("更新条件不能为空!");
    }
    StringBuffer sb = new StringBuffer();
    sb.append(" where ");
    for(Map.Entry<String, Object> entry:conditions.entrySet()){
        sb.append(" "+entry.getKey()+"="+modifiedField(entry.getValue()));
    }
    System.out.println("更新条件为 "+new String(sb));
    return new String(sb);
}

@SuppressWarnings("rawtypes")
@Override
public List<T> findCollectionByConditionNoPageWithCache(String condition,
        final Object[] params, LinkedHashMap<String, String> hashMap) {
    /*
     * web界面查询用户的信息，where默认为1=1，这样用户即使不选择任何条件,sql查询也不会出错。
     */
    String hql = "from "+entityClass.getSimpleName() +" o where 1=1";
    String orderby = "";
    //判断是否需要排序
    if(hashMap !=null){

        orderby = orderByHql(hashMap);
    }
    //from SystemGroupUser o where 1=1 and o.name like ? and o.principal = ? order by o.id desc 
    final String finalHql = hql + condition + orderby;
    System.out.println("hql : "+hql);
    @SuppressWarnings({ "unchecked" })
    List<T> list = (List<T>) this.getHibernateTemplate().execute(new HibernateCallback() {

        @Override
        public Object doInHibernate(Session session) throws HibernateException,
                SQLException {
            Query query = session.createQuery(finalHql);
            for(int i=0;params!=null && i<params.length;i++){
                query.setParameter(i, params[i]);
            }
            //启用二级缓存存储数据
            query.setCacheable(true);
            return  query.list();
        }
    });

    return list;
}

@Override
public void saveConllection(Collection<T> entities) {

    this.getHibernateTemplate().saveOrUpdateAll(entities);

}

}

上面的类中有一个行代码是很重要的

      @SuppressWarnings("rawtypes")
       private Class entityClass = GenericSuperClass.getActualTypeClass(this.getClass()) ;

通过一个工具类GenericSuperClass调用getActualTypeClass方法来获取真实的T泛型类型。

public class GenericSuperClass {
    /**
     * 
     * @param clazz
     * @return class对象
     * @description 将泛型转换为class类对象
     */
    @SuppressWarnings("rawtypes")
    public static Class getActualTypeClass(Class clazz){
        ParameterizedType type = (ParameterizedType) clazz.getGenericSuperclass();
        Class entityClass = (Class) type.getActualTypeArguments()[0];
        return entityClass;
    }

}

只要继承这个类并传入泛型类型，最后得到的entityClass对象就是传入的泛型的对象。
//通过依赖注入SessionFactory类，获取hibernateTempalte对象
@Resource(name=”sessionFactory”)
public final void setSessionFactoryDI(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
}
因为CommonDaoImpl继承了HibernateDaoSupport这个类，所以可以使用这个类的对象方法this.getHibernateTemplate()；获取得到hibernate的模板，这是Spring框架提供的。但是，一定要给这个类的属性赋值，所以要使用上面的代码，依赖注入sessionFactory，而这个sessionFactory在spring配置文件里已经定义了。所以在部署启动服务器的时候就会初始化这个sessionFactory然后赋值给给这个属性。

这里的工作已经做的差不多了，后面实现各个对象的访问层类的编写就很容易多了。

public interface IUserDao extends ICommonDao<User>{

    public final static String SERVICE_NAME = "cn.water.cf.dao.impl.UserDaoImpl";

}
@Repository(IUserDao.SERVICE_NAME)
public class UserDaoImpl extends CommonDaoImpl<User> implements IUserDao{

}

从上面的代码可以看出，UserDaoImpl里面什么代码都不用写，因为他已经继承了CommonDaoImpl这个类，并通过泛型User传递进去，所以，直接调用父类的增删改查的方法就可以对数据库中User表的数据进行操作。