JPA Specification复杂查询及排序

一、前言

刚使用spring-data-jpa,遇到不少难题，网上查了很多资料，发现讲jpa的不多，发个我刚做过的接口的过程吧。

二、需求

看到图了吗？需要实现搜索以及各种字段的排序还要分页，还有可能有选择各种条件的下拉列表，是不是很变态？

三、开始了

一、dao

需要先处理dao层，这里喜欢叫repository。做一个实体类的dao层接口，继承JpaSpecificationExecutor，再写一个查询接口。

二、service

在这里主要处理的是查询条件，我这里是搜索功能的模糊查询，当然如果有更多的查询也可以添加进这里。这里需要注意的是specification。

三、排序

需要先建一个辅助的实体类，属性名我取和需要排序的实体类一样的名字，但是注意属性都是String类型的啊。后面细说，先上我建的辅助类。

@Data
public class DeptSort {

    private String id;//编码

    private String name;//名称

    private String highDeptName;//上级部门

    private String principal;//负责人

    private String deptType;//部门类型

    private String enable;//启用
}
字段都是需要排序的字段，这是为了好区分，叫别的也可以。
下面是controller层，排序功能的具体实现。

public ResponseModel table(@RequestParam("search")String search,
                           @RequestParam("pageNumber")Integer pageNumber,
                           @RequestParam("pageSize")Integer pageSize,
                           @RequestBody DeptSort deptSort){
    ResponseModel model = null;
    try {
        List<Sort.Order> orders = new ArrayList<Sort.Order>();
        if (StringUtils.isNotBlank(deptSort.getId())){
            orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getId()),"id"));
        }
        if (StringUtils.isNotBlank(deptSort.getName())){
            orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getName()),"name"));
        }
        if (StringUtils.isNotBlank(deptSort.getHighDeptName())){
            orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getHighDeptName()),"highDeptName"));
        }
        if (StringUtils.isNotBlank(deptSort.getPrincipal())){
            orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getPrincipal()),"principal"));
        }
        if (StringUtils.isNotBlank(deptSort.getDeptType())){
            orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getDeptType()),"deptType"));
        }
        if (StringUtils.isNotBlank(deptSort.getEnable())){
            orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getEnable()),"enable"));
        }
        //orders不能为空，所以如果为空设置按id排序

        if (orders.size() == 0){
        orders.add(new Sort.Order(Sort.Direction.ASC,"id"));
        }

        Sort sort = new Sort(orders);
        Pageable pageable = new PageRequest(pageNumber,pageSize,sort);
        Page<Businessdept> all = service.findAll(search, pageable);
        model = ResponseModel.getSuccessResponseModel().setData(all);
    }catch (Exception e){
        e.printStackTrace();
        model = ResponseModel.getFailedResponseModel();
    }
    return model;
}

需要的参数有搜索内容search，还有DeptSort辅助类。首先建立

List<Sort.Order> orders = new ArrayList<Sort.Order>();集合，然后if判断将参数加入集合。
需要说明的是类似

orders.add(new Sort.Order(Sort.Direction.fromString(deptSort.getEnable()),"enable"))语句，“enable”是需要查询的

Businessdept里的字段，不是辅助类的，当然这里我的辅助类和Businessdept类一致，但是不一样的同学需要注意了。

 四、前端

对于前端传递的参数有什么要求呢？

deptSort的各个属性的参数只能限定两种asc和desc，即升序和降序。上图的功能需求只需要传deptSort里的一个属性就可以了，这里传两个参数演示一下。

查询成功的数据不展示了，给大家看一个后台的SQL语句

Hibernate:
/* select
count(generatedAlias0)
from
Businessdept as generatedAlias0
where
(
generatedAlias0.name like :param0
)
and (
generatedAlias0.deleteIs=1
) */ select
count(businessde0_.id) as col_0_0_
from
t_department businessde0_
where
(
businessde0_.name like ?
)
and businessde0_.delete_is=1
Hibernate:
/* select
generatedAlias0
from
Businessdept as generatedAlias0
where
(
generatedAlias0.name like :param0
)
and (
generatedAlias0.deleteIs=1
)
order by
generatedAlias0.deptType asc,
generatedAlias0.enable desc */ select
businessde0_.id as id1_3_,
businessde0_.delete_is as delete_i2_3_,
businessde0_.dept_type as dept_typ3_3_,
businessde0_.enable as enable4_3_,
businessde0_.high_dept_id as high_dep5_3_,
businessde0_.high_dept_name as high_dep6_3_,
businessde0_.name as name7_3_,
businessde0_.principal as principa8_3_
from
t_department businessde0_
where
(
businessde0_.name like ?
)
and businessde0_.delete_is=1
order by
businessde0_.dept_type asc,
businessde0_.enable desc limit ?

可以看到条件查询，升序、降序都有。

四、结束语

好了，我是我发的第一个帖子，请多多支持，最好关注我。

 

转载于:https://www.cnblogs.com/ymf23/p/6653417.html