上一节我们完成了EasyUI菜单的实现。这一节我们主要来写一下CategoryServiceImpl实现类,完成数据库的级联查询。一般项目从后往前做,先做service(我们没有抽取Dao,最后再抽取),做完了再做上面层。

  在写之前,先看一下数据库中的表的情况:

SQL代码
  1. drop database if exists shop;    
  2. /*创建数据库,并设置编码*/    
  3. create database shop default character set utf8;    
  4.     
  5. use shop;    
  6. /*删除管理员表*/    
  7. drop table if exists account;    
  8. /*删除最新送白菜网类别表*/    
  9. drop table if exists category;    
  10.     
  11. /*============================*/    
  12. /*      Table:管理员表结构                       */    
  13. /*============================*/    
  14. create table account    
  15. (    
  16.     /* 管理员编号,自动增长 */    
  17.     id int primary key not null auto_increment,    
  18.     /* 管理员登录名 */    
  19.     login varchar(20),    
  20.     /* 管理员姓名 */    
  21.     name varchar(20),    
  22.     /* 管理员密码 */    
  23.     pass varchar(20)    
  24. );    
  25.     
  26. /*============================*/    
  27. /*     Table:最新送白菜网类别表结构                      */    
  28. /*============================*/    
  29. create table category    
  30. (    
  31.    /* 类别编号,自动增长 */    
  32.    id  int primary key not null auto_increment,    
  33.    /* 类别名称 */    
  34.    type varchar(20),    
  35.    /* 类别是否为热点类别,热点类别才有可能显示在首页*/    
  36.    hot  bool default false,    
  37.    /* 外键,此类别由哪位管理员管理 */    
  38.    account_id int,    
  39.    constraint aid_FK foreign key(account_id) references account(id)    
  40. );    

  主要有两张表,最新送白菜网类别表和管理员表,并且最新送白菜网类别表中提供了一个外键关联管理员表。也就是最新送白菜网和管理员是多对一的关系。现在我们开始编写查询最新送白菜网的类别信息,需要级联管理员。

  1. 实现级联查询方法

  首先在CategoryService接口中定义该方法:

Java代码
  1. public interface CategoryService extends BaseService<Category> {    
  2.     //查询类别信息,级联管理员    
  3.     public List<Category> queryJoinAccount(String type); //使用类别的名称查询    
  4. }   

  然后我们在CategoryService的实现类CategoryServiceImpl中实现这个方法:

Java代码
  1. @Service("categoryService")    
  2. public class CategoryServiceImpl extends BaseServiceImpl<Category> implements CategoryService {    
  3.     
  4.     @Override    
  5.     public List<Category> queryJoinAccount(String type) {    
  6.         String hql = "from Category c where c.type like :type";    
  7.         return getSession().createQuery(hql)    
  8.                 .setString("type""%" + type + "%").list();    
  9.     }    
  10. }    

  在两个Model中我们配一下关联注解:

Java代码
  1. //Category类中    
  2. @ManyToOne(fetch = FetchType.EAGER)    
  3. @JoinColumn(name = "account_id")    
  4. public Account getAccount() {    
  5.     return this.account;    
  6. }    
  7. //Account类中    
  8. @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "account")    
  9. public Set<Category> getCategories() {    
  10.     return this.categories;    
  11. }    

  然后我们在测试类中测试一下:

Java代码
  1. @RunWith(SpringJUnit4ClassRunner.class)    
  2. @ContextConfiguration(locations="classpath:beans.xml")    
  3. public class CategoryServiceImplTest {    
  4.     
  5.     @Resource    
  6.     private CategoryService categoryService;    
  7.         
  8.     @Test    
  9.      public void testQueryJoinAccount() {    
  10.         for(Category c : categoryService.queryJoinAccount("")) {    
  11.              System.out.println(c);    
  12.              System.out.println(c.getAccount());    
  13.         }    
  14.     }    
  15. }    

  2. 级联查询存在的问题

  我们看一下控制台的输出可以看出,它发了不止一条SQL语句,但是我们明明只查询了一次,为什么会发这么多语句呢?这就是常见的1+N问题。所谓的1+N问题,就是首先发出一条语句查询当前对象,然后发出N条语句查询关联对象,因此效率变得很低。这里就两个对象,如果有更多的对象,那效率就会大打折扣了,我们该如何解决这个问题呢?

  可能大家会想到将fetch设置生FetchType.LAZY就不会发多条语句了,但是这肯定不行,因为设置成LAZY后,我们就拿不到Account对象了,比较好的解决方法是我们自己写hql语句,使用join fetch。具体看修改后的CategoryServiceImpl实现类:

Java代码
  1. @Service("categoryService")    
  2. public class CategoryServiceImpl extends BaseServiceImpl<Category> implements CategoryService {    
  3.     
  4.     @Override    
  5.     public List<Category> queryJoinAccount(String type) {    
  6.         String hql = "from Category c left join fetch c.account where c.type like :type";    
  7.         return getSession().createQuery(hql)    
  8.                 .setString("type""%" + type + "%").list();    
  9.     }    
  10. }    

  left join表示关联Account一起查询,fetch表示将Account对象加到Category中去,这样就只会发一条SQL语句了,并且返回的Category中也包含了Account对象了。

  3. 完成分页功能

  Hibernate中的分页很简单,只需要调用两个方法setFirstResult和setMaxResults即可:我们修改一下CategoryService接口和它的实现类CategoryServiceImpl:

Java代码
  1. //CategoryService    
  2. public interface CategoryService extends BaseService<Category> {    
  3.     //查询类别信息,级联管理员    
  4.     public List<Category> queryJoinAccount(String type, int page, int size); //并实现分页    
  5. }    
  6.     
  7. //CategoryServiceImpl    
  8. @Service("categoryService")    
  9. public class CategoryServiceImpl extends BaseServiceImpl<Category> implements CategoryService {    
  10.     
  11.     @Override    
  12.     public List<Category> queryJoinAccount(String type, int page, int size) {    
  13.         String hql = "from Category c left join fetch c.account where c.type like :type";    
  14.         return getSession().createQuery(hql)    
  15.                 .setString("type""%" + type + "%")    
  16.                 .setFirstResult((page-1) * size) //从第几个开始显示    
  17.                 .setMaxResults(size) //显示几个    
  18.                 .list();    
  19.     }    
  20. }    

  我们在测试类中测试一下:

Java代码
  1. @RunWith(SpringJUnit4ClassRunner.class)    
  2. @ContextConfiguration(locations="classpath:beans.xml")    
  3. public class CategoryServiceImplTest {    
  4.     
  5.     @Resource    
  6.     private CategoryService categoryService;    
  7.     
  8.     @Test    
  9.     public void testQueryJoinAccount() {    
  10.         for(Category c : categoryService.queryJoinAccount("",1,2)) { //显示第一页,每页2条数据    
  11.             System.out.println(c + "," + c.getAccount());    
  12.         }    
  13.     }    
  14. }    

  为此,我们写完了Service的方法了,完成了对最新送白菜网类别的级联查询和分页功能。

除非特别注明,鸡啄米文章均为原创
转载请标明本文地址:http://www.teaching4real.com/software/764.html
2017年9月13日
作者:鸡啄米 分类:软件开发 浏览: 注册送白菜网:0