spring data jpa Specification动态查询

package com.ytkj.entity;
 
import javax.persistence.*;
import java.io.Serializable;
 
/**
 *          @Entity
 *         	作用：指定当前类是实体类。
 *         @Table
 *         	作用：指定实体类和表之间的对应关系。
 *         	属性：
 *         		name：指定数据库表的名称
 *         @Id
 *         	作用：指定当前字段是主键。
 *         @GeneratedValue
 *         	作用：指定主键的生成方式。。
 *         	属性：
 *         		strategy ：指定主键生成策略。
 *         @Column
 *         	作用：指定实体类属性和数据库表之间的对应关系
 *         	属性：
 *         		name：指定数据库表的列名称。
 *         		unique：是否唯一
 *         		nullable：是否可以为空
 *         		inserttable：是否可以插入
 *         		updateable：是否可以更新
 *         		columnDefinition: 定义建表时创建此列的DDL
 *         		secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
 *
 * 客户实体类
 *      配置映射关系
 *          实体类和表映射
 *          实体类属性和表字段映射
 */
@Entity
@Table(name = "cst_customer")
public class Customer implements Serializable {
    /**
     * 声明主键配置
     */
    @Id
    /**
     * 配置主键的生成策略
     */
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    /**
     * 指定实体类属性和数据库表之间的对应关系
     */
    @Column(name ="cust_id")
    private Long custId;//客户主键
    @Column(name = "cust_name")
    private String custName;//客户名称
    @Column(name ="cust_source" )
    private String custSource;//客户来源
    @Column(name = "cust_industry")
    private String custIndustry;//客户行业
    @Column(name ="cust_level")
    private String custLevel;//客户级别
    @Column(name ="cust_address")
    private String custAddress;//客户地址
    @Column(name = "cust_phone")
    private String custPhone;//客户电话
 
    public Long getCustId() {
        return custId;
    }
 
    public void setCustId(Long custId) {
        this.custId = custId;
    }
 
    public String getCustName() {
        return custName;
    }
 
    public void setCustName(String custName) {
        this.custName = custName;
    }
 
    public String getCustSource() {
        return custSource;
    }
 
    public void setCustSource(String custSource) {
        this.custSource = custSource;
    }
 
    public String getCustIndustry() {
        return custIndustry;
    }
 
    public void setCustIndustry(String custIndustry) {
        this.custIndustry = custIndustry;
    }
 
    public String getCustLevel() {
        return custLevel;
    }
 
    public void setCustLevel(String custLevel) {
        this.custLevel = custLevel;
    }
 
    public String getCustAddress() {
        return custAddress;
    }
 
    public void setCustAddress(String custAddress) {
        this.custAddress = custAddress;
    }
 
    public String getCustPhone() {
        return custPhone;
    }
 
    public void setCustPhone(String custPhone) {
        this.custPhone = custPhone;
    }
 
    @Override
    public String toString() {
        return "Customer{" +
                "custId=" + custId +
                ", custName='" + custName + '\'' +
                ", custSource='" + custSource + '\'' +
                ", custIndustry='" + custIndustry + '\'' +
                ", custLevel='" + custLevel + '\'' +
                ", custAddress='" + custAddress + '\'' +
                ", custPhone='" + custPhone + '\'' +
                '}';
    }
}

　　

 
 Specifications动态查询
 
    JpaSpecificationExecutor 方法列表
 
        T findOne(Specification<T> spec);  //查询单个对象
 
        List<T> findAll(Specification<T> spec);  //查询列表
 
        //查询全部，分页
        //pageable：分页参数
        //返回值：分页pageBean（page：是springdatajpa提供的）
        Page<T> findAll(Specification<T> spec, Pageable pageable);
 
        //查询列表
        //Sort：排序参数
        List<T> findAll(Specification<T> spec, Sort sort);
 
        long count(Specification<T> spec);//统计查询
 
    * Specification ：查询条件
        自定义我们自己的Specification实现类
            实现
                //root：查询的根对象（查询的任何属性都可以从根对象中获取）
                //CriteriaQuery：顶层查询对象，自定义查询方式（了解：一般不用）
                //CriteriaBuilder：查询的构造器，封装了很多的查询条件
                Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件

Demo

/**
 * JpaRepository<实体类类型，主键类型>：用来完成基本CRUD操作
 * JpaSpecificationExecutor<实体类类型>：用于复杂查询（分页等查询操作）
 */
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
 
}

　　

import com.ytkj.dao.CustomerDao;
import com.ytkj.entity.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import javax.persistence.criteria.*;
import java.util.List;
 
/**
 * Specifications动态查询
 */
