联系人管理-抽取通用DAO| CRM客户关系管理系统项目 实战六（Struts2+Spring+Hibernate）解析+源代码

增删改

在Dao层当中这些代码几乎是重复的操作，所以可以抽取一个公共的DAO

第一种方式：通过提供构造方法实现

1、在DAO当中创建BaseDao接口

package com.itzheng.crm.dao;
/*
 * 通用的DAO的接口
 */
public interface BaseDao<T> {//在类上什么T  在类当中所有非静态的成员都可以使用该变量
	public void save(T t);
	public void update(T t);
	public void delete(T t);
}

2、在Impl当中创建BaseDaoImpl实现上述接口

package com.itzheng.crm.dao.impl;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.itzheng.crm.dao.BaseDao;
/*
 * 通用DAO的实现类
 */
public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {
	@Override
	public void save(T t) {
		this.getHibernateTemplate().save(t);
	}
	@Override
	public void update(T t) {
		this.getHibernateTemplate().update(t);
	}
	@Override
	public void delete(T t) {
		this.getHibernateTemplate().delete(t);
	}
}

3、修改客户的DAO和联系人的DAO以及对应的Impl实现类

（1）CustomerDao接口继承BaseDao，删除CustomerDao和与BaseDao当中接口重复的接口

package com.itzheng.crm.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import com.itzheng.crm.domain.Customer;
/*
 * 客户管理的DAO的接口
 */
public interface CustomerDao extends BaseDao<Customer> {
	Integer findCount(DetachedCriteria detachedCriteria);
	List<Customer> findByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize);
	Customer findById(Long cust_id);
	List<Customer> findAll();
}

（2）CustomerDaoImpl接口继承BaseDaoImpl，并且删除与BaseDaoImpl重复的方法，直接使用继承的方法

package com.itzheng.crm.dao.impl;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import org.springframework.transaction.annotation.Transactional;
import com.itzheng.crm.dao.CustomerDao;
import com.itzheng.crm.domain.Customer;
/*
 * 客户管理的DAO的实现类
 */
@Transactional
public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao {

	// DAO 当中带条件的统计个数的方法
	@Override
	public Integer findCount(DetachedCriteria detachedCriteria) {
		// TODO Auto-generated method stub
		// select count(*) from xxx where 条件;
		DetachedCriteria setProjection = detachedCriteria.setProjection(Projections.rowCount());// 设置条件获取个数
		List<Long> list = (List<Long>) this.getHibernateTemplate().findByCriteria(setProjection);
		if (list.size() > 0) {
			return list.get(0).intValue();
		}
		return null;
	}
	@Override
	// DAO 当中分页查询客户的方法
	public List<Customer> findByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize) {
		// TODO Auto-generated method stub
		detachedCriteria.setProjection(null);// 情况detachedCriteria当中的查询方法
		return (List<Customer>) this.getHibernateTemplate().findByCriteria(detachedCriteria, begin, pageSize);
	}
	@Override
	public Customer findById(Long cust_id) {
		// TODO Auto-generated method stub
		return this.getHibernateTemplate().get(Customer.class, cust_id);
	}
	@Override
	// DAO当中查询所有客户的方法
	public List<Customer> findAll() {
		return (List<Customer>) this.getHibernateTemplate().find("from Customer");
	}
}

（3）LinkManDao接口继承BaseDao，删除LinkManDao和与BaseDao当中接口重复的接口

package com.itzheng.crm.dao;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import com.itzheng.crm.domain.LinkMan;
/*
 * 联系人的DAO接口
 */
public interface LinkManDao extends BaseDao<LinkMan> {
	Integer findCount(DetachedCriteria detachedCriteria);
	List<LinkMan> findByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize);
	LinkMan findById(Long lkm_id);
}

（4）LinkManDaoImpl接口继承BaseDaoImpl，并且删除与BaseDaoImpl重复的方法，直接使用继承的方法

package com.itzheng.crm.dao.impl;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.itzheng.crm.dao.LinkManDao;
import com.itzheng.crm.domain.LinkMan;
/*
 * 联系人的DAO的实现类
 */
 @Transactional
