Spring Data JPA系列QueryByExampleExecutor使用详解

目录
  • 1、QueryByExampleExecutor用法
    • 1.1 介绍
    • 1.2 QueryByExampleExecutor接口
    • 1.3 QueryByExampleExecutor实践
    • 1.4 Example语法详解
    • 1.5 ExampleMatcher语法分析
  • 2、ExampleMatcher语法暴露常用方法
    • 2.1 忽略大小写
    • 2.2 NULL值的Property的处理方式
    • 2.3 忽略某些属性列表,不参与查询过滤条件
    • 2.4 字符串默认的匹配规则
  • 3、实践出真理
    • 3.1 AND查询
    • 3.2 OR 查询
    • 3.3 忽略大小写查询
      • 3.3.1 忽略大小写 不指定属性
    • 3.4 NULL值的处理
      • 3.4.1 NULL属性值作为查询条件
      • 3.4.2 忽略(实体类中)NULL属性
    • 3.5 忽略某些属性不做筛选
    • 3.6 字符串匹配规则
      • 3.6.1 DEFAULT和EXACT 相等
      • 3.6.2 STARTING和ENDING 模糊查询【开始匹配(?1 + %) 和 结束匹配(% + ?1 )) 】
      • 3.6.3 Containing 包含模糊匹配【% + ?1 + %】

1、QueryByExampleExecutor用法

在前面章节中,我们介绍了DMQ 和 @Query两种查询方法,除此之外,还有QueryByExampleExecutor查询方法。

1.1 介绍

QueryByExampleExecutor是一种用户友好的查询技术,具有简单的接口,它允许动态创建,并且不需要填写包含字段名称的查询。

1.2 QueryByExampleExecutor接口

public interface QueryByExampleExecutor<T> {
   // 根据实体查询条件、查找一个对象
   <S extends T> Optional<S> findOne(Example<S> example);
   // 根据实体查询条件、查询一批对象
   <S extends T> Iterable<S> findAll(Example<S> example);
   // 根据实体查询条件并排序、查询一批对象
   <S extends T> Iterable<S> findAll(Example<S> example, Sort sort);
   // 根据实体查询条件并分页,查询一批对象
   <S extends T> Page<S> findAll(Example<S> example, Pageable pageable);
   // 根据实体查询条件、查询符合条件的对象个数
   <S extends T> long count(Example<S> example);
   // 根据实体查询条件、判断是否有符合条件的对象
   <S extends T> boolean exists(Example<S> example);
   // 根据实体查询条件、判断是否有符合条件的对象
   <S extends T, R> R findBy(Example<S> example, Function<FluentQuery.FetchableFluentQuery<S>, R> queryFunction);
}

1.3 QueryByExampleExecutor实践

第一步 :创建User实体和UserAddress实体

// User表
@Data
@Entity
@NoArgsConstructor
@AllArgsConstructor
@Builder
@ToString(exclude = "address")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Integer id;
    private String name;
    private String email;
    private Integer age;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    @OneToMany(mappedBy = "user",fetch = FetchType.LAZY)
    private List<UserAddress> address;
}
// Address表
@Entity
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = "user")
public class UserAddress {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String address;
    @ManyToOne(cascade = CascadeType.ALL)
    private User user;
}

第二步: 编写DAO层,JpaRepository已经继承QueryByExampleExceutor

public interface UserAddressRepo extends JpaRepository<UserAddress,Integer>  {
}

第三步:测试

@Test
public void test01 () {
    User user = User.builder()
            .name("jack")
            .email("123456@126.com")
            .age(20)
            .build();
    userAddressRepo.saveAll(Lists.newArrayList(UserAddress.builder()
            .address("shanghai").user(user).build(),UserAddress.builder()
            .address("beijing").user(user).build()));
}
@Test
public void testQBEE() throws JsonProcessingException {
    User user = User.builder()
            .name("jack")
            .age(20)
            .email("12345")
            .build();
    UserAddress userAddress = UserAddress.builder()
            .address("shanghai")
            .user(user)
            .build();
    ObjectMapper objectMapper = new ObjectMapper();
    // 创建匹配器,构建动态查询条件
    ExampleMatcher exampleMatcher = ExampleMatcher.matching()
            .withMatcher("user.email",ExampleMatcher.GenericPropertyMatchers.startsWith())
            .withMatcher("address",ExampleMatcher.GenericPropertyMatchers.startsWith());
    Page<UserAddress> u = userAddressRepo.findAll(Example.of(userAddress,exampleMatcher), PageRequest.of(0,2));
    System.out.println(objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(u));
}