@RunWith(SpringJUnit4ClassRunner.class)//声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class SpringdatajpaSpecification {
 
    @Autowired
    CustomerDao customerDao;
 
    /**
     *
     * 根据单个条件查询
     */
    @Test
    public void  test(){
        //匿名内部类
        /**
         * 自定义查询条件
         *              1：实现Specification接口（提供泛型，查询对象的类型）
         *              2.实现Specification接口中的toPredicate方法（构造查询条件）
         *              3.根据方法中的两个参数：
         *                                  root:获取需要查询对象的属性名称
         *                                  criteriaBuilder：构造查询条件，内部封装了很多查询条件
         * 根据名称查询
         *
         */
        Specification<Customer> specification=new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //1.获取查询属性名称
                Path<Object> custName = root.get("custName");
                //2.构造查询条件 select * from cst_customer where cust_name='者超超'
                /**
                 * 第一个参数：需要比较的属性
                 * 第二个参数：当前需要比较的取值
                 */
                Predicate predicate = criteriaBuilder.equal(custName, "者超超");//精准匹配
                return predicate;
            }
        };
        Customer customer = customerDao.findOne(specification);
        System.out.println(customer);
    }
 
    /**
     *
     * 根据多个条件查询
     */
    @Test
    public void  test2(){
        //匿名内部类
        /**
         * 自定义查询条件
         *              1：实现Specification接口（提供泛型，查询对象的类型）
         *              2.实现Specification接口中的toPredicate方法（构造查询条件）
         *              3.根据方法中的两个参数：
         *                                  root:获取需要查询对象的属性名称
         *                                  criteriaBuilder：构造查询条件，内部封装了很多查询条件
         * 根据名称和地址查询
         *
         */
        Specification<Customer> specification=new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //1.获取查询属性名称
                Path<Object> custName = root.get("custName");
                Path<Object> custAddress = root.get("custAddress");
                //2.构造查询条件
                /**
                 * 第一个参数：path对象需要比较的属性
                 * 第二个参数：当前需要比较的取值
                 */
                Predicate predicate = criteriaBuilder.equal(custName, "者超超");//精准匹配
                Predicate predicate2 = criteriaBuilder.equal(custAddress, "昆明");//精准匹配
                //3.将多个查询条件组合起来：组合（根据自己的业务而定）比如：满足条件一并且满足条件二，满足条件一或者满足条件二
                Predicate and = criteriaBuilder.and(predicate, predicate2);
                return and;
            }
        };
        Customer customer = customerDao.findOne(specification);
        System.out.println(customer);
    }
 
    /**
     * 更具电话号码模糊查询
     * equal ：直接的到path对象（属性），然后进行比较即可
     *      gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
     *           指定参数类型：path.as(类型的字节码对象)
     */
    @Test
    public void  test3(){
        Specification<Customer> specification=new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //1.获取查询对象的属性
                Path<Object> custPhone = root.get("custPhone");
                //2.拼接查询条件
                Predicate like = criteriaBuilder.like(custPhone.as(String.class), "18%");
                return like;
            }
        };
        List<Customer> list = customerDao.findAll(specification);
        for (Customer customer : list) {
            System.out.println(customer);
        }
 
    }
 
    /**
     * 排序查询
     * 更具电话号码模糊 降序查询
     * equal ：直接的到path对象（属性），然后进行比较即可
     *      gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
     *           指定参数类型：path.as(类型的字节码对象)
     */
    @Test
    public void  test4(){
        Specification<Customer> specification=new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //1.获取查询对象的属性
                Path<Object> custPhone = root.get("custPhone");
                //2.拼接查询条件
                Predicate like = criteriaBuilder.like(custPhone.as(String.class), "18%");
                return like;
            }
        };
        //添加排序
        //创建排序对象,需要调用构造方法实例化sort对象
        //第一个参数：排序的顺序（倒序，正序）
        //   Sort.Direction.DESC:倒序
        //   Sort.Direction.ASC ： 升序
        //第二个参数：排序的属性名称
        Sort sort=new Sort(Sort.Direction.DESC,"custId");
        List<Customer> list = customerDao.findAll(specification, sort);
        for (Customer customer : list) {
            System.out.println(customer);
        }
    }
 
    /**
     * 根据id分页查询
     *      Specification: 查询条件
     *      Pageable：分页参数
     *          分页参数：查询的页码，每页查询的条数
     *          findAll(Specification,Pageable)：带有条件的分页
     *          findAll(Pageable)：没有条件的分页
     *  返回：Page（springDataJpa为我们封装好的pageBean对象，数据列表，共条数）
     */
    @Test
    public void  test5(){
        //匿名内部类
        /**
         * 自定义查询条件
         *              1：实现Specification接口（提供泛型，查询对象的类型）
         *              2.实现Specification接口中的toPredicate方法（构造查询条件）
         *              3.根据方法中的两个参数：
         *                                  root:获取需要查询对象的属性名称
         *                                  criteriaBuilder：构造查询条件，内部封装了很多查询条件
         * 根据名称查询
         *
         */
        Specification<Customer> specification=new Specification<Customer>() {
            @Override
            public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                //1.获取查询属性名称
                Path<Object> custId = root.get("custId");
                //2.构造查询条件 select * from cst_customer where custId>3 limit 0,5
                /**
                 * 第一个参数：需要比较的属性
                 * 第二个参数：当前需要比较的取值
                 */
                Predicate predicate = criteriaBuilder.gt(custId.as(Long.class), 3L);//精准匹配
                return predicate;
            }
        };
 
        /**
         * public PageRequest(int page, int size) {
         * 		this(page, size, null);
         *        }
         */
        Pageable pageable=new PageRequest(0,2);
        //分页查询
        Page<Customer> page = customerDao.findAll(specification, pageable);
        List<Customer> list = page.getContent();
        for (Customer customer : list) {
            System.out.println(customer);
        }
        System.out.println(page.getContent()); //得到数据集合列表
        System.out.println(page.getTotalElements());//得到总条数
        System.out.println(page.getTotalPages());//得到总页数
 
    }
 
}