public class LinkManDaoImpl extends BaseDaoImpl<LinkMan> implements LinkManDao {
	@Override
	// DAO 当中统计个数的方法
	public Integer findCount(DetachedCriteria detachedCriteria) {
		// TODO Auto-generated method stub
		detachedCriteria.setProjection(Projections.rowCount());// 带条件的查询
		List<Long> list = (List<Long>) this.getHibernateTemplate().findByCriteria(detachedCriteria);

		if (list.size() > 0) {
			return list.get(0).intValue();
		}
		return null;
	}
	@Override
	// DAO 的分页查询
	public List<LinkMan> findByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize) {
		// TODO Auto-generated method stub
		// 情况count语句
		detachedCriteria.setProjection(null);
		// 等到list集合：带条件的查询
		List<LinkMan> list = (List<LinkMan>) this.getHibernateTemplate().findByCriteria(detachedCriteria, begin,
				pageSize);
		return list;
	}
	@Override
	// DAO中根据ID查询联系人的方法
	public LinkMan findById(Long lkm_id) {
		return this.getHibernateTemplate().get(LinkMan.class, lkm_id);
	}
}

第二种方式：通过泛型反射抽取通用DAO

• 如果现在将DAO中的构造方法去掉，将父类的通用的DAO当中提供无参数的构造即可，但是需要在无参数的构造当中需要去获得具体类型的Class才可以-----涉及到泛型的反射了
• 回顾一下泛型
  泛型：通用的类型。

< > :念为  typeof 
List< E > :E被称为类型参数变量 
ArrayList< Integer > :Integer被称为实际类型参数
ArrayList <Integer>:ArrayList <Integer>称为参数化的类型

1、需要做的事情是在父类的构造方法当中获得子类所继承的父类上的参数化类型中的实际类型参数

2、泛型反射的步骤：

第一步：获得daib子类对象的Class

第二步：查看API

Type[] getGenericlnterfaces();//获得带有泛型的接口，可以实现多个接口
Type[] getGenericSuperClass();//获得带有泛型的类，继承一个类		

第三步：获得到带有泛型的父类

第四步：将带有泛型的父类的类型转成具体的参数化的类型

第五步：通过参数化类型中的方法获得实际类型参数

第六步：抽取公共DAO

package com.itzheng.crm.dao.impl;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
import com.itzheng.crm.dao.BaseDao;
/*
 * 通用DAO的实现类
 */
public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T> {

	public Class clazz;

	/*
	 * 不想子类上有构造方法，必须在父类当中提供无参数的构造，在无参构造当中获得具体的Class 具体类型的Class 是参数化类型中的实际类型参数
	 */
	public BaseDaoImpl() {
		// 反射：第一步获得Class
		Class clazz = this.getClass();// 正在被调用的那个类的Class，clazz对应的子类或者LinkManDaoImpl
		// 查看JDK的API
		Type type = clazz.getGenericSuperclass();// 参数化的类型BaseDaoImpl,BaseDaoImpl
		// 得到的Type就是一个参数化的一个类型，将type强转成参数化的类型：
		ParameterizedType pType = (ParameterizedType) type;
		// 通过参数化类型获得实际类型参数：得到一个实际类型参数的数组？因为还有这种可能性Map
		Type[] types = pType.getActualTypeArguments();
		// 只获得第一个实际类型参数即可。
		this.clazz = (Class) types[0];// 得到Customer、Linkman、User
	}
	@Override
	public void save(T t) {
		this.getHibernateTemplate().save(t);
	}
	@Override
	public void update(T t) {
		this.getHibernateTemplate().update(t);
	}
	@Override
	public void delete(T t) {
		this.getHibernateTemplate().delete(t);
	}
	@Override
	public T findById(Serializable id) {
		// TODO Auto-generated method stub
		return (T) this.getHibernateTemplate().get(clazz, id);
	}
	@Override
	public List<T> findAll() {
		// TODO Auto-generated method stub
		return (List<T>) this.getHibernateTemplate().find("from " + clazz.getSimpleName());//注意from后的空格
	}
	@Override
	public Integer findCount(DetachedCriteria detachedCriteria) {

		detachedCriteria.setProjection(Projections.rowCount());
		List<Long> list = (List<Long>) this.getHibernateTemplate().findByCriteria(detachedCriteria);

		if (list.size() > 0) {
			return list.get(0).intValue();
		}
		return null;
	}
	@Override
	public List<T> findByPage(DetachedCriteria detachedCriteria, Integer begin, Integer pageSize) {
		detachedCriteria.setProjection(null);// 情况detachedCriteria当中的查询方法
		return (List<T>) this.getHibernateTemplate().findByCriteria(detachedCriteria, begin, pageSize);
	}
}

第七步：将Customer和LinkMan当中的DAO和Impl置空