一开始写这个代码的时候,我也比较懵逼, Example是什么?ExampleMatcher是什么? 下面我一一介绍。

1.4 Example语法详解

首先:我们先看Example的源码

public interface Example<T> {
   static <T> Example<T> of(T probe) {
      return new TypedExample<>(probe, ExampleMatcher.matching());
   }
   static <T> Example<T> of(T probe, ExampleMatcher matcher) {
      return new TypedExample<>(probe, matcher);
   }
   T getProbe();
   ExampleMatcher getMatcher();
   @SuppressWarnings("unchecked")
   default Class<T> getProbeType() {
      return (Class<T>) ProxyUtils.getUserClass(getProbe().getClass());
   }
}
  • probe:实际实体类,即查询条件的封装类(又可以理解为查询条件参数)
  • ExampleMatcher :匹配器,匹配特定字段的匹配规则。
  • Example:由probe 和 ExampleMatcher租车,由于创建查询,即组合查询参数和参数的匹配规则。

创建Example的两个方法 :

  • static Example of(T probe):需要一个实体参数,即查询条件。而里面的ExampleMatcher采用默认的ExamoleMatcher.matching(); 表示忽略NULL,所有字段采用精准匹配
  • static Example of(T probe, ExampleMatcher matcher):需要两个参数构建Example,也就表示ExampleMatcher自由组合规则,正如我们上面的测试用例里面的代码一样。

1.5 ExampleMatcher语法分析

上图是ExampleMatcher向外暴露的方法,我们只要关心返回值为ExampleMatcher类型的方法。

其中有三个方法我们需要注意一下:

static ExampleMatcher matching() {
   return matchingAll();
}
static ExampleMatcher matchingAll() {
   return new TypedExampleMatcher().withMode(MatchMode.ALL);
}

上述的这两种方法表达的意思是一样的。两者采用的都是MatcheMode.ALL的模式,即AND模式,生成的SQL如下:

Hibernate: select count(useraddres0_.id) as col_0_0_ from user_address useraddres0_ inner join user user1_ on useraddres0_.user_id=user1_.id where (useraddres0_.address like ? escape ?) and user1_.name=? and (user1_.email like ? escape ?) and user1_.age=20

可以看到,这些查询条件都是AND的关系。再看另外一种方法

static ExampleMatcher matchingAny() {
   return new TypedExampleMatcher().withMode(MatchMode.ANY);
}

当前方法与上面两个方法不一样的地方在于:第三个MatchMode.Any,表示查询条件是or的关系

Hibernate: select count(useraddres0_.id) as col_0_0_ from user_address useraddres0_ inner join user user1_ on useraddres0_.user_id=user1_.id where useraddres0_.address like ? escape ? or user1_.name=? or user1_.email like ? escape ? or user1_.age=20

以上就是初始化ExampleMatcher实例的方法,你在运用中需要注意and 和 or的关系

2、ExampleMatcher语法暴露常用方法

2.1 忽略大小写

// 哪些属性的paths忽略大小写,可以指定多个参数
ExampleMatcher withIgnoreCase(String... propertyPaths);
// 提供一个默认的实现方法,忽略大小写
default ExampleMatcher withIgnoreCase() {
   return withIgnoreCase(true);
}
// 默认忽略大小写的方式,默认false
ExampleMatcher withIgnoreCase(boolean defaultIgnoreCase);

2.2 NULL值的Property的处理方式

暴露的Null值处理方式如下所示:

ExampleMatcher withNullHandler(NullHandler nullHandler);

NullHandler枚举值如下所示:INCLUDE(包括)、IGNORE(忽略),

enum NullHandler {
   INCLUDE, IGNORE
}

需要注意的是: 标识作为条件的实体对象中,一个属性值(条件值)为NULL时,是否参与过滤;
当该选项值是INCLUDE时,标识仍参与过滤,会匹配数据库表中该字段值是NULL的记录;

若为IGNORE值,表示不参与过滤;

// 把(实体类中)NULL属性值作为查询条件
default ExampleMatcher withIncludeNullValues() {
   return withNullHandler(NullHandler.INCLUDE);
}
// 提供一个默认实现方法,忽略(实体类中)NULL属性
default ExampleMatcher withIgnoreNullValues() {
   return withNullHandler(NullHandler.IGNORE);
}

我们来看一下,把(实体类中)NULL属性值作为查询条件使用,执行的SQL如下所示:

Hibernate: select count(useraddres0_.id) as col_0_0_ from user_address useraddres0_ inner join user user1_ on useraddres0_.user_id=user1_.id where useraddres0_.id is null or useraddres0_.address like ? escape ? or user1_.name=? or user1_.email like ? escape ? or user1_.id is null or user1_.age=20

2.3 忽略某些属性列表,不参与查询过滤条件

// 忽略某些属性(可以是多个),不参与查询过滤条件
ExampleMatcher withIgnorePaths(String... ignoredPaths);

2.4 字符串默认的匹配规则

ExampleMatcher withStringMatcher(StringMatcher defaultStringMatcher);

默认字符串的匹配方式有以下几种 ,如下所示:

enum StringMatcher {
   DEFAULT,
   EXACT,
   STARTING,
   ENDING,
   CONTAINING,
   REGEX;
}

DEFAULT:默认,作用和EXACT一样
EXACT:相等
STARTING:开始匹配
ENDING:结束匹配
CONTAINING:包含、模糊匹配
REGEX:正则表达式

使用方法如下

withStringMatcher(ExampleMatcher.StringMatcher.ENDING)

或指定某些字符串属性匹配规则

ExampleMatcher withMatcher(String propertyPath, GenericPropertyMatcher genericPropertyMatcher);

3、实践出真理

就从上面介绍的方法,我们手动练习一下。

新建一张Dog表

@Data
@Entity
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "tb_dog")
public class Dog {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(columnDefinition = "int(11) NOT NULL COMMENT '主键' ")
    private Integer id;
    @Column(columnDefinition = "varchar(30) DEFAULT '' COMMENT '宠物名'")
    private String name;
    @Column(columnDefinition = "int(11) DEFAULT NULL COMMENT '年龄'")
    private Integer age;
}

3.1 AND查询

解释:根据当前dog对象的属性值作为查询条件去查询

@Test
public void testBy01(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .build();
    // AND 查询
    ExampleMatcher matcher = ExampleMatcher.matching(); //ExampleMatcher.matchingAll()  也可以
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

Hibernate: select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_ from tb_dog dog0_ where dog0_.name=? and dog0_.age=2

3.2 OR 查询

解释:根据当前dog对象的属性值作为查询条件去查询

@Test
public void testBy02(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .build();
    // OR 查询
    ExampleMatcher matcher = ExampleMatcher.matchingAny();
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_ from tb_dog dog0_ where dog0_.name=? or dog0_.age=2

3.3 忽略大小写查询

解释:指定"name"属性忽略大小写

@Test
public void testBy03(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withIgnoreCase("name");
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_ from tb_dog dog0_ where lower(dog0_.name)=? and dog0_.age=2

在Dog表中添加type字段

@Column(columnDefinition = "varchar(20) DEFAULT NULL COMMENT '种类'")
private String type;

3.3.1 忽略大小写 不指定属性

解释:不指定属性,默认为所有查询字符串条件加上忽略大小写条件

@Test
public void testBy04(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withIgnoreCase();
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where lower(dog0_.name)=? and lower(dog0_.type)=? and dog0_.age=2

3.4 NULL值的处理

3.4.1 NULL属性值作为查询条件

解释:把(实体类中)NULL属性值作为查询条件使用

@Test
public void testBy05(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withIgnoreCase()
                    .withIncludeNullValues();
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where lower(dog0_.type)=? and (dog0_.id is null) and dog0_.age=2 and lower(dog0_.name)=?

3.4.2 忽略(实体类中)NULL属性

解释:把(实体类中)NULL属性值忽略

@Test
public void testBy06(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withIgnoreNullValues();
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where dog0_.name=? and dog0_.type=? and dog0_.age=2

3.5 忽略某些属性不做筛选

解释:把(实体类中)某些属性忽略掉,不做筛选

@Test
public void testBy07(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    // 忽略掉"name" 和 "type"两个属性
    ExampleMatcher matcher = ExampleMatcher.matching()
            .withIgnorePaths("name","type");
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where dog0_.age=2

3.6 字符串匹配规则

3.6.1 DEFAULT和EXACT 相等

解释:把(实体类中)所有字符串属性匹配规则设置为 EXACT (相等)

@Test
public void testBy08(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
                     // 字符串属性提供的匹配规则 EXACT相等
                    .withStringMatcher( ExampleMatcher.StringMatcher.EXACT);
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where dog0_.name=? and dog0_.age=2 and dog0_.type=?

3.6.2 STARTING和ENDING 模糊查询【开始匹配(?1 + %) 和 结束匹配(% + ?1 )) 】

解释:把(实体类中)所有字符串属性匹配规则设置为 STARTING/ENDING (模糊查询)

public void testBy09(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
                     // 设置为开始匹配
                    .withStringMatcher(ExampleMatcher.StringMatcher.STARTING);
                     // 设置为结束匹配
                  //.withStringMatcher(ExampleMatcher.StringMatcher.ENDING);
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where dog0_.age=2 and (dog0_.type like ? escape ?) and (dog0_.name like ? escape ?)

3.6.3 Containing 包含模糊匹配【% + ?1 + %】

解释:把(实体类中)所有字符串属性匹配规则设置为 Containing (包含模糊查询)

@Test
public void testBy11(){
    Dog dog = Dog.builder()
            .name("TIMI")
            .age(2)
            .type("L")
            .build();
    ExampleMatcher matcher = ExampleMatcher.matching()
             // 包含模糊查询
            .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING);
    System.out.println(dogRepo.findAll(Example.of(dog, matcher)));
}

执行SQL结果如下所示:

select dog0_.id as id1_3_, dog0_.age as age2_3_, dog0_.name as name3_3_, dog0_.type as type4_3_ from tb_dog dog0_ where dog0_.age=2 and (dog0_.type like ? escape ?) and (dog0_.name like ? escape ?)

以上就是Spring Data JPA系列QueryByExampleExecutor使用详解的详细内容,更多关于Spring Data JPA QueryByExampleExecutor的资料请关注我们其它相关文章!

(0)

相关推荐

  • Spring Data JPA 注解Entity关联关系使用详解

    目录 1.OneToOne关联关系 1.1 解读OneToOne源码 1.2 mappedBy 注意事项 1.3 CascadeType 用法 1.4 orphanRemoval属性用法 1.5 orphanRemoval 和 CascadeType.REMOVE的区别 2.@JoinColumns & @JoinColumn 3.@ManyToOne & @OneToMany 3.1 Lazy机制 4.ManyToMany 4.1 利用@ManyToOne 和 @OneToMany表达多

  • SpringDataJpa的使用之一对一、一对多、多对多 关系映射问题

    目录 SpringDataJpa的使用 -- 一对一.一对多.多对多 关系映射 项目依赖 项目配置 sql文件(MySQL版) 级联关系简述 @OneToOne 一对一 关系映射 1.无中间表,维护方添加外键,被维护方添加对应项 2.无中间表,维护方添加外键,被维护方不添加对应项 3.有中间表,维护方不添加外键,被维护方不添加对应项 @OneToMany.@ManyToOne 一对多 关系映射 1.无中间表,多方维护并添加外键,一方被维护 2.有中间表,多方维护,一方被维护 3.无中间表,多方维

  • Spring Data Jpa返回自定义对象的3种方法实例

    目录 方法一.简单查询直接new对象 方法二.Service层使用EntityManager 方法三.Dao层使用Map接收自定义对象 总结 tasks表对应的Entity @Entity @NoArgsConstructor @AllArgsConstructor @Table(name = "tasks") @Data public class Tasks extends BaseEntity { @Id @GeneratedValue(strategy = GenerationT

  • Spring Data JPA系列JpaSpecificationExecutor用法详解

    目录 1.JpaSpecificationExecutor用法 2.JpaSpecificationExecutor语法详解 2.1 Specification 接口 2.2 Root< User >root 2.3 CriteriaQuery<?> query 2.4 CriteriaBuilder cb 在上一篇文章中,我们介绍了QueryByExampleExecutor动态查询的方法,那么今天我们来学习JpaSpecificationExecutor的详细用法. 1.Jpa

  • Spring Data JPA注解Entity使用示例详解

    目录 1.JPA协议中关于Entity的相关规定 需要注意的是: 2.常用注解 2.1 JPA支持的注解 2.2 常用注解 3.联合主键 3.1 @IdClass 3.2 @Embeddable与@EmbeddedId注解使用 3.3 两者的区别是什么? 1.JPA协议中关于Entity的相关规定 (1)实体是直接进行数据库持久化操作的领域对象(即一个简单的POJO),必须通过@Entity注解进行标示. (2)实体必须有一个 public 或者 projected的无参数构造方法. (3)持久

  • Spring Boot 整合持久层之Spring Data JPA

    目录 整合Spring Data JPA 1. 创建数据库 2. 创建项目 3. 数据库配置 4. 创建实体类 5. 创建 BookDao 接口 6. 创建 BookService 7. 创建 BookController 8. 测试 整合Spring Data JPA JPA (Java Persistence API)和 Spring Data 是两个范畴的概念. Hibernate 是一个 ORM 框架,JPA 则是一种ORM,JPA 和 Hibernate 的关系就像 JDBC 与 JD

  • Spring Data JPA系列QueryByExampleExecutor使用详解

    目录 1.QueryByExampleExecutor用法 1.1 介绍 1.2 QueryByExampleExecutor接口 1.3 QueryByExampleExecutor实践 1.4 Example语法详解 1.5 ExampleMatcher语法分析 2.ExampleMatcher语法暴露常用方法 2.1 忽略大小写 2.2 NULL值的Property的处理方式 2.3 忽略某些属性列表,不参与查询过滤条件 2.4 字符串默认的匹配规则 3.实践出真理 3.1 AND查询 3

  • Spring data jpa的使用与详解(复杂动态查询及分页,排序)

    一. 使用Specification实现复杂查询 (1) 什么是Specification Specification是springDateJpa中的一个接口,他是用于当jpa的一些基本CRUD操作的扩展,可以把他理解成一个spring jpa的复杂查询接口.其次我们需要了解Criteria 查询,这是是一种类型安全和更面向对象的查询.而Spring Data JPA支持JPA2.0的Criteria查询,相应的接口是JpaSpecificationExecutor. 而JpaSpecifica

  • 详解Spring Data JPA系列之投影(Projection)的用法

    本文介绍了Spring Data JPA系列之投影(Projection)的用法,分享给大家 在JPA的查询中,有一个不方便的地方,@Query注解,如果查询直接是 Select C from Customer c ,这时候,查询的返回对象就是Customer这个完整的对象,包含所有字段,对于我们的示例并没有什么问题,但是对于比较庞大的domain类,这个查询时就比较要命,并不是所有的字段都能用到,比较头疼.另外,如果定义 select c.firstName as firstName,c.la

  • spring boot + jpa + kotlin入门实例详解

    spring boot +jpa的文章网络上已经有不少,这里主要补充一下用kotlin来做. kotlin里面的data class来创建entity可以帮助我们减少不少的代码,比如现在这个User的Entity,这是Java版本的: @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; private String firstName; private S

  • Spring Data JPA 简单查询--方法定义规则(详解)

    一.常用规则速查 1 And 并且 2 Or   或 3 Is,Equals 等于 4 Between   两者之间 5 LessThan 小于 6 LessThanEqual   小于等于 7 GreaterThan 大于 8 GreaterThanEqual   大于等于 9 After 之后(时间) > 10 Before 之前(时间) < 11 IsNull 等于Null 12 IsNotNull,NotNull 不等于Null 13 Like 模糊查询.查询件中需要自己加 % 14

  • Spring Data Jpa的四种查询方式详解

    这篇文章主要介绍了Spring Data Jpa的四种查询方式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.调用接口的方式 1.基本介绍 通过调用接口里的方法查询,需要我们自定义的接口继承Spring Data Jpa规定的接口 public interface UserDao extends JpaRepository<User, Integer>, JpaSpecificationExecutor<User> 使用这

  • Spring Data JPA框架的Repository自定义实现详解

    目录 1. Spring Data Repository自定义实现 1.1 自定义特殊repository 1.2 配置类 1.3 解决歧义 1.4 手动装配 1.5 自定义Base Repository 1. Spring Data Repository自定义实现 Spring Data提供了各种选项来创建查询方法,只需少量编码.但是当这些选项不能满足你的需求时,你也可以为资源库方法提供你自己的自定义实现.本节主要介绍如何做到这一点. 1.1 自定义特殊repository 要用自定义的功能实

  • 详解Spring Data JPA中Repository的接口查询方法

    目录 1.查询方法定义详解 2.搜索查询策略 3.查询创建 4.属性表达式 5.特殊参数处理 6.限制查询结果 7. repository方法返回Collections or Iterables 8.repository方法处理Null 9.查询结果流 10.异步查询结果 1.查询方法定义详解 repository代理有两种方式从方法名中派生出特定存储查询. 通过直接从方法名派生查询. 通过使用一个手动定义的查询. 可用的选项取决于实际的商店.然而,必须有一个策略来决定创建什么实际的查询. 2.

随机推荐