SpringDataJpa的扩展

继承JpaSpecificationExecutor

• dao层

public interface PersonDao extends JpaRepository<Person,Integer>, JpaSpecificationExecutor<Person> {
}

• 案例测试1

单条件

 /*
    * 根据条件，查询单个对象
    * */
    @Test
    public void testInsertOrder(){
        //匿名内部类
        /*
        * 自定义查询条件
        * 1、实现Specification接口(提供泛型，查询的对象类型)
        * 2、实现toPredicate()方法(构造查询条件)
        * 3、需要借助方法参数中的两个参数
        *      root:获取需要查询的对象属性
        *      CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件(模糊匹配，精准匹配)，
        *   案例：根据用户名查询，
        * */
        Specification<Person> spec=new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //1、获取比较的查询
                Path<Object> name = root.get("name");
                //2、构造查询条件
                /*
                * 第一个参数，需要比较的属性(path对象)
                * 第二个参数，当前需要比较的取值
                * */

                Predicate predicate =cb.equal(name,"周志强");//进行精准的匹配 (比较的属性，比较的属性的取值)
                return predicate;
            }
        };
        Person person = personDao.findOne(spec);
        System.out.println(person);
    }

• 案例测试2

多条件组合

/*
    * 多条件查询
    *  案例：根据用户名和住址进行查询
    * */
    @Test
    public void testSpec(){
        Specification<Person> spec=new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> name = root.get("name");
                Path<Object> personAddr = root.get("personAddr");
                Predicate p1 = cb.equal(name, "周志强");
                Predicate p2 = cb.equal(personAddr, "天水");
                //将多个查询条件组合在一起(与关系，或关系两种根据业务来搞)
                Predicate and =cb.and(p1,p2);
                return and;
            }
        };
        Person person = personDao.findOne(spec);
        System.out.println(person);
    }

• 案例测试2.1

对or的测试

/*
    * 多条件查询
    *  案例：根据用户名和住址进行查询
    * */
    @Test
    public void testSpec(){
        Specification<Person> spec=new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> name = root.get("name");
                Path<Object> personAddr = root.get("personAddr");
                Predicate p1 = cb.equal(name, "周志强");
                Predicate p2 = cb.equal(personAddr, "天水");
                //将多个查询条件组合在一起(与关系，或关系两种根据业务来搞)
                Predicate and =cb.or(p1,p2);
                return and;
            }
        };
        List<Person> people = personDao.findAll(spec);
        people.forEach(person -> System.out.println(person));
    }

• 案例测试3

模糊查询

/*
    * 根据用户名进行模糊查询
    *
    * equal：直接得到path对象就可以比较
    * gt,lt,ge,le,like：不能直接用path对象进行比较，根据path对象指定比较的参数类型，再进行比较
    * 指定参数类型：path.as(类型的字节码对象);
    * */
    @Test
    public void testLike(){
        Specification<Person> spec=new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> name = root.get("name");
                Predicate predicate = cb.like(name.as(String.class), "%周%");
                return predicate;
            }
        };
        Person person = personDao.findOne(spec);
        System.out.println(person);
    }

• 案例测试4

排序

  @Test
    public void testOrder(){
        Specification<Person> spec=new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> name = root.get("personAddr");
                Predicate predicate = cb.like(name.as(String.class), "%天%");
                return predicate;
            }
        };
        //创建排序
        Sort sort = new Sort(Sort.Direction.DESC,"personId");
        List<Person> people = personDao.findAll(spec, sort);
        people.forEach(person -> System.out.println(person));
    }

• 案例测试5

分页加排序

   /*
    * 分页加排序
    * */
    @Test
    public void testOrderAndPage(){
        Specification<Person> spec=new Specification<Person>() {
            @Override
            public Predicate toPredicate(Root<Person> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> name = root.get("personAddr");
                Predicate predicate = cb.like(name.as(String.class), "%天%");
                return predicate;
            }
        };
        //创建排序
        Sort sort = new Sort(Sort.Direction.DESC,"personId");
        Pageable pageable=new PageRequest(0, 3, sort);
        Page<Person> people = personDao.findAll(spec, pageable);
        people.forEach(person -> System.out.println(person));
    }

springdatajpa多条件查询

    @Override
    public Page<SysTechnician> objPage(Integer page, Integer limit,SysTechnician sysTechnician,String sortColom) {
        Pageable pageable = new PageRequest(page - 1, limit);
        Page<SysTechnician> myPage = technicianDao.findAll(new Specification<SysTechnician>() {
            @Override
            public Predicate toPredicate(Root<SysTechnician> root, CriteriaQuery<?> query,
                                         CriteriaBuilder criteriaBuilder) {
                List<Predicate> list = new ArrayList<Predicate>();
                // config search where rule
                if (StringUtils.isNoneBlank(sysTechnician.getTechnicianName())) {
                    list.add(criteriaBuilder.like(root.get("technicianName"), "%"+sysTechnician.getTechnicianName()+"%"));
                }
                Predicate[] p = new Predicate[list.size()];
                return criteriaBuilder.and(list.toArray(p));
            }
        }, pageable);
        return myPage;
    }