自定义我们自己的Specification实现类
    实现
    Root：查询的根对象（查询的任何属性都可以从根对象中获取）
    CriteriaQuery：顶层查询对象，自定义查询方式（了解：一般不用）
    CriteriaBuilder：查询的构造器，封装了很多的查询条件 

    1.  Predicate toPredicate(Root<T> var1, CriteriaQuery<?> var2, CriteriaBuilder var3); 
    2. //封装查询条件

    代码实例

    1. package com.cedric.test;
    3. import com.cedric.dao.CustomerDao;
    4. import com.cedric.domain.Customer;
    5. import org.junit.Test;
    6. import org.junit.runner.RunWith;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.data.domain.Page;
    9. import org.springframework.data.domain.PageRequest;
    10. import org.springframework.data.domain.Pageable;
    11. import org.springframework.data.domain.Sort;
    12. import org.springframework.data.jpa.domain.Specification;
    13. import org.springframework.test.context.ContextConfiguration;
    14. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    16. import javax.persistence.criteria.*;
    17. import java.util.List;
    19. @RunWith(SpringJUnit4ClassRunner.class)
    20. @ContextConfiguration(locations = "classpath:applicationContext.xml")
    21. public class SpecTest {
    23.     @Autowired
    24.     private CustomerDao customerDao;
    26.     /**
    27.      * 根据条件，查询单个对象
    28.      */
    29.     @Test
    30.     public void testSpec(){
    31.         /**
    32.          * 自定义查询条件
    33.          *  1.实现Specification接口（提供泛型，查询的对象类型）
    34.          *  2.实现toPredicate方法(构造查询条件)
    35.          *  3.需要借助方法参数中的两个参数（
    36.          *      root:获取需要查询的对象属性
    37.          *      CriteriaBuilder：构造查询条件的内部封装了很多查询条件（模糊匹配，精准匹配）
    38.          *  ）
    39.          *
    40.          *  案例：根据客户名称查询，查询客户名为京东的客户
    41.          *      查询条件
    42.          *          1.查询方式
    43.          *              cb对象
    44.          *          2.比较的属性名称
    45.          *              root对象
    46.          */
    47.         Specification<Customer> spec = new Specification<Customer>() {
    48.             @Override
    49.             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    50.                 // 1.获取比较的属性
    51.                 Path<Object> custName = root.get("custName");
    52.                 // 2.构造查询条件     ：   select * from cst_customer where cust_name = '京东'
    53.                 /**
    54.                  * 第一个参数：需要比较的属性（path对象）
    55.                  * 第二个参数：当前需要比较的取值
    56.                  */
    57.                 Predicate predicate = criteriaBuilder.equal(custName, "京东");//进行精准匹配（比较的属性，比较的属性取值）
    58.                 return predicate;
    59.             }
    60.         };
    61.         Customer customer = customerDao.findOne(spec);
    62.         System.out.println(customer);
    63.     }
    65.     /**
    66.      * 多条件查询
    67.      *      案例：根据客户名（腾讯）和客户所属行业查询（网游）
    68.      */
    69.     @Test
    70.     public void testSpec1(){
    71.         /**
    72.          * root:获取属性
    73.          *      客户名
    74.          *      所属行业
    75.          * criteriaBuilder：构造查询
    76.          *      1.构造客户名的精准匹配查询
    77.          *      2.构造所属行业的精准匹配查询
    78.          *      3.将以上两个查询联系起来
    79.          */
    80.         Specification<Customer> spec = new Specification<Customer>() {
    81.             @Override
    82.             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    83.                 Path<Object> custName = root.get("custName");//客户名
    84.                 Path<Object> custIndustry = root.get("custIndustry");//所属行业
    86.                 //构造函数
    87.                 //1.构造客户名的精准匹配查询
    88.                 Predicate predicate = criteriaBuilder.equal(custName, "腾讯");// 第一个参数，path（属性），第二个参数,属性的取值
    89.                 //2.构造所属行业的精准匹配查询
    90.                 Predicate predicate1 = criteriaBuilder.equal(custIndustry, "网游");
    91.                 //3.将多个查询条件组合到一起:组合（满足条件一并且满足条件二：与关系，满足条件一或满足条件二即可：或关系）
    92.                 Predicate and = criteriaBuilder.and(predicate, predicate1);//以与的形式拼接多个查询条件
    93.                 //criteriaBuilder.or();//以或的形式拼接多个查询条件
    94.                 return and;
    95.             }
    96.         };
    97.         Customer customer = customerDao.findOne(spec);
    98.         System.out.println(customer);
    99.     }
    101.     /**
    102.      * 案例：完美根据客户名称的模糊匹配，返回客户列表
    103.      *      客户名称以‘阿里’开头
    104.      * equal:直接得到path对象(属性)，然后进行比较即可
    105.      * gt,lt,ge,le,like:得到path对象，根据path指定比较的参数类型，再去进行比较
    106.      *      指定参数类型：path.as（类型的字节码对象）
    107.      */
    108.     @Test
    109.     public void testSpec3(){
    110.         //构造查询条件
    111.         Specification<Customer> spec = new Specification<Customer>() {
    112.             @Override
    113.             public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
    114.                 //查询属性：用户名
    115.                 Path<Object> custName = root.get("custName");
    116.                 //查询方式：模糊匹配
    117.                 Predicate like = criteriaBuilder.like(custName.as(String.class), "阿里%");
    118.                 return like;
    119.             }
    120.         };
    121.        /* ListCustomer> all = customerDao.findAll(spec);
    122.         for(Customer customer : all){
    123.             System.out.println(customer);
    124.         }*/
    126.         //添加排序
    127.         //创建排序对象，需要调用构造方法实例化sort对象
    128.         //第一个参数：排序的顺序（倒序，正序）
    129.         //Sort.Direction.DESC：倒序
    130.         //Sort.Direction.ASC：升序
    131.         //第二个参数：排序的属性名称
    132.         Sort sort = new Sort(Sort.Direction.DESC,"custId");
    133.         List<Customer> all = customerDao.findAll(spec, sort);
    134.         for(Customer customer : all){
    135.             System.out.println(customer);
    136.         }
    137.     }
    139.     /**
    140.      * 分页查询
    141.      *      Specification:查询条件
    142.      *      Pageable：分页参数
    143.      *          分页参数：查询的页码，每页查询的条数
    144.      *      findAll(Specification,Pageable)：带有条件的分页
    145.      *      findAll(Pageable):没有条件的分页
    146.      *  返回：Page（SpringDataJpa为我们封装好的pageBean对象，数据列表，总条数）
    147.      */
    148.     @Test
    149.     public void testSpec4(){
    151.         Specification spec = null;
    152.         //PageRequest对象是Pageable接口的实现类
    153.         /**
    154.          * 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
    155.          *      第一个参数：当前查询的页数（从0开始）
    156.          *      第二个参数：每页查询的数量
    157.          */
    158.         Pageable pageable = new PageRequest(0,2);
    159.         // 分页查询
    160.         Page<Customer> page = customerDao.findAll(null, pageable);
    161.         System.out.println(page.getContent());//得到数据集合列表
    162.         System.out.println(page.getTotalElements());//得到总条数
    163.         System.out.println(page.getTotalPages());//得到总页数
    164.     }
    165. }