WebFlux的探索与实战 - r2dbc的分页查询

一时失言乱红尘 2023-09-24 21:21 21阅读 0赞

### 前言 ###

虽然响应式API更加适合流式列表的查询，但是分页这东西可是很常见的。

也没什么前言可说，反正就是一篇介绍如何在 [Spring WebFlux][] 中使用 [Spring Data R2DBC][] 进行分页查询的文章。如果喜欢，还望点个赞喵。

> 文章会从创建项目开始，你要是没啥兴趣，就往下划划。

### 准备 ###

总而言之，先创建个项目，并且要加上 WebFlux 、R2DBC 和一个支持 R2DBC 的数据库驱动。至于驱动的选择，你可以去 [R2DBC官方网站的这里][R2DBC] 看看。

你可以去 [start.spring.io][] 去整个项目下来，我选择使用 gradle 构建项目，这里是我的项目配置：

**gradle.build.kts**

plugins {
        java
        id("org.springframework.boot") version "3.0.3"
        id("io.spring.dependency-management") version "1.1.0"
    }
    
    group = "com.example"
    version = "0.0.1-SNAPSHOT"
    java.sourceCompatibility = JavaVersion.VERSION_17
    
    configurations {
        compileOnly {
            extendsFrom(configurations.annotationProcessor.get())
        }
    }
    
    repositories {
        mavenCentral()
    }
    
    dependencies {
        compileOnly("org.projectlombok:lombok")
        implementation("org.springframework.boot:spring-boot-starter-data-r2dbc")
        implementation("org.springframework.boot:spring-boot-starter-webflux")
        runtimeOnly("com.h2database:h2")
        runtimeOnly("io.r2dbc:r2dbc-h2")
        annotationProcessor("org.projectlombok:lombok")
        testImplementation("org.springframework.boot:spring-boot-starter-test")
        testImplementation("io.projectreactor:reactor-test")
        testRuntimeOnly("com.h2database:h2")
        testRuntimeOnly("io.r2dbc:r2dbc-h2")
    }
    
    tasks.withType<Test> {
        useJUnitPlatform()
    }
    复制代码

这里我选择使用 [H2][] 数据库作为演示用的数据库，其他内容一律默认。

### 实体类与Repository ###

按照惯例，首先建个表用作示例：

**schema.sql**

DROPTABLE IF EXISTS foo;
    
    CREATETABLE IF NOTEXISTS foo(
        id int auto_increment notnullprimary key comment 'id',
        name varchar(20) notnulldefault'' comment '名称',
        size intnotnulldefault0 comment '大小'
    )
    复制代码

**data.sql**

INSERTINTO foo(name, size) VALUES ('name1', 1);
    INSERTINTO foo(name, size) VALUES ('name2', 2);
    INSERTINTO foo(name, size) VALUES ('name3', 3);
    INSERTINTO foo(name, size) VALUES ('name4', 4);
    INSERTINTO foo(name, size) VALUES ('name5', 114);
    INSERTINTO foo(name, size) VALUES ('name6', 514);
    INSERTINTO foo(name, size) VALUES ('name7', 19);
    INSERTINTO foo(name, size) VALUES ('name8', 10);
    INSERTINTO foo(name, size) VALUES ('name9', 11);
    INSERTINTO foo(name, size) VALUES ('name10', 12);
    INSERTINTO foo(name, size) VALUES ('name11', 13);
    INSERTINTO foo(name, size) VALUES ('name12', 14);
    INSERTINTO foo(name, size) VALUES ('name13', 15);
    INSERTINTO foo(name, size) VALUES ('name14', 16);
    INSERTINTO foo(name, size) VALUES ('name15', 17);
    复制代码

foo 是什么意思呢？我也不清楚，但是反正我们这次要去分页查询这个 foo 的表。

接下来，整个对应的实体类吧：

/**
     * 数据库 foo 对应实体类
     *
     * @param id   主键
     * @param name 名称
     * @param size 大小
     */publicrecordFoo(@Id Integer id, String name, Integer size) {
    }
    复制代码

然后给这个实体类提供一个对应的 Repository 实现。或者更准确的说，是 ReactiveRepository 的实现：

/**
     * {@link Foo} 的 Repository 实现
     * @author ForteScarlet
     */@RepositorypublicinterfaceFooRepositoryextendsR2dbcRepository<Foo, Integer> {
    }
    复制代码

