标签：私有属性 cto -- 映射 rda 大量 ber array name
客户拜访管理
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(多对一)
----------------------------------------------------------------------------------------
添加页面：
1 <TABLE cellSpacing=0 cellPadding=0 width="98%" border=0> 2 <TBODY> 3 <TR> 4 <TD width=15 background=${pageContext.request.contextPath }/images/new_022.jpg><IMG 5 src="${pageContext.request.contextPath }/images/new_022.jpg" border=0></TD> 6 <TD vAlign=top width="100%" bgColor=#ffffff> 7 <TABLE cellSpacing=0 cellPadding=5 width="100%" border=0> 8 <TR> 9 <TD class=manageHead>当前位置：客户拜访管理 > 添加拜访</TD> 10 </TR> 11 <TR> 12 <TD height=2></TD> 13 </TR> 14 </TABLE> 15 <TABLE cellSpacing=0 cellPadding=5 border=0> 16 <tr> 17 <td>客户：</td> 18 <!-- 应该用下拉列表显示所有的客户 而不是让用户输入 所有就需要在到达该页面之前在域对象中保存所有客户的记录 用于在这里显示 --> 19 <td colspan="3"> 20 <!--<input type="text" name="custId" style="WIDTH: 180px"/> 21 --> 22 <select name="customer.cid"> 23 <c:forEach items="${listCustomer}" var="customer"> 24 <option value="${customer.cid}">${customer.custName}</option> 25 </c:forEach> 26 </select> 27 </td> 28 </tr> 29 30 <tr> 31 <td>用户：</td> 32 <!-- 应该用下拉列表显示所有的客户 而不是让用户输入 所有就需要在到达该页面之前在域对象中保存所有客户的记录 用于在这里显示 --> 33 <td colspan="3"> 34 <!--<input type="text" name="custId" style="WIDTH: 180px"/> 35 --> 36 <select name="user.id"> 37 <c:forEach items="${listUser}" var="user"> 38 <option value="${user.id}">${user.name}</option> 39 </c:forEach> 40 </select> 41 </td> 42 </tr> 43 44 <TR> 45 <td>拜访地址：</td> 46 <td> 47 <INPUT class=textbox id=sChannel2 48 style="WIDTH: 180px" maxLength=50 name="vaddress"> 49 </td> 50 <td>拜访内容：</td> 51 <td> 52 <INPUT class=textbox id=sChannel2 53 style="WIDTH: 180px" maxLength=50 name="vcontent"> 54 </td> 55 </TR> 56 57 <tr> 58 <td rowspan=2> 59 <INPUT class=button id=sButton2 type=submit 60 value="保存 " name=sButton2> 61 </td> 62 </tr> 63 </TABLE>
运行界面：
在action中使用模型驱动
点击提交数据库中就保存了一条记录：
操作和一对多都一样，只是配置关系时 需要把多对多 拆分为两个一对多
------------------------------------------------------------------------------------
内容介绍
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接口：
1 package org.dao; 2 3 import java.util.List; 4 5 public interface BaseDao<T> { 6 //修改 7 public void update(T t); 8 //添加 9 public void add(T t); 10 //删除 11 public void delete(T t); 12 //查找所有 13 public List<T> findAll(); 14 //根据id值 进行查找 一条记录 15 public T findOne(int id); 16 }
basedaoimpl:
1 package org.dao; 2 3 import java.lang.reflect.ParameterizedType; 4 import java.lang.reflect.Type; 5 import java.util.List; 6 7 import org.model.Customer; 8 import org.springframework.orm.hibernate5.support.HibernateDaoSupport; 9 10 public class BaseDaoImpl<T> extends HibernateDaoSupport implements BaseDao<T>{ 11 //这里只抽取最基本的方法 即增删改查 12 private Class classType=null; 13 public BaseDaoImpl() { 14 super(); 15 //得到当前运行类的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]; 25 this.classType=clazzParameter; 26 } 27 28 public void add(T t) { 29 this.getHibernateTemplate().save(t); 30 } 31 32 public void delete(T t) { 33 this.getHibernateTemplate().delete(t); 34 } 35 36 public void update(T t) { 37 this.getHibernateTemplate().update(t); 38 } 39 40 public List<T> findAll() {//classType 41 //"from Customer" 42 return (List<T>)this.getHibernateTemplate().find("from "+classType.getSimpleName()); 43 } 44 public T findOne(int id) { 45 //(Customer.class,id) 46 return (T) this.getHibernateTemplate().get(classType, id); 47 } 48 49 }
customerdao:
1 package org.dao; 2 3 import java.util.List; 4 5 import org.model.Customer; 6 //接口之间也可以进行继承 7 public interface CustomerDao extends BaseDao<Customer>{//因为在basedao中已经存在了增删改查的方法，所以这里注释掉自己定义的方法 8 //T 真正实体类的名称 这里是customer 9 //void add(Customer customer); 10 11 //List<Customer> findAll(); 12 13 //Customer findOne(int id); 14 15 //void delete(Customer c); 16 17 //void update(Customer customer); 18 19 int findCount(); 20 21 List<Customer> findPage(int begin, int pageSize); 22 23 List<Customer> findCondition(Customer customer); 24 25 26 27 }
customerdaoimpl:
1 package org.dao; 2 3 import java.util.List; 4 5 import org.hibernate.Query; 6 import org.hibernate.Session; 7 import org.hibernate.SessionFactory; 8 import org.hibernate.criterion.DetachedCriteria; 9 import org.hibernate.criterion.Restrictions; 10 import org.model.Customer; 11 import org.springframework.orm.hibernate5.support.HibernateDaoSupport; 12 //该类继承HibernateDaoSupport类 不需要注入HibernateTemplate对象了 只用在配置文件中注入sessionfactory对象 13 //而做basedao抽取的时候 需要继承baseDao的实现类 因为该实现类继承了hibernateDaoSupport 所以这里就 14 //不需c复继承了 但是在spring配置文件中 CustomerDaoImpl中还是需要注入sessionfactory类的 15 //因为该类虽然没有直接继承hibernateDaoSupport 但是因为basedaoimpl继承了 本类又继承了 basedaoimpl 16 //所以这个类就继承了hibernateDaoSupport 17 //另外在继承basedaoimpl时 需要明确泛型的类型 把泛型替换为具体的对象类型 18 public class CustomerDaoImpl extends BaseDaoImpl<Customer> implements CustomerDao { 19 20 // public CustomerDaoImpl() { 21 // super(); 22 // System.out.println("customerdaoimpl......构造函数执行"); 23 // } 24 /* 25 * 因为在basedaoimpl中已经做了抽取 把基本的增删改查操作都做了实现 而且继承了basedaoimpl 直接在service中调用即可 26 * 27 * 28 //向t_customer表中保存一条记录 29 public void add(Customer customer) { 30 //得到模板对象 使用方法进行数据的保存 31 this.getHibernateTemplate().save(customer); 32 } 33 //查询t_customer表中的所有记录 34 public List<Customer> findAll() { 35 // TODO Auto-generated method stub 36 return (List<Customer>) this.getHibernateTemplate().find("from Customer"); 37 } 38 //根据id 查询对象 39 public Customer findOne(int id) { 40 // TODO Auto-generated method stub 41 return this.getHibernateTemplate().get(Customer.class,id); 42 } 43 //删除对象 44 public void delete(Customer c) { 45 // TODO Auto-generated method stub 46 this.getHibernateTemplate().delete(c); 47 } 48 //修改操作 49 public void update(Customer customer) { 50 // TODO Auto-generated method stub 51 this.getHibernateTemplate().update(customer); 52 } 53 */ 54 //查询总的记录数 55 public int findCount() { 56 // TODO Auto-generated method stub 57 //使用模板中的find方法来完成查询总记录数 查询出来的不是一个个的对象的集合 58 //而是一个数值 但是该方法反回的的是一个list集合 所以仍然需要使用list集合进行接收 59 List<Object>list=(List<Object>) this.getHibernateTemplate().find("select count(*) from Customer"); 60 //从list中把值得到 61 if(list!=null&&list.size()!=0){ 62 //变成int类型 63 Object obj=list.get(0); 64 //直接变是不行的 需要先变成Long型（long的包装类） 在转为int性 65 Long lobj=(Long) obj; 66 int count=lobj.intValue(); 67 return count; 68 } 69 return 0; 70 } 71 //分页操作 72 public List<Customer> findPage(int begin, int pageSize) { 73 // TODO Auto-generated method stub 74 //创建离线DetachedCriteria对象 指明是对那个实体类进行操作 75 DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class); 76 //第一个参数是离线对象 第二个 ：起始位置 第三个 每页的大小(记录数) 77 List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria,begin,pageSize); 78 return list; 79 } 80 //条件查询 输入的内容不为空 81 public List<Customer> findCondition(Customer customer) { 82 // TODO Auto-generated method stub 83 //第一种方式： 84 // SessionFactory sessionFactory=this.getHibernateTemplate().getSessionFactory();//得到sessionfactory对象 85 // Session session=sessionFactory.getCurrentSession();//得到session 这里的session对象和web阶段的HttpSession不是同一个概念 86 // Query query=session.createQuery("from Customer where custName like ?"); 87 // query.setParameter(0,customer.getCustName()); 88 // List<Customer> list=query.list(); 89 90 91 //第二种方式： 单一条件查询的时候 这种比较简单 但是多条件查询的时候 使用第三中方式最简单 92 // List<Customer> list=(List<Customer>) this.getHibernateTemplate().find("from Customer where custName like ?","%"+customer.getCustName()+"%"); 93 94 95 //第三种方式： 96 //创建离线对象，表示对那个实体类进行操作 97 DetachedCriteria criteria=DetachedCriteria.forClass(Customer.class); 98 //设置对实体类中的那个属性进行条件查询 如果对多个字段进行条件查询 那么只需要调用add方法即可 99 criteria.add(Restrictions.like("custName","%"+customer.getCustName()+"%")); 100 //调用模板中的方法 得到集合 101 List<Customer> list=(List<Customer>) this.getHibernateTemplate().findByCriteria(criteria); 102 return list; 103 } 104 105 }
如果该实现类不注入sessionfactory，那么就会报错：
service中部分代码：因为继承了basedaoimpl 所以这里调用的方法 都是basedaoimpl中的方法
1 // 添加客户 2 public void add(Customer customer) { 3 // TODO Auto-generated method stub 4 customerDao.add(customer); 5 } 6 7 // 客户列表 8 public List<Customer> findAll() { 9 // TODO Auto-generated method stub 10 return customerDao.findAll(); 11 } 12 13 // 根据id查询对象 14 public Customer findOne(int id) { 15 return customerDao.findOne(id); 16 } 17 18 // 删除对象 19 public void delete(Customer c) { 20 // TODO Auto-generated method stub 21 customerDao.delete(c); 22 } 23 24 // 修改操作 25 public void update(Customer customer) { 26 // TODO Auto-generated method stub 27 customerDao.update(customer); 28 }
这样统一的功能就由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中的方法：
1 //多条件查询 2 public List<Customer> moreCondition(Customer customer) { 3 List<Object> p=new ArrayList<Object>(); 4 String hql="from Customer where 1=1"; 5 //下面进行验证是否为空 并拼接hql字符串 6 if(customer.getCustName()!=null&&!"".equals(customer.getCustName())){ 7 hql=hql+" and custName=?"; 8 p.add(customer.getCustName());//如果值不为空 就把该值设置进list集合中 9 } 10 if(customer.getCustLevel()!=null&&!"".equals(customer.getCustLevel())){ 11 hql += " and custLevel=?"; 12 p.add(customer.getCustLevel()); 13 } 14 if(customer.getCustSource()!=null&&!"".equals(customer.getCustSource())){ 15 hql += " and custSource=?"; 16 p.add(customer.getCustSource()); 17 } 18 //第二个参数是一个可变参数（就是一种数组的形式） 需要把list集合变为数组 19 return (List<Customer>) this.getHibernateTemplate().find(hql,p.toArray()); 20 }
在这方法中，我们采用的是字符串拼接的方式来构造hql语句，因为用户可能什么也没用输入，所以就需要判断是否为空，如果为空，那么if语句就都没有执行，所以hql语句就变为：
String hql="from Customer where 1=1";
当然是查询所有了
所以通过字符串拼接的方式，就能够完成多条件的查询操作
第三种方式代码实现：
daoimpl代码：
1 //多条件查询 2 public List<Customer> moreCondition(Customer customer) { 3 //第二种方式：使用离线对象 4 DetachedCriteria c=DetachedCriteria.forClass(Customer.class);//DetachedCriteria离线查询 5 //仍然需要验证是否为空 如果不为空 就像离线对象中插入限制条件 并且设置值 6 if(customer.getCustName()!=null&&!"".equals(customer.getCustName())){ 7 c.add(Restrictions.eq("custName",customer.getCustName())); 8 } 9 if(customer.getCustLevel()!=null&&!"".equals(customer.getCustLevel())){ 10 c.add(Restrictions.eq("custLevel",customer.getCustLevel())); 11 } 12 if(customer.getCustSource()!=null&&!"".equals(customer.getCustSource())){ 13 c.add(Restrictions.eq("custSource",customer.getCustSource())); 14 } 15 //调用方法 执行查询 16 return (List<Customer>) this.getHibernateTemplate().findByCriteria(c); 17 }
DetachedCriteria--离线查询
Restrictions--条件限制
标签：私有属性 cto -- 映射 rda 大量 ber array name
原文地址：http://www.cnblogs.com/Joke-Jay/p/6648768.html
