客户拜访管理
1 什么是客户拜访
（1）客户：与公司有业务往来的
（2）用户：可以使用系统的人
2 用户和客户关系
（1）用户和客户之间是拜访的关系
（2）用户 和 客户 是 多对多关系
** 一个用户可以拜访多个客户，一个客户可以被多个用户拜访
（3）多对多建表：
– 创建第三张表，使用外键维护关系
3 多对多配置
（1）缺陷：第三张表只有两个字段（两个id值）
4 把多对多拆分成两个一对多实现
（1）用户、客户、拜访
（2）用户 和 拜访是一对多
（3）客户和拜访是一对多
配置用户和客户关系
(传统多对多中 是不需要创建中间实体类的 而是在配置文件中 相互表示 然后自动建中间表 这里因为要在中间表中增加额外的属性值，所以不使用之前的方式，创建中间实体类的同时，增加一些其他属性（拜访地址，拜访内容等等），同时使该实体类和user和customer互相表示，即把多对多 拆分为两个一对多，客户和拜访 一对多 ， 用户和拜访 一对多 配置时 类比这客户、联系人的关系 一对多 进行配置)
第一步 创建三个实体类
第二步 实体类之间互相表示
（1）用户和拜访一对多
– 在用户实体类表示所有拜访记录，使用set集合
– 在拜访实体类里面表示所属用户，使用对象
（2）客户和拜访一对多
– 在客户实体类表示所有拜访记录，使用set集合
– 在拜访实体类表示所属客户，使用对象
第三步 配置映射关系
（1）拜访实体类visit 基本属性配置
（2）用户和拜访一对多
– 在用户映射文件中表示所有拜访记录，使用set标签
– 在拜访映射文件中表示所属用户
（3）客户和拜访一对多
– 客户映射文件中表示所有拜访
– 在拜访映射文件中表示所属客户
最后把映射配置文件在核心配置文件中做引入
代码实践截图：
拜访实体类visit
user实体类
customer实体类
visit.hbm.xml
user.hbm.xml
customer.hbm.xml
在核心配置文件中引入映射文件之后，启动服务器 然后自动建表
总结：在多对多映射配置中，推荐使用此方式，因为中间表中一般都不只是两个外键组成的，还拥有自己的私有属性，传统的简单多对多配置只有两个外键，而这里将多对多拆分成了两个一对多来进行配置，配置的时候可以类比多对一(联系人和客户)的思路进行配置
visit和user（多对一） visit和customer(多对一)
—————————————————————————————-
添加页面：
<TABLE cellSpacing=0 cellPadding=0 width="98%" border=0>
<TBODY>
<TR>
<TD width=15 background=${pageContext.request.contextPath }/images/new_022.jpg><IMG
src="${pageContext.request.contextPath }/images/new_022.jpg" border=0></TD>
<TD vAlign=top width="100%" bgColor=#ffffff>
<TABLE cellSpacing=0 cellPadding=5 width="100%" border=0>
<TR>
<TD class=manageHead>当前位置：客户拜访管理 > 添加拜访</TD>
</TR>
<TR>
<TD height=2></TD>
</TR>
</TABLE>
<TABLE cellSpacing=0 cellPadding=5 border=0>
<tr>
<td>客户：</td>
<!-- 应该用下拉列表显示所有的客户 而不是让用户输入 所有就需要在到达该页面之前在域对象中保存所有客户的记录 用于在这里显示 -->
<td colspan="3">
<!--<input type="text" name="custId" style="WIDTH: 180px"/>
-->
<select name="customer.cid">
<c:forEach items="${listCustomer}" var="customer">
<option value="${customer.cid}">${customer.custName}</option>
</c:forEach>
</select>
</td>
</tr> <tr>
<td>用户：</td>
<!-- 应该用下拉列表显示所有的客户 而不是让用户输入 所有就需要在到达该页面之前在域对象中保存所有客户的记录 用于在这里显示 -->
<td colspan="3">
<!--<input type="text" name="custId" style="WIDTH: 180px"/>
-->
<select name="user.id">
<c:forEach items="${listUser}" var="user">
<option value="${user.id}">${user.name}</option>
</c:forEach>
</select>
</td>
</tr> <TR>
<td>拜访地址：</td>
<td>
<INPUT class=textbox id=sChannel2
style="WIDTH: 180px" maxLength=50 name="vaddress">
</td>
<td>拜访内容：</td>
<td>
<INPUT class=textbox id=sChannel2
style="WIDTH: 180px" maxLength=50 name="vcontent">
</td>
</TR> <tr>
<td rowspan=2>
<INPUT class=button id=sButton2 type=submit
value="保存 " name=sButton2>
</td>
</tr>
</TABLE>
运行界面：
在action中使用模型驱动
点击提交数据库中就保存了一条记录：
操作和一对多都一样，只是配置关系时 需要把多对多 拆分为两个一对多
————————————————————————————
抽取BaseDao
内容介绍
1 代码review
2 抽取basedao代码重构方式
（1）在dao层，做操作最基本crud操作
（2）做crud操作时候，调用hibernate模板的方法都一样
（3）不同的是参数不同，
比如操作客户，传递客户对象，比如操作联系人，传递联系人对象
（4）抽取basedao，减少dao层大量重复的代码
3 使用反射+泛型实现抽取
（1）反射得到类的.class文件内容
– 得到类Class方式
— Class.forName(…)
— 类名.class
— 对象.getClass() ;
this.getClass() ;
— getClass方法是Object类的方法
（2）泛型术语
List<User> :
– <> ：读成 typeof
– List<User> ：整体部分读成 参数化类型
– <User> ： <>中的User，读成 实际类型参数
具体实现
1 创建basedao接口，使用泛型方式
在接口里面定义操作的方法curd方法
2 创建BaseDao接口实现类
3 在真正功能的接口，继承basedao接口
（1）把实现crud操作的方法去掉了
4 让真正功能的实现类继承BaseDao实现类
（1）在真正的实现类，不需要继承hibernateDaoSupport，因为baseDaoImpl类继承了hibernateDaoSupport 所以不需要重复继承，所以customerdaoimpl对象中仍然需要注入sessionfactory对象
5 上面操作实现基本功能，有两个查询没有实现(需要得到当前操作的对象才能实现，比如findAll查询的时候，需要传递查询的实体类名，而这些操作需要在父类basedaoimpl的构造函数中进行 )
（1）根据id查询，返回对象
（2）查询所有
6 当customerdaoimpl实现类的对象创建的时候，父类的构造执行，即先执行basedaoimpl的构造方法，在这个方法中需要得到操作类的名称，结束之后才会调用custoemrdaoimpl类的构造方法
（1）在BaseDaoImpl的构造方法中得到传递对象的class
（2）得到BaseDaoImpl泛型里面Customer的class
7 具体实现
（1）得到运行类的class
（2）得到customerdaoimpl父类内容
（3）得到父类的参数化类型
（4）获取实际类型参数
（5）代码实现
private Class clazzType;
public BaseDaoImpl() {
//1 获取当前运行对象的class
//比如运行customerDao实现类，得到customerDao实现类class
Class clazz = this.getClass();
//2 获取运行类的父类的参数化类型BaseDaoImpl<Customer> 现在customerdaoimpl的父类是basedaoimpl 因为该类继承了basedaoimpl
Type type = clazz.getGenericSuperclass();
//3 转换成子接口ParameterizedType
ParameterizedType ptype = (ParameterizedType) type;
//4 获取实际类型参数
//比如 Map<key,value>
Type[] types = ptype.getActualTypeArguments();
//5 把Type变成class
Class clazzParameter = (Class) types[0];
this.clazzType = clazzParameter;
}
注意hql语句中，from后面是需要空格的
———————————————-
代码实现，以customer为例
这里只有customerdaoimpl类继承了basedaoimpl 代码的执行顺序是：在创建custoemrdoaimpl对象之前，因为该类继承了basedaoimpl ，则，basedaoimpl就是customerdaoimpl的父类，那么在创建customerdaoimpl对象的时候，会先执行basedaoimpl
类的构造方法，然后才执行customerdaoimpl类的构造方法，可通过反射方式，在父类的构造方法中得到当前运行的类的名称
basedao接口：
package org.dao; import java.util.List; public interface BaseDao<T> {
//修改
public void update(T t);
//添加
public void add(T t);
//删除
public void delete(T t);
//查找所有
public List<T> findAll();
//根据id值 进行查找 一条记录
public T findOne(int id);
}
basedaoimpl:
package org.dao; import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List; import org.model.Customer;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport; public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T>{
//这里只抽取最基本的方法 即增删改查
private Class classType=null;
public BaseDaoImpl() {
super();
//得到当前运行类的Class
16 Class clazz=this.getClass();
17 //得到运行类 的父类参数化类型 例如当前运行类是customer CustomerDaoImpl extends BaseDaoImpl<Customer>
18 //那么basedaoimpl是customerdaoimpl的父类， 最终得到的结果就是BaseDaoImpl<Customer>
19 Type type=clazz.getGenericSuperclass();
20 //强转 子接口
21 ParameterizedType ptype=(ParameterizedType) type;
22 //使用子接口中的方法 得到实际类型参数 即<>中的内容
23 Type[] types=ptype.getActualTypeArguments();
24 Class clazzParameter=(Class) types[0];
this.classType=clazzParameter;
} public void add(T t) {
this.getHibernateTemplate().save(t);
} public void delete(T t) {
this.getHibernateTemplate().delete(t);
} public void update(T t) {
this.getHibernateTemplate().update(t);
} public List<T> findAll() {//classType
//"from Customer"
return (List<T>)this.getHibernateTemplate().find("from "+classType.getSimpleName());
}
public T findOne(int id) {
//(Customer.class,id)
return (T) this.getHibernateTemplate().get(classType, id);
} }
customerdao:
package org.dao; import java.util.List; import org.model.Customer;
//接口之间也可以进行继承
public interface CustomerDao extends BaseDao<Customer>{//因为在basedao中已经存在了增删改查的方法，所以这里注释掉自己定义的方法
//T 真正实体类的名称 这里是customer
//void add(Customer customer); //List<Customer> findAll(); //Customer findOne(int id); //void delete(Customer c); //void update(Customer customer); int findCount(); List<Customer> findPage(int begin, int pageSize); List<Customer> findCondition(Customer customer); }
customerdaoimpl:
package org.dao; import java.util.List; import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;
import org.model.Customer;
import org.springframework.orm.hibernate5.support.HibernateDaoSupport;
//该类继承HibernateDaoSupport类 不需要注入HibernateTemplate对象了 只用在配置文件中注入sessionfactory对象
//而做basedao抽取的时候 需要继承baseDao的实现类 因为该实现类继承了hibernateDaoSupport 所以这里就
//不需c复继承了 但是在spring配置文件中 CustomerDaoImpl中还是需要注入sessionfactory类的
//因为该类虽然没有直接继承hibernateDaoSupport 但是因为basedaoimpl继承了 本类又继承了 basedaoimpl
//所以这个类就继承了hibernateDaoSupport
//另外在继承basedaoimpl时 需要明确泛型的类型 把泛型替换为具体的对象类型
public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao { // public CustomerDaoImpl() {
// super();
// System.out.println("customerdaoimpl......构造函数执行");
// }
/*
* 因为在basedaoimpl中已经做了抽取 把基本的增删改查操作都做了实现 而且继承了basedaoimpl 直接在service中调用即可
*
*
//向t_customer表中保存一条记录
public void add(Customer customer) {
//得到模板对象 使用方法进行数据的保存
this.getHibernateTemplate().save(customer);
}
//查询t_customer表中的所有记录
public List<Customer> findAll() {
// TODO Auto-generated method stub
return (List<Customer>) this.getHibernateTemplate().find("from Customer");
}
//根据id 查询对象
public Customer findOne(int id) {
// TODO Auto-generated method stub
return this.getHibernateTemplate().get(Customer.class,id);
}
//删除对象
public void delete(Customer c) {
// TODO Auto-generated method stub
this.getHibernateTemplate().delete(c);
}
//修改操作
public void update(Customer customer) {
// TODO Auto-generated method stub
this.getHibernateTemplate().update(customer);
}
*/
//查询总的记录数
public int findCount() {
// TODO Auto-generated method stub
//使用模板中的find方法来完成查询总记录数 查询出来的不是一个个的对象的集合
//而是一个数值 但是该方法反回的的是一个list集合 所以仍然需要使用list集合进行接收
List<Object>list=(List<Object>) this.getHibernateTemplate().find("select count(*) from Customer");
//从list中把值得到
if(list!=null&&list.size()!=0){
//变成int类型
Object obj=list.get(0);
//直接变是不行的 需要先变成Long型（long的包装类） 在转为int性
Long lobj=(Long) obj;
int count=lobj.intValue();
return count;
}
return 0;
}
//分页操作
public List<Customer> findPage(int begin, int pageSize) {
// TODO Auto-generated method stub
//创建离线DetachedCriteria对象 指明是对那个实体类进行操作
DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class);
//第一个参数是离线对象 第二个 ：起始位置 第三个 每页的大小(记录数)
List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria,begin,pageSize);
return list;
}
//条件查询 输入的内容不为空
public List<Customer> findCondition(Customer customer) {
// TODO Auto-generated method stub
//第一种方式：
// SessionFactory sessionFactory=this.getHibernateTemplate().getSessionFactory();//得到sessionfactory对象
// Session session=sessionFactory.getCurrentSession();//得到session 这里的session对象和web阶段的HttpSession不是同一个概念
// Query query=session.createQuery("from Customer where custName like ?");
// query.setParameter(0,customer.getCustName());
// List<Customer> list=query.list(); //第二种方式： 单一条件查询的时候 这种比较简单 但是多条件查询的时候 使用第三中方式最简单
// List<Customer> list=(List<Customer>) this.getHibernateTemplate().find("from Customer where custName like ?","%"+customer.getCustName()+"%"); //第三种方式：
//创建离线对象，表示对那个实体类进行操作
DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class);
//设置对实体类中的那个属性进行条件查询 如果对多个字段进行条件查询 那么只需要调用add方法即可
criteria.add(Restrictions.like("custName","%"+customer.getCustName()+"%"));
//调用模板中的方法 得到集合
List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria);
return list;
} }
如果该实现类不注入sessionfactory，那么就会报错：
service中部分代码：因为继承了basedaoimpl 所以这里调用的方法 都是basedaoimpl中的方法
// 添加客户
public void add(Customer customer) {
// TODO Auto-generated method stub
customerDao.add(customer);
} // 客户列表
public List<Customer> findAll() {
// TODO Auto-generated method stub
return customerDao.findAll();
} // 根据id查询对象
public Customer findOne(int id) {
return customerDao.findOne(id);
} // 删除对象
public void delete(Customer c) {
// TODO Auto-generated method stub
customerDao.delete(c);
} // 修改操作
public void update(Customer customer) {
// TODO Auto-generated method stub
customerDao.update(customer);
}
这样统一的功能就由basedao进行实现，继承basedaoimpl类，就可以使用基本的增删改查操作，从而减少了大量的代码
——————————–
当customerdaoimpl和linkmandaoimpl两个实现类继承basedaoimpl的时候，服务器的启动截图：
说明创建对象之前会先调用父类中的构造方法，而在核心配置文件中是先引入的customer.xml文件，后引入的linkman.xml文件，所以加载配置文件的顺序就是先customer.xml后linkman.xml,所以在服务器启动的时候 先创建customer对象，后创建linkman对象，而创建这两个对象之前都会先调用其父类的构造方法。
———————————————————————————–
多条件组合查询
第一种 写底层hibernate代码实现
第二种 使用hibernate模板里面find方法实现
- 写hql语句实现
//多条件组合查询
@SuppressWarnings("all")
public List<Customer> findMoreCondition(Customer customer) {
//使用hibernate模板里面find方法实现
//拼接hql语句
String hql = "from Customer where 1=1 ";
//创建list集合，如果值不为空，把值设置到list里面
List<Object> p = new ArrayList<Object>();
//判断条件值是否为空，如果不为空拼接hql语句
if(customer.getCustName()!=null && !"".equals(customer.getCustName())) {
//拼接hql
hql += " and custName=?";
//把值设置到list里面
p.add(customer.getCustName());
}
if(customer.getCustLevel()!=null && !"".equals(customer.getCustLevel())) {
hql += " and custLevel=?";
p.add(customer.getCustLevel());
}
if(customer.getCustSource()!=null && !"".equals(customer.getCustSource())) {
hql += " and custSource=?";
p.add(customer.getCustSource());
}
// System.out.println("hql: "+hql);
// System.out.println("list: "+p);
return (List<Customer>) this.getHibernateTemplate().find(hql, p.toArray());
}
第三种 使用离线对象和hibernate模板里面方法
第二种方式代码实现：
表单提交之后，把数据提交给action，因为action中使用了模型驱动，所以可以得到数据，如果没有输入任何东西，那么action中封装的模型对象中的数据就是为null,但是这不影响数据的检索，
action中直接调用service中的方法，service调用dao中的方法
下面是daoimpl中的方法：
//多条件查询
public List<Customer> moreCondition(Customer customer) {
List<Object> p=new ArrayList<Object>();
String hql="from Customer where 1=1";
//下面进行验证是否为空 并拼接hql字符串
if(customer.getCustName()!=null&&!"".equals(customer.getCustName())){
hql=hql+" and custName=?";
p.add(customer.getCustName());//如果值不为空 就把该值设置进list集合中
}
if(customer.getCustLevel()!=null&&!"".equals(customer.getCustLevel())){
hql += " and custLevel=?";
p.add(customer.getCustLevel());
}
if(customer.getCustSource()!=null&&!"".equals(customer.getCustSource())){
hql += " and custSource=?";
p.add(customer.getCustSource());
}
//第二个参数是一个可变参数（就是一种数组的形式） 需要把list集合变为数组
return (List<Customer>) this.getHibernateTemplate().find(hql,p.toArray());
}
在这方法中，我们采用的是字符串拼接的方式来构造hql语句，因为用户可能什么也没用输入，所以就需要判断是否为空，如果为空，那么if语句就都没有执行，所以hql语句就变为：
String hql="from Customer where 1=1";
当然是查询所有了
所以通过字符串拼接的方式，就能够完成多条件的查询操作第三种方式代码实现：
daoimpl代码：
//多条件查询
public List<Customer> moreCondition(Customer customer) {
//第二种方式：使用离线对象
DetachedCriteria c=DetachedCriteria.forClass(Customer.class);//DetachedCriteria离线查询
//仍然需要验证是否为空 如果不为空 就像离线对象中插入限制条件 并且设置值
if(customer.getCustName()!=null&&!"".equals(customer.getCustName())){
c.add(Restrictions.eq("custName",customer.getCustName()));
}
if(customer.getCustLevel()!=null&&!"".equals(customer.getCustLevel())){
c.add(Restrictions.eq("custLevel",customer.getCustLevel()));
}
if(customer.getCustSource()!=null&&!"".equals(customer.getCustSource())){
c.add(Restrictions.eq("custSource",customer.getCustSource()));
}
//调用方法 执行查询
return (List<Customer>) this.getHibernateTemplate().findByCriteria(c);
}
DetachedCriteria--离线查询
Restrictions--条件限制