顺带一提，R2dbcRepository<T, ID> 实现了下述三个基础接口：

*  ReactiveCrudRepository<T, ID>

*  ReactiveSortingRepository<T, ID>

*  ReactiveQueryByExampleExecutor<T>

那么这样就完成了吗？并没有。通常情况下，一个最简化的、整体性的分页数据应该包括 数据总量 和 分页数据列表 这两个信息，那么让我们首先来提供一个 Paged 类型：

/**
     * 分页数据体
     *
     * @param total 数据总量
     * @param data 数据列表
     */publicrecordPaged<T>(long total, List<T> data) {
    }
    复制代码

接下来，因为我们之前的 FooRepository 中已经包含了查询数据总量的 count，所以接下来我们只需要一个查询分页列表数据的方法就好了。十分幸运，[R2DBC Repositories 的 Query Methods][R2DBC Repositories _ Query Methods] 支持我们直接这么写：

@RepositorypublicinterfaceFooRepositoryextendsR2dbcRepository<Foo, Integer> {
    
        /**
         * 分页查询 foo
         * @param pageable 分页信息
         * @return paged foo flux
         */
        Flux<Foo> findAllBy(Pageable pageable);
    
    }
    复制代码

直接在接口中增加一个如上所示的 findAllBy 并提供一个分页参数即可。当然，因为我们在用 r2dbc，所以返回值应该是响应式的 Flux 类型。

这里的 Pageable 是Spring所提供的类型，所以可以直接拿来用。

接下来让我们来试试效果。先查询总数，再查询列表，然后将他们合并为一个 Paged:

@SpringBootTestclassWebfluxR2dbcPageableDemoApplicationTests {
    
        @TestvoidpagedTest(@Autowired FooRepository repository) {
            // 第一页的三条数据varpaged= PageRequest.of(0, 2);
            repository.count().flatMap(total -> repository
                            .findAllBy(paged)
                            .collectList()
                            .map(list -> newPaged<>(total, list)))
                    .as(StepVerifier::create)
                    .consumeNextWith(System.out::println) // 控制台输出
                    .verifyComplete();
        }
    }
    复制代码

输出:

Paged[total=15, data=[Foo[id=1, name=name1, size=1], Foo[id=2, name=name2, size=2]]]
    复制代码

在这个单元测试中，我们首先准备了一个代表 第一页的三条数据 的分页信息。其中，PageRequest 是Spring提供的 Pageable 的一个基本的实现类，所以直接借来用了。

我们首先通过 repository.count 查询数据库数据总数 Mono<Integer>, 再通过 flatMap 进行下一步，也就是查询列表。

查询列表使用了我们之前的 findAllBy(Pageable)，然后使用 collectList 将其收集为一个 Mono<List<Foo>> 。

之后便是将总数和列表合并为了 Paged，然后交给下游。

还是蛮简单的，不是吗？

### 简单条件查询 ###

但是仅此而已吗？有些时候我们希望分页查询的结果是存在条件的，比如我们想要根据 name 的**包含查询**来查询结果。那么接下来让我们来对 FooRepository 稍作调整，添加几个新函数：

/**
     * 分页查询包含 name 的 foo
     * @param name Foo的name，包含查询
     * @param pageable 分页信息
     * @return paged foo flux
     */
    Flux<Foo> findAllByNameContains(String name, Pageable pageable);
    
    /**
     * 查询包含 name 的 foo 总数
     * @param name Foo的name，包含查询
     * @return count
     */
    Mono<Long> countByNameContains(String name);
    复制代码

可以看到， 新的两个函数与之前的不同的是，它们都是以 ByNameContains 结尾，并且都多了一个 String name 参数。

这里的 ByNameContains 是 Spring Repositories Query Methods 的关键字(keyword)之一，Spring会根据你的关键字自行处理SQL。更多的关键字你可以去[它们的文档][R2DBC Repositories _ Query Methods] 阅读，IDEA的智能提示也会帮你一把：

![format_png][]

这些就是另外的话题了.回到正题，让我们再来试试这加了条件的分页查询是如何的：

@TestvoidselectByNameTest(@Autowired FooRepository repository) {
        // 第一页的三条数据varpaged= PageRequest.of(0, 2);
        // 查询包含 'name1' 的内容
        repository.countByNameContains("name1").flatMap(total -> repository
                        .findAllByNameContains("name1", paged)
                        .collectList()
                        .map(list -> newPaged<>(total, list)))
                .as(StepVerifier::create)
                .consumeNextWith(System.out::println) // 控制台输出
                .verifyComplete();
    }
    复制代码

与之前的测试用例没什么太大的区别，只不过是更换了一下方法名，然后添加了一个新的参数。

控制台输出:

2023-03-01T12:38:49.072+08:00 DEBUG 21376 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT COUNT(FOO.ID) FROM FOO WHERE FOO.NAME LIKE $1]
    2023-03-01T12:38:49.089+08:00 DEBUG 21376 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT FOO.ID, FOO.NAME, FOO.SIZE FROM FOO WHERE FOO.NAME LIKE $1 LIMIT 2]
    Paged[total=7, data=[Foo[id=1, name=name1, size=1], Foo[id=10, name=name10, size=12]]]
    复制代码

从 DEBUG 日志可以看到，Spring生成的SQL中为我们添加了 WHERE FOO.NAME LIKE $1 的查询条件，这也就说明我们的方法是可行的。

### 实体Example查询? ###

如果你有更高的追求，你希望直接通过实体类作为参数载体查询，并且当 name 不为null的时候才进行查询，这时候如果直接用 Query Methods 可能就不太好用了。

还记得之前提到的吗？ FooRepository 继承了 R2dbcRepository，而它又继承了 ReactiveQueryByExampleExecutor。此时，也许你会觉得：我们可以使用 Example 来查询结果嘛！

varfoo=newFoo(null, "name", 1);
    varexample= Example.of(foo,
            // 所有条件都需要，简单来说大概就是条件通过 AND 连接
            ExampleMatcher.matchingAll()
                    // 如果属性为null，忽略它
                    .withIgnoreNullValues()
                    // 对于 name 属性，使用 contains 策略，简单来说就是模糊查询
                    .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains());
    );
    复制代码

观察上述代码，我们通过一个 foo 构建了一个 Example 实例。这个 Example 代表：

*  如果 foo 中某个属性为null，则SQL条件中不出现

*  foo.name 使用包含策略进行查询

*  各条件使用 AND 连接

OK, 准备好 Example 之后，要怎么使用呢？ ReactiveQueryByExampleExecutor 中存在各种通过 Example 查询的函数，因此 count 可以直接使用：

Mono<Long> count = repository.count(example);
    // ...复制代码

列表查询也可以直接使用：

Flux<Foo> all = repository.findAll(example);
    // ...复制代码

等一下，分页哪里去了？

是的， ReactiveQueryByExampleExecutor 并没有提供使用 Example 配合 Pageable 的函数。那么是不是可以再次借助 Query Methods 来实现呢？

/**
     * 分页查询包含 name 的 foo ...?
     */
    Flux<Foo> findAllByExample(Example<Foo> example, Pageable pageable);
    复制代码

但是很遗憾，这种方式并行不通，你除了会得到一个异常以外，恐怕不会有什么其他结果。

### 实体Example查询 ###

那么我们应该怎么有效利用 Example 呢？这时候就不能再仰仗 Repository 了，这次我们要使用 R2dbcEntityTemplate。

首先来解决分页列表查询的问题，这次先给结果：

@TestvoidselectByExampleTest(
            @Autowired R2dbcEntityTemplate template
    ) {
        varfoo=newFoo(null, "name1", 1);
        varexample= Example.of(foo,
                // 所有条件都需要，简单来说大概就是条件通过 AND 连接
                ExampleMatcher.matchingAll()
                        // 如果属性为null，忽略它
                        .withIgnoreNullValues()
                        // 对于 name 属性，使用 contains 策略，简单来说就是模糊查询
                        .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains())
        );
        
        RelationalExampleMapperrelationalExampleMapper=newRelationalExampleMapper(template.getConverter().getMappingContext());
        varpage= PageRequest.of(0, 2);
        Queryquery= relationalExampleMapper.getMappedExample(example).with(page);
        template.select(query, Foo.class)
                .collectList()
                .as(StepVerifier::create)
                .consumeNextWith(System.out::println) // 控制台输出
                .verifyComplete();
    }
    复制代码

可以注意到，这次我们直接注入了一个 R2dbcEntityTemplate，并在过程中构建了一个 RelationalExampleMapper:

RelationalExampleMapperrelationalExampleMapper=newRelationalExampleMapper(template.getConverter().getMappingContext());
    复制代码

它是干什么的呢？从名字上大概也能猜出来，它的作用是将一个 Example 转化为 Query 类型。这实际上也是 ReactiveQueryByExampleExecutor 提供的那些支持 Example 函数中偷偷做的事情。

RelationalExampleMapperrelationalExampleMapper=newRelationalExampleMapper(template.getConverter().getMappingContext());
    varpage= PageRequest.of(0, 2);
    Queryquery= relationalExampleMapper.getMappedExample(example).with(page);
    复制代码

结合之后几句代码一起看，RelationalExampleMapper 将 Example 转化为了 Query，并通过 .with(page) 为其增加了分页信息，这样我们就得到了一个既有条件又能分页的 Query 了。

之后便可以借助 R2dbcEntityTemplate 进行查询了：

template.select(query, Foo.class) // 使用 query 查询 Foo 对应的表
                    .collectList()
                    .as(StepVerifier::create)
                    .consumeNextWith(System.out::println) // 控制台输出
                    .verifyComplete();
    复制代码

输出：

2023-03-01T13:13:23.002+08:00 DEBUG 11604 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT FOO.* FROM FOO WHERE (FOO.NAME LIKE $1) AND (FOO.SIZE = $2) LIMIT 2]
    [Foo[id=1, name=name1, size=1]]
    复制代码

可以看到实际生成的SQL中的确出现了我们所希望的出现的条件，以及结尾的分页。

那么二者结合一下，便可以得到使用 Example 进行分页查询的方案：

@TestvoidselectByExampleTest(@Autowired R2dbcEntityTemplate template) {
        // 查询条件varfoo=newFoo(null, "name1", 1);
        varexample= Example.of(foo,
                // 所有条件都需要，简单来说大概就是条件通过 AND 连接
                ExampleMatcher.matchingAll()
                        // 如果属性为null，忽略它
                        .withIgnoreNullValues()
                        // 对于 name 属性，使用 contains 策略，简单来说就是模糊查询
                        .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains())
        );
        varrelationalExampleMapper=newRelationalExampleMapper(template.getConverter().getMappingContext());
        varpage= PageRequest.of(0, 2);
        varquery= relationalExampleMapper.getMappedExample(example).with(page);
        // 先根据条件查询总数
        template.count(query, Foo.class)
                // 再根据条件查询分页列表
                .flatMap(total -> template.select(query, Foo.class)
                        // 将总数与列表合并为 Paged
                        .collectList().map(list -> newPaged<>(total, list)))
                .as(StepVerifier::create)
                .consumeNextWith(System.out::println) // 控制台输出
                .verifyComplete();
    }
    复制代码

输出:

2023-03-01T13:23:44.212+08:00 DEBUG 25652 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT COUNT(FOO.ID) FROM FOO WHERE (FOO.NAME LIKE $1) AND (FOO.SIZE = $2)]
    2023-03-01T13:23:44.230+08:00 DEBUG 25652 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT FOO.* FROM FOO WHERE (FOO.NAME LIKE $1) AND (FOO.SIZE = $2) LIMIT 2]
    Paged[total=1, data=[Foo[id=1, name=name1, size=1]]]
    复制代码

嗯，很不错的一次分页呢。

> 顺带一提，RelationalExampleMapper 在单数据源的情况下理论上只需要一个实例即可，此处每次都 new 是仅作演示。

### 复杂的条件查询 ###

但是你又开始不满足了，这时候你希望查询条件中，size 要大于匹配，也就是希望 size 生成的条件是 WHERE FOO.SIZE > $1 ，而不是直接等于。

怎么办？直接用 Example 吗？但可惜的是，Example 似乎并不支持更多的条件，它的大多数条件都是为 String 类型的字段准备的。

这时候，我们可能就需要手动构造 Query 了。

先给大家看看结果：

@TestvoidselectByQueryTest(@Autowired R2dbcEntityTemplate template) {
        // 查询条件varfoo=newFoo(null, "name", 4);
        varcriteria= Criteria.empty();
        if (foo.name() != null) {
            // 如果name不为null，则模糊查询name
            criteria = criteria.and("name").like("%" + foo.name() + "%");
        }
        if (foo.size() != null) {
            // 如果size不为null，则 size > $size
            criteria = criteria.and("size").greaterThan(foo.size());
        }
        // 构建Queryvarpage= PageRequest.of(0, 2);
        varquery= Query.query(criteria).with(page);
        // 先根据条件查询总数
        template.count(query, Foo.class)
                // 再根据条件查询分页列表
                .flatMap(total -> template.select(query, Foo.class)
                        // 将总数与列表合并为 Paged
                        .collectList().map(list -> newPaged<>(total, list)))
                .as(StepVerifier::create)
                .consumeNextWith(System.out::println) // 控制台输出
                .verifyComplete();
    }
    复制代码

你可能注意到了，在一开始我们构建了一个 Criteria.empty()，你可以将它理解为一个"开始"，它代表为一个没有条件的条件。

然后，根据我们的需要一步步的判断，并添加我们所需的条件。Criteria 能提供的查询条件要比 Example 丰富的多，当然了，它们的职能可能并不完全一样。

需要注意的是，Criteria 是一个不可变类，因此每次条件的增加后都是一个新的实例，你需要重新接收/保存这个结果。可不要忘了喔！

当你准备好一个最终的 Criteria 之后，你就可以通过它来构建一个 Query 了：

// 构建Query
    var page = PageRequest.of(0, 2);
    var query = Query.query(criteria).with(page);复制代码

这里我也顺手把分页信息一起放进去了。后面的查询就跟之前完全一样了，我们直接来看看控制台的结果吧：

2023-03-01T13:36:03.989+08:00 DEBUG 1752 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT COUNT(FOO.ID) FROM FOO WHERE FOO.NAME LIKE $1AND FOO.SIZE >= $2]
    2023-03-01T13:36:04.006+08:00 DEBUG 1752 --- [    Test worker] o.s.r2dbc.core.DefaultDatabaseClient     : Executing SQL statement [SELECT FOO.* FROM FOO WHERE FOO.NAME LIKE $1AND FOO.SIZE > $2 LIMIT 2]
    Paged[total=12, data=[Foo[id=4, name=name4, size=4], Foo[id=5, name=name5, size=114]]]
    复制代码

和我们预期的基本一样呢，真棒！

### 矮一点儿? ###

一开始便提到，我们在查询分页的时候，基本上都是需要进行两个查询的，一次数量，一次列表。通常情况下，我们其实不是非常需要关心这两个数据是否是真正准确的，它们之间存在一点点小小的误差是完全可以接受的，所以我们通常不会在一个事务中使用它们。

还记得我们上面那些示例的代码吗？它们是怎么合并 total 和 list 的呢？是通过 flatMap。但是你会发现，通过 flatMap 合并的时候，它们看上去是那么的"丑陋"：flatMap(total -> xxx.map(list -> new Paged(total, list)) 这一层 flatMap 一层 map 的，看的人头晕眼花。

有什么什么更..."矮"一些的写法呢？

或许你可以试试这个：

public Mono<Paged<Foo>> queryPaged(Query query) {
        return Mono.zip(
                template.count(query, Foo.class),
                template.select(query, Foo.class).collectList(),
                Paged::new
        );
    }
    复制代码

我们通过 Mono.zip 在前两个参数中直接将 count 和 select 两个查询压缩，并通过第三个参数 Paged::new 将它们的结果合并为 Paged 类型后返回。

怎么样，你会不会觉得这些写，让这代码变更明了、更"矮"了呢？但是 **先不要着急！** 这里面是有些 **隐患的**。

让我们加上事务注解，变成这样：

@Transactional(readOnly = true)public Mono<Paged<Foo>> queryPaged(Query query) {
        return Mono.zip(
                template.count(query, Foo.class),
                template.select(query, Foo.class).collectList(),
                Paged::new
        );
    }
    复制代码

此时如果再次运行，你就会惊奇的发现...咦？什么事都没有？你可能会觉得刚刚我只是虚张声势了一下，因为这并没有发生什么了不得的事情。

让我们来回忆一下。在开头，我提到我选择使用 H2 数据库作为演示。而如果我们将数据库驱动改为 MySQL（这里我选择使用 [**jasync-sql**][jasync-sql] 所提供的 r2dbc 支持），你**也许**就会发现，加上事务注解后这段代码不好使了。

你可能注意到了我的措辞：**也许**。因为这种情况可能与不同的数据库驱动的实现有关，有些驱动会解决这个问题，有些则不会，而又有些可能会在未来解决它。

那么到底是什么问题呢？你可以看看 [jasync-sql\#383][jasync-sql] 的讨论，这是我在使用的时候发现的一个小问题。

简单来说，当你通过 Mono.zip 或者 Mono.zipWith 连接两个查询的时候，它们之间可能并没有什么先后顺序，也就是说它们可能是一起开始的。这并不代表传统并发中的"并行"，但是这会导致两个查询的运行是"交叉"的。

如果它们不在同一个事务中，那么这两个查询可能会各占一个连接，此时问题倒是不大。而当两个查询运行在同一个事务中时，它们便会共享同一个连接。而这便**有可能**会导致其中一个查询先一步完成了查询，而后就关闭了连接，但是此时另一个查询还在忙着呢，就会出现问题。

至于哪个驱动有这个问题、为什么没有解决这个问题、怎么解决这个问题，那就要看它们的实现者了。按照上述的 \#383 来说，jasync-sql 反正是有这种隐患的。

引用 jasync-sql 开发者 oshai 的回复：

> ...  
> Is actually running 2 queries on the same connection, without waiting for the first one to complete.  
> The way to solve it is by using some chaining function (map, flatMap, etc') after the first select and only then run the second query.  
> （大意：实际上是在同一个连接上运行两个查询，而不等待第一个查询的完成。  
> 解决这个问题的方法是，在第一次查询后使用一些连锁函数（map、flatMap 等），然后才运行第二个查询。）  
> Usually each query can run in it's on connection, but transaction forces the same connection. Running two queries simultaneously on the same connection is not supported.  
> （大意：通常情况下，每个查询可以在它的连接（独立的连接）上运行，但事务会强制使用同一个连接。不支持在同一个连接上同时运行两个查询。）

总而言之，所以在进行分页查询的时候（也不止分页查询，而是任何可能运行多个SQL的地方）在使用事务的时候都需要"斟酌"一番。通过 then() 、flatMap 、map 这类可以体现"顺序"的方式更加...稳妥。

### 尾声 ###

这篇文章算是 水 写完了。

我也不知道自己总结的到不到位，说的对不对。如果你有学到什么，我很荣幸；如果我说错了什么或者遗漏了什么，欢迎在评论区友好交流，非常感谢！

那么，我们有缘再相会~

作者：法欧特斯卡雷特

链接：[https://juejin.cn/post/7205412097954922557][https_juejin.cn_post_7205412097954922557]

[Spring WebFlux]: https://link.juejin.cn?target=https%3A%2F%2Fdocs.spring.io%2Fspring-boot%2Fdocs%2Fcurrent%2Freference%2Fhtml%2Fweb.html%23web.reactive.webflux
[Spring Data R2DBC]: https://link.juejin.cn?target=https%3A%2F%2Fspring.io%2Fprojects%2Fspring-data-r2dbc
[R2DBC]: https://link.juejin.cn?target=https%3A%2F%2Fr2dbc.io%2Fdrivers%2F
[start.spring.io]: https://link.juejin.cn?target=https%3A%2F%2Fstart.spring.io%2F
[H2]: https://link.juejin.cn?target=http%3A%2F%2Fh2database.com%2F
[R2DBC Repositories _ Query Methods]: https://link.juejin.cn?target=https%3A%2F%2Fdocs.spring.io%2Fspring-data%2Fr2dbc%2Fdocs%2Fcurrent%2Freference%2Fhtml%2F%23r2dbc.repositories.queries
[format_png]: https://img-blog.csdnimg.cn/img_convert/d1d116d43734f8dfd1977da21c55566c.webp?x-oss-process=image/format,png
[jasync-sql]: https://link.juejin.cn?target=https%3A%2F%2Fgithub.com%2Fjasync-sql%2Fjasync-sql
[https_juejin.cn_post_7205412097954922557]: https://juejin.cn/post/7205412097954922557