JPA--SpringDataJpa之Specifications动态查询

Specifications动态查询

JpaSpecificationExecutor 方法列表

• T findOne(Specification spec)：查询单个对象
• List findAll(Specification spec)：查询列表

• Page findAll(Specification spec, Pageable pageable)：分页查询

  • pageable：分页参数
  • 返回值：分页pageBean（page：是springdatajpa提供的）

• List findAll(Specification spec, Sort sort)：查询列表

  • Sort：排序参数
• long count(Specification spec)：统计查询

Specification ：
Specification是查询条件，由我们自己实现。
需要实现Predicate toPredicate(Root root, CriteriaQuery<?> query, CriteriaBuilder cb)方法

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

示例

实体类

package pers.zhang.entity;
/** * @author zhang * @date 2019/12/15 - 22:10 */
import javax.persistence.*;
/** * 1.实体类和表的映射关系 * @Entity * @Table * 2.类中属性和表中字段的映射关系 * @Id * @GeneratedValue * @Colum */
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer { 
    @Id//声明当前私有属性为主键
    @GeneratedValue(strategy= GenerationType.IDENTITY) //配置主键的生成策略
    @Column(name="cust_id") //指定和表中cust_id字段的映射关系
    private Long custId;
    @Column(name="cust_name") //指定和表中cust_name字段的映射关系
    private String custName;
    @Column(name="cust_source")//指定和表中cust_source字段的映射关系
    private String custSource;
    @Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
    private String custIndustry;
    @Column(name="cust_level")//指定和表中cust_level字段的映射关系
    private String custLevel;
    @Column(name="cust_address")//指定和表中cust_address字段的映射关系
    private String custAddress;
    @Column(name="cust_phone")//指定和表中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 + '\'' +
                '}';
    }
}

Dao接口

public interface MyCustomerDao extends JpaRepository<Customer, Long>, JpaSpecificationExecutor<Customer> { 
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest { 
    @Autowired
    private MyCustomerDao customerDao;
}

根据条件查询单个对象

@Test
public void  testSpec(){ 
    /* 自定义查询条件： 1.实现Specification接口（提供泛型：查询对象类型） 2.实现toPredicate方法（构造查询条件） 3.需要借助方法参数中的两个参数（root：获取需要查询的对象属性 CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精确匹配）） 示例：根据客户名称查询，查询客户名为网易的客户 查询条件： 1.查询方式 criteriaBuilder对象 2.比较的属性名称 root对象 */
    Specification<Customer> spec = new Specification<Customer>() { 
        @Override
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) { 
            //获取比较的属性
            Path<Object> custName = root.get("custName");
            //构造查询条件 select * from cst_customer where cust_name = '网易'
            //第一个参数：需要比较的属性
            //第二个参数：当前需要比较的取值
            Predicate predicate = criteriaBuilder.equal(custName, "网易");//精准匹配
            return predicate;
        }
    };
    Customer customer = customerDao.findOne(spec);
    System.out.println(customer);
}

多条件查询单个值

/* 多条件查询 示例：根据客户名（网页）和客户行业（游戏）查询客户 */
@Test
public void testSpec1(){ 
    /* root：获取属性（客户名，所属行业） criteriaBuilder： 1.构造客户名的精准匹配查询 2.构造所属行业的精准匹配查询 3.将以上两个查询联系起来 */
    Specification<Customer> spec = new Specification<Customer>() { 
        @Override
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) { 
            Path<Object> custName = root.get("custName");
            Path<Object> custIndustry = root.get("custIndustry");
            //构造查询参数
            //1.构造客户名的精准匹配
            Predicate p1 = criteriaBuilder.equal(custName, "网易");
            //2.构造所属行业的精准匹配
            Predicate p2 = criteriaBuilder.equal(custIndustry, "游戏");
            //3.将多个条件组合到一起，组合（满足条件一并且满足条件二：与关系 满足条件一或满足条件二即可：或关系）
            Predicate and = criteriaBuilder.and(p1, p2);//以与的形式拼接多个查询条件
            //criteriaBuilder.or() 以或的方式拼接条件
            return and;
        }
    };
    Customer customer = customerDao.findOne(spec);
    System.out.println(customer);
}

查询列表

/* 查询列表： 示例：根据客户名称模糊匹配，返回客户列表 criteriaBuilder的方法： equal：直接得到path对象（属性），然后进行比较 gt,lt,ge,le,like：得到path对象，根据句path指定比较的参数类型，再去进行比较 指定参数的类型：path.as(类型的字节码对象) */
@Test
public void testSpec3(){ 
    Specification<Customer> spec = new Specification<Customer>() { 
        @Override
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) { 
            Path<Object> custName = root.get("custName");
            Predicate predicate = criteriaBuilder.like(custName.as(String.class), "%腾%");
            return predicate;
        }
    };
    List<Customer> all = customerDao.findAll(spec);
    for(Customer c : all)
        System.out.println(c);
}

排序查询

/* 排序查询 示例：根据客户名称模糊匹配，逆序，返回客户列表 */
@Test
public void testSpec4(){ 
    Specification<Customer> spec = new Specification<Customer>() { 
        @Override
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) { 
            Path<Object> custName = root.get("custName");
            Predicate predicate = criteriaBuilder.like(custName.as(String.class), "%腾%");
            return predicate;
        }
    };
    /* 创建排序对象Sort 需要调用构造方法传递参数 1. 排序的顺序（asc | desc） 2. 排序的属性名 */
    Sort sort = new Sort(Sort.Direction.ASC, "custName");
    List<Customer> all = customerDao.findAll(spec);
    for(Customer c : all)
        System.out.println(c);
}

分页查询
Page接口

public interface Page<T> extends Iterable<T> {   
        int getNumber();            //当前第几页 返回当前页的数目。总是非负的 
        int getSize();              //返回当前页面的大小。 
        int getTotalPages();         //返回分页总数。 
        int getNumberOfElements();   //返回当前页上的元素数。 
        long getTotalElements();    //返回元素总数。 
        boolean hasPreviousPage();  //返回如果有上一页。 
        boolean isFirstPage();      //返回当前页是否为第一页。 
        boolean hasNextPage();      //返回如果有下一页。 
        boolean isLastPage();       //返回当前页是否为最后一页。 
        Iterator<T> iterator();  
        List<T> getContent();     //将所有数据返回为List 
        boolean hasContent();     //返回数据是否有内容。 
        Sort getSort();          //返回页的排序参数。 
    }

Pageable 接口:

/** * 分页信息抽象接口 * * @author Oliver Gierke */  
    public interface Pageable {   
        /** * 返回要返回的页面. * * @return the page to be returned. */  
        int getPageNumber();  
        /** * 返回要返回的项目的数量。 * * @return the number of items of that page */  
        int getPageSize();  
        /** * 根据底层页面和页面大小返回偏移量。 * * @return the offset to be taken */  
        int getOffset();  
        /** * 返回排序参数。 * * @return */  
        Sort getSort();  
    }
/* 分页查询: 1.findAll(Specification, Pageable)：有条件的分页 2.findALL(Pageable)：没有条件的分页 Specification：查询条件 Pageable：分页参数 返回：Page（springdataJpa为我们封装好的pageBean对象） */
@Test
public void testSpec5(){ 
    Specification spec = null;
    /* PageRequest是Pageable的实现类，在创建pageable的过程中，需要调用它的构造方法传入两个参数 1.当前查询的页数（从0开始） 2.每页查询的数量 */
    Pageable pageable = new PageRequest(0, 2);
    Page page = customerDao.findAll(spec, pageable);
    /* Page方法： getContent():获取查询的结果，返回List<?> getTotalElements():获取查询到的总条数，返回Long getTotalPages()：获取查询到的总页数，返回int */
    System.out.println("数据：" + page.getContent());
    System.out.println("总条数：" + page.getTotalElements());
    System.out.println("总页数" + page.getTotalPages());
}