---
# System prepended metadata

title: Spring Data JPA 非阻塞
tags: [chatgpt]

---

# Spring Data JPA 非阻塞

[TOC]

###### tags: `chatgpt`

---

## 使用 Spring Data JPA 能否 non-blocking

Spring Data JPA 默认情况下是不支持非阻塞的操作的，因为它是在基于 JPA 的同步 ORM 框架之上构建的。

不过，可以使用 Spring Data R2DBC（Reactive Relational Database Connectivity）来实现非阻塞的操作。Spring Data R2DBC 基于 Reactive Streams API 和 R2DBC 驱动程序规范，提供了对关系数据库的异步访问支持。

使用 Spring Data R2DBC，您可以通过编写 Reactive Repository 来执行非阻塞的操作。这些操作将返回 Mono 或 Flux 类型，这些类型支持响应式流式处理，因此可以异步地处理结果。

需要注意的是，使用 Spring Data R2DBC 需要您的数据库驱动程序实现 R2DBC 规范，因此并不是所有的数据库都能够与 Spring Data R2DBC 兼容。

## 我的數據庫是 PostgreSQL

PostgreSQL 支持 R2DBC 规范，因此可以使用 Spring Data R2DBC 与 PostgreSQL 进行非阻塞的操作。

在使用 Spring Data R2DBC 时，您需要使用与您的 PostgreSQL 数据库兼容的 R2DBC 驱动程序。Spring Data R2DBC 支持许多常见的 R2DBC 驱动程序，包括 PostgreSQL R2DBC 驱动程序。

如果您使用的是 Maven，则可以将以下依赖项添加到您的 `pom.xml` 文件中：

```xml
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-r2dbc</artifactId>
</dependency>
<dependency>
	<groupId>io.r2dbc</groupId>
	<artifactId>r2dbc-postgresql</artifactId>
</dependency>
```

然后，您可以像使用 Spring Data JPA 一样使用 Spring Data R2DBC 来定义您的 Repository 接口。但是，您需要确保您的 Repository 接口扩展了 **`ReactiveCrudRepository`** 接口，而不是 ~~`CrudRepository`~~ 接口。这样可以确保您的 Repository 接口支持响应式流式处理，并可以异步地处理结果。

例如，下面是一个使用 Spring Data R2DBC 定义 Repository 接口的示例：

```java
import org.springframework.data.repository.reactive.ReactiveCrudRepository;

public interface UserRepository extends ReactiveCrudRepository<User, Long> {
}
```

在这个示例中，`UserRepository` 接口扩展了 `ReactiveCrudRepository` 接口，并将 `User` 实体类作为实体类型，将 `Long` 类型作为实体 ID 类型。这个接口将自动生成一些基本的 CRUD 方法，并支持响应式流式处理。

请注意，使用 Spring Data R2DBC 可能需要您对代码进行一些修改，以适应异步操作的特性。您需要确保您的代码正确处理异步结果，并避免使用阻塞操作。

## 除了將 `Repository` 繼承 `ReactiveCrudRepository`，還有哪些地方跟傳統 blocking 的 JDBC 不同

使用 Spring Data R2DBC 进行非阻塞操作，与传统的 blocking JDBC 有以下不同之处：

1. 异步执行：与传统的 blocking JDBC 不同，Spring Data R2DBC 是异步执行的，不会阻塞主线程。当您执行一个操作时，它会立即返回一个 Mono 或 Flux 类型的结果，该结果是一个 Publisher，它可以异步地处理查询结果或操作完成事件。

2. 响应式流：与传统的 blocking JDBC 不同，Spring Data R2DBC 支持响应式流，您可以使用 Mono 或 Flux 类型的对象处理数据流。这使得您可以编写更简洁、更高效的代码来处理大量数据。

3. 非阻塞 I/O：Spring Data R2DBC 使用了基于 Reactive Streams API 的 R2DBC 驱动程序，这意味着它可以通过非阻塞 I/O 进行数据库访问。这种方式可以减少系统资源的使用，提高并发性能。

4. 异常处理：与传统的 blocking JDBC 不同，Spring Data R2DBC 的异常处理方式也不同。在 Spring Data R2DBC 中，异常是通过 Reactive Streams API 中的 onError 事件传播的。这意味着您需要处理 onError 事件，以便在操作失败时正确处理异常。

总的来说，Spring Data R2DBC 提供了一种全新的方式来处理数据库操作，它更适合于高并发、大规模的应用程序。不过，使用 Spring Data R2DBC 需要您具备异步编程的经验和知识，以便正确地处理响应式流和异常。

## 我想問的是，專案裡無論是代碼還是配置還有哪些地方不同

除了将 Repository 接口扩展为 ReactiveCrudRepository 之外，使用 Spring Data R2DBC 进行非阻塞操作的方式与使用传统的 blocking JDBC 有以下不同之处：

1. 数据库配置：如果您使用的是传统的 blocking JDBC，您需要配置 `DataSource` 和 `JdbcTemplate` 等传统的 JDBC 组件。而如果您使用 Spring Data R2DBC，则需要配置 R2DBC 数据库连接工厂和 R2DBC 驱动程序。这些组件是异步非阻塞的，可以提高应用程序的性能和可扩展性。例如，您可以使用 HikariCP、R2DBC PostgreSQL 驱动程序和 R2DBC PostgreSQL 数据库连接工厂来配置您的 PostgreSQL 数据库连接池。

2. 事务管理：与传统的 blocking JDBC 不同，Spring Data R2DBC 的事务管理是通过 Reactive Transaction API 实现的。在 Spring Data R2DBC 中，您可以使用 `ReactiveTransactionManager` 来管理事务。您可以使用 `ReactiveTransactionTemplate` 来执行事务性操作，这个模板将自动创建和提交事务。

3. 数据库查询：与传统的 blocking JDBC 不同，Spring Data R2DBC 支持响应式流，您可以使用 Mono 或 Flux 类型的对象处理数据流。在 Spring Data R2DBC 中，您可以使用 Query 接口来定义查询，使用 `R2dbcEntityTemplate` 或 `R2dbcRepository` 接口来执行查询。

4. 异常处理：与传统的 blocking JDBC 不同，Spring Data R2DBC 的异常处理方式也不同。在 Spring Data R2DBC 中，异常是通过 Reactive Streams API 中的 onError 事件传播的。这意味着您需要处理 onError 事件，以便在操作失败时正确处理异常。

5. 编写业务逻辑：在使用 Spring Data R2DBC 进行非阻塞操作时，您需要遵循响应式编程模型。这意味着您需要将业务逻辑分解为小的、可组合的函数单元，以便在使用 `Mono` 和 `Flux` 类型的对象时正确地处理数据流。

总的来说，使用 Spring Data R2DBC 进行非阻塞操作需要您具备异步编程的经验和知识，并且需要您对数据库配置、事务管理、查询、异常处理和业务逻辑的编写方式有一定的了解。但是，使用 Spring Data R2DBC 可以提高应用程序的性能和可扩展性，使您的应用程序更适合于高并发、大规模的场景。

## 假設有三個 `@Transactional(readOnly=false)` 方法 `a`、`b`、`c`，在 `a` 呼叫 `b` 跟 `c`，當 `c` 發生錯誤時會怎樣

如果在 `@Transactional(readOnly=false)` 方法 `a` 中调用了方法 `b` 和 `c`，而方法 `c` 抛出了异常，则方法 `a` 和方法 `b` 都会被**回滚**。这是因为方法 `a` 和方法 `b` 都在同一个事务中运行，而事务的默认行为是在抛出运行时异常时回滚事务。

回滚意味着所有在该事务中进行的操作都会被撤销，以便使数据保持一致性。在这种情况下，如果方法 `a` 和方法 `b` 在执行过程中进行了任何数据修改，这些修改都将被回滚，并且数据库将恢复到方法 `a` 开始执行时的状态。

需要注意的是，如果方法 `a` 或方法 `b` 自己抛出了异常，则整个事务也将回滚。因此，在使用 `@Transactional(readOnly=false)` 注解时，需要仔细考虑事务的边界，以便正确处理事务。如果方法 `a` 和方法 `b` 不需要在同一个事务中执行，则可以将它们标记为 `@Transactional(readOnly=true)` 或不使用 `@Transactional` 注解，以便让它们在自己的事务中运行。

## 我意思是三個方法都是 `@Transactional(readOnly=false)`，這樣當 `c` 方法拋出異常時 `b` 方法也會 rollback 嗎

是的，如果三个方法 `a`、`b`、`c` 都被标记为 `@Transactional(readOnly=false)`，那么它们将在同一个事务中运行。在这种情况下，如果方法 `c` 抛出了异常，那么整个事务将被回滚，包括方法 `a` 和方法 `b` 中所做的所有修改操作。

因此，即使方法 `b` 没有抛出异常，它所做的修改也会被回滚。这是因为事务的默认行为是在抛出运行时异常时回滚事务，而方法 `c` 抛出的异常会导致整个事务回滚，从而撤销所有在该事务中进行的修改操作，包括方法 `a` 和方法 `b` 中的操作。

如果您希望方法 `b` 在方法 `c` 抛出异常时不回滚，您可以将方法 `b` 标记为新的事务，例如使用 `@Transactional(propagation=Propagation.REQUIRES_NEW)` 注解来将方法 `b` 放在一个新的事务中。这样，当方法 `c` 抛出异常时，方法 `b` 所做的修改不会被回滚，只有方法 `c` 中的修改会被回滚。

# 能推薦 PostgreSQL 的 R2DBC driver 嗎？若是官方的更棒

PostgreSQL 官方推荐的 R2DBC 驱动程序是 PostgreSQL R2DBC，您可以在以下网址中找到它：https://github.com/pgjdbc/pgjdbc-ng。

此外，还有其他可用的 PostgreSQL R2DBC 驱动程序，包括：

- **Reactive PostgreSQL Client** - 这是一个由企业级支持的开源项目，提供了对 PostgreSQL 的非阻塞访问。它提供了一个简单的 API，允许您使用 Reactive Streams 和 Reactive Relational Database Connectivity (R2DBC) 进行异步访问。您可以在以下网址中找到它：https://github.com/eclipse-vertx/reactive-pg-client。

- **R2DBC Postgres** - 这是一个由 Spring Data 开发团队提供的开源项目，提供了对 PostgreSQL 的非阻塞访问。它是 R2DBC 驱动程序规范的一部分，并支持 Spring Data R2DBC。您可以在以下网址中找到它：https://github.com/r2dbc/r2dbc-postgresql。

无论您选择哪个驱动程序，都应该遵循最佳实践和安全性建议，以确保您的应用程序能够可靠地访问 PostgreSQL 数据库。

## 比較一下這三者

- **PostgreSQL R2DBC**：官方推荐的 PostgreSQL R2DBC 驱动程序，由 PostgreSQL JDBC 驱动程序的开发人员维护。它提供了完整的 R2DBC API 实现，可以让您使用 R2DBC 完全控制非阻塞 Postgres 连接。同时，它也具有高性能和稳定性。

- **Reactive PostgreSQL Client**：一个基于 Eclipse Vert.x 平台的 PostgreSQL R2DBC 驱动程序，提供了异步的、无阻塞的访问 PostgreSQL 数据库的能力。它提供了一个简单的 API，容易上手和使用，并且支持 Reactive Streams 和 Reactive Relational Database Connectivity（R2DBC）。同时，它也具有很好的性能和可扩展性。

- **R2DBC Postgres**：由 Spring Data 开发团队维护的 PostgreSQL R2DBC 驱动程序。它是 R2DBC 规范的一部分，支持 Spring Data R2DBC。它提供了可靠的、异步的、无阻塞的访问 PostgreSQL 数据库的能力，并且容易上手和使用。同时，它也支持开箱即用的 Connection Pool。

总的来说，如果您想要获得官方支持、稳定性和高性能，那么 PostgreSQL R2DBC 驱动程序是最佳选择。如果您使用 Eclipse Vert.x 平台，那么 Reactive PostgreSQL Client 可能更适合您。如果您使用 Spring Data R2DBC 或希望与 Spring 框架集成，那么 R2DBC Postgres 可能是最佳选择。无论您选择哪个驱动程序，都应该根据自己的需求进行评估，并且遵循最佳实践和安全性建议。

## 除去 Eclipse Vert.x 平台的 Reactive PostgreSQL Client，比較一下剩餘兩者的優缺點

PostgreSQL R2DBC 和 R2DBC Postgres 是两个非常受欢迎的 PostgreSQL R2DBC 驱动程序，它们都具有自己的优缺点，具体如下：

PostgreSQL R2DBC 的优缺点：

优点：

- 官方推荐和维护，具有很高的稳定性和兼容性。
- 完全支持 R2DBC API，提供完整的非阻塞 Postgres 连接控制。
- 具有高性能和可靠性。

缺点：

- 由于官方推荐和维护，因此可能存在更新较慢的问题。
- 与 Spring 框架集成可能需要更多的工作。
- R2DBC Postgres 的优缺点：

优点：

- 支持 R2DBC 规范，可与 Spring Data R2DBC 等其他 R2DBC 实现集成。
- 通过开箱即用的连接池来提高性能和可伸缩性。
- 易于上手和使用。

缺点：

- 可能没有官方推荐和维护的 PostgreSQL R2DBC 稳定和兼容性高。
- 相比于 PostgreSQL R2DBC，可能缺少一些高级功能和选项。

综上所述，如果您需要完整的 Postgres 非阻塞连接控制，并且希望获得官方支持和维护，那么 PostgreSQL R2DBC 是更好的选择。如果您需要更快的启动和连接速度，以及与 Spring 框架的集成，则 R2DBC Postgres 可能是更好的选择。无论您选择哪个驱动程序，都应该根据自己的需求进行评估，并且遵循最佳实践和安全性建议。

## 除了 `Repository` 繼承 `ReactiveCrudRepository`，剛提到使用 Spring Data R2DBC 需要对代码进行一些修改以适应异步操作的特性，請具體舉例

使用 Spring Data R2DBC 需要对代码进行一些修改以适应异步操作的特性。以下是一些可能需要修改的代码示例：

1. 返回类型

在使用 R2DBC 进行异步操作时，方法的返回类型应该是 `Mono<T>` 或 `Flux<T>`，而不是传统的阻塞类型，如 `T` 或 `List<T>`。例如，下面的代码片段演示了如何将 `findAll()` 方法从阻塞操作更改为异步操作：

```java
// 阻塞操作
public List<User> findAll() {
	return userRepository.findAll();
}

// 异步操作
public Flux<User> findAll() {
	return userRepository.findAll();
}
```

2. 异常处理

当使用异步操作时，异常处理也需要进行相应的修改。与传统的阻塞式操作不同，异步操作的异常处理应该使用 `onErrorResume()` 或 `onErrorReturn()` 等方法。例如，下面的代码片段演示了如何使用 `onErrorResume()` 处理异步操作中的异常：

```java
public Mono<User> findById(Long id) {
	return userRepository
		.findById(id)
		.onErrorResume(
			error -> Mono.empty()
		);
}
```

3. 参数传递

在异步操作中，方法调用的参数类型也需要进行相应的修改。例如，如果使用异步操作查询一个用户，可以将用户 ID 作为方法参数，而不是将其作为查询条件。例如，下面的代码片段演示了如何修改 `findById()` 方法的参数：

```java
// 阻塞操作
public User findById(Long id) {
	return userRepository.findById(id).orElse(null);
}

// 异步操作
public Mono<User> findById(Long id) {
	return userRepository.findById(id);
}
```

这些只是一些可能需要修改的代码示例，实际上在使用 Spring Data R2DBC 进行异步操作时，需要根据具体的情况进行相应的调整和修改。

## `ReactiveCrudRepository` 也支持所有 `JpaRepository` 的方法嗎？例如 Pagination 跟 `Specification`

`ReactiveCrudRepository` 提供了与 `JpaRepository` 相似的基本 CRUD 操作，例如 `findById()`、`findAll()`、`save()`、`deleteById()` 等。但是它不支持所有 `JpaRepository` 的方法。

在 `ReactiveCrudRepository` 中，分页查询使用的是 `Page` 或 `Pageable` 类型，而不是传统的 `Pageable`。因此，如果您要进行分页查询，可以使用 Spring Data 提供的 `PageRequest` 或 `Pageable` 类型，并将其传递给 `findAll()` 方法。例如：

```java
Pageable pageable = PageRequest.of(0, 10, Sort.by("name"));
Flux<User> users = userRepository.findAll(pageable);
```

对于查询条件的动态构建，`ReactiveCrudRepository` 不支持 `Specification` 类型。您可以使用类似 `QuerydslPredicateExecutor` 的其他接口来构建查询。例如，如果您想使用 Querydsl 进行查询，可以使用 `QuerydslPredicateExecutor` 接口来实现该功能，而不是使用 `ReactiveCrudRepository`。例如：

```java
public interface UserRepository extends ReactiveCrudRepository<User, Long>, QuerydslPredicateExecutor<User> {
	// ...
}
```

综上所述，`ReactiveCrudRepository` 提供了一组基本的异步 CRUD 操作，但如果您需要更复杂的查询和操作，可能需要考虑其他接口或自定义实现。

## 在 Spring Boot 專案如何配置 R2DBC，例如 `DataSource`，畢竟有時還是需要直接使用 `JdbcTemplate`

在 Spring Boot 中，配置 R2DBC 的方式与配置传统的 JDBC 数据源（`DataSource`）类似，需要添加相应的 R2DBC 驱动程序和配置数据库连接信息。下面是一个使用 PostgreSQL R2DBC 驱动程序的示例配置：

```properties
# 数据库连接配置
spring.r2dbc.url=r2dbc:postgresql://localhost:5432/mydatabase
spring.r2dbc.username=myuser
spring.r2dbc.password=mypassword

# 驱动程序依赖配置
# Spring Boot 2.4.x 及以上版本已经自动引入了 R2DBC 相关依赖，无需手动添加
# spring.r2dbc.driver=io.r2dbc.postgresql.PostgresqlConnectionFactory
# spring.r2dbc.initialization-mode=always

# 配置 JdbcTemplate 使用 R2DBC 数据源
spring.jdbc.template.deferred-query-cache=true
spring.jdbc.template.fetch-size=1000
spring.jdbc.template.max-rows=5000
spring.jdbc.template.query-timeout=30s
spring.jdbc.template.pool.max-size=10
spring.jdbc.template.pool.initial-size=1
spring.jdbc.template.pool.max-idle-time=600000
spring.jdbc.template.pool.validation-query=SELECT 1
spring.datasource.hikari.data-source=r2dbc:pool:postgresql://localhost:5432/mydatabase
spring.datasource.hikari.username=myuser
spring.datasource.hikari.password=mypassword
```

在上面的示例配置中，使用 `spring.r2dbc.url`、`spring.r2dbc.username` 和 `spring.r2dbc.password` 配置了 PostgreSQL 数据库的连接信息。同时，如果需要指定使用的 R2DBC 驱动程序，可以通过 `spring.r2dbc.driver` 属性进行配置，不过在 Spring Boot 2.4.x 及以上版本中已经自动引入了相应的 R2DBC 驱动程序，无需手动添加。如果需要在应用程序启动时自动执行 SQL 初始化脚本，可以通过 `spring.r2dbc.initialization-mode` 属性进行配置。

最后，如果您需要使用 `JdbcTemplate` 访问数据库，可以通过 `spring.jdbc.template` 和 `spring.datasource.hikari` 相关属性进行配置，其中 `spring.datasource.hikari.data-source` 配置了使用 R2DBC 数据源。配置完成后，您可以在应用程序中注入 `JdbcTemplate` 实例来访问数据库。例如：

```java
@Autowired
private JdbcTemplate jdbcTemplate;
```

注意，使用 `JdbcTemplate` 访问 R2DBC 数据库时，由于 JdbcTemplate 是基于 JDBC 技术的，因此可能会导致阻塞操作。如果您的应用程序需要完全遵循响应式编程模型，建议直接使用 R2DBC 提供的响应式操作 API。

## 所以 R2DBC 跟 `JdbcTemplate` 可以共存且 `JdbcTemplate` 可直接使用 R2DBC 的 `DataSource` 只是可能導致阻塞嗎

是的，R2DBC 和 `JdbcTemplate` 可以共存。R2DBC 提供的 `ConnectionFactory` 可以通过 `JdbcTemplate` 的构造函数注入，从而使得 `JdbcTemplate` 直接使用 R2DBC 的数据源。但是，如果在使用 `JdbcTemplate` 进行阻塞操作时，可能会导致整个线程阻塞，从而降低异步操作的效率。

因此，如果您的项目中同时需要使用 R2DBC 和 `JdbcTemplate`，建议将它们放在不同的线程池中运行，从而使得异步和阻塞操作不会相互干扰。另外，也可以使用 Reactor 的异步 JDBC 驱动来替代 `JdbcTemplate`，以获得更好的异步操作性能。

## 如何将它们放在不同的线程池中运行

在 Spring Boot 中，可以通过配置不同的 `TaskExecutor` 来将 R2DBC 和 `JdbcTemplate` 放在不同的线程池中运行。以下是一个示例：

```java
@Configuration
@EnableAsync
public class AsyncConfiguration implements AsyncConfigurer {

	@Bean(name = "r2dbcTaskExecutor")
	public ThreadPoolTaskExecutor r2dbcTaskExecutor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setCorePoolSize(10);
		executor.setMaxPoolSize(50);
		executor.setQueueCapacity(100);
		executor.setThreadNamePrefix("r2dbc-task-executor-");
		executor.initialize();
		return executor;
	}

	@Bean(name = "jdbcTaskExecutor")
	public ThreadPoolTaskExecutor jdbcTaskExecutor() {
		ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
		executor.setCorePoolSize(10);
		executor.setMaxPoolSize(50);
		executor.setQueueCapacity(100);
		executor.setThreadNamePrefix("jdbc-task-executor-");
		executor.initialize();
		return executor;
	}

	@Override
	public Executor getAsyncExecutor() {
		return r2dbcTaskExecutor();
	}

	@Override
	public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
		return new SimpleAsyncUncaughtExceptionHandler();
	}

	@Bean
	public JdbcTemplate jdbcTemplate(DataSource dataSource, @Qualifier("jdbcTaskExecutor") TaskExecutor taskExecutor) {
		return new JdbcTemplate(dataSource, taskExecutor);
	}
}
```

在上面的示例中，我们定义了两个不同的 `ThreadPoolTaskExecutor`，一个用于 R2DBC 的异步操作，另一个用于 `JdbcTemplate` 的异步操作。在 `JdbcTemplate` 的构造函数中，我们注入了名为 `jdbcTaskExecutor` 的线程池，这样 `JdbcTemplate` 就会使用该线程池进行异步操作。

注意，在使用 R2DBC 时，可以通过在 `Repository` 接口上使用 `@Async` 注解将异步方法放在 R2DBC 的线程池中运行，而无需再手动创建一个线程池。但是，使用 `@Async` 注解时要注意，如果在同一个方法内既有异步 R2DBC 操作又有阻塞的 `JdbcTemplate` 操作，可能会出现线程切换的问题，从而导致性能下降。因此，建议将异步 R2DBC 和异步 `JdbcTemplate` 操作放在不同的方法中，以充分利用异步操作的性能优势。

## 舉個使用 `@Async` 注解的實例

假设我们有一个 Spring Boot 应用程序，其中有一个 `UserService` 类，我们希望在其中添加一个方法，以便异步地执行某些任务。

首先，我们需要在启动类上添加 `@EnableAsync` 注解，以启用 Spring 的异步功能：

```java
@SpringBootApplication
@EnableAsync
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}
```

接下来，我们在 `UserService` 类中创建一个新的方法，使用 `@Async` 注解将其标记为异步执行：

```java
@Service
public class UserService {

	// ...

	@Async
	public CompletableFuture<User> createUser(User user) {
	// 执行一些耗时的操作，比如向数据库中插入新的用户数据
		return userRepository.save(user);
	}

	// ...
}
```

注意，`@Async` 注解的方法必须是 `public`，否则无法被 Spring 扫描并创建代理。

现在，当我们调用 `createUser` 方法时，它将在另一个线程中异步执行。我们可以在另一个服务或控制器中调用它：

```java
@RestController
public class UserController {

	private final UserService userService;

	public UserController(UserService userService) {
		this.userService = userService;
	}

	@PostMapping("/users")
	public CompletableFuture<User> createUser(@RequestBody User user) {
		return userService.createUser(user);
	}
}
```

## 这将使 Spring 在后台启动新线程，异步地执行 `createUser` 方法，并返回一个 `CompletableFuture` 对象，以便我们可以在需要的时候等待结果。

在同一个方法内既有 R2DBC 操作又有 `JdbcTemplate` 操作，如果使用了 `@Transactional` 注解，则在默认情况下会将它们都绑定到同一个事务中，这可能会导致阻塞，因为 R2DBC 和 `JdbcTemplate` 库是不同的异步和同步库。

为了解决这个问题，我们可以在方法上添加 `@Transactional` 注解，并使用 propagation 属性来指定新的事务应该在一个新的线程中启动。例如：

```java
@Service
public class MyService {

	private final R2dbcRepository r2dbcRepository;

	private final JdbcTemplate jdbcTemplate;

	public MyService(R2dbcRepository r2dbcRepository, JdbcTemplate jdbcTemplate) {
		this.r2dbcRepository = r2dbcRepository;
		this.jdbcTemplate = jdbcTemplate;
	}

	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public void myMethod() {
		// 使用 R2DBC 进行异步操作
		r2dbcRepository
			.findById(1L)
			.doOnNext(
				item -> System.out.println("Found item: " + item)
			)
			.block();

		// 使用 JdbcTemplate 进行同步操作
		jdbcTemplate.update("INSERT INTO my_table (id, name) VALUES (?, ?)", 1, "test");
	}
}
```

在上面的例子中，我们使用了 `@Transactional(propagation = Propagation.REQUIRES_NEW)` 注解，指示新的事务应该在一个新的线程中启动。这将使 R2DBC 和 `JdbcTemplate` 操作在不同的线程中执行，避免阻塞。

## 倘若這個例子中的 `JdbcTemplate` 操作拋出異常，R2DBC 的操作也會 rollback 嗎？要是先操作同步的 `JdbcTemplate` 再操作異步的 R2DBC 也會 rollback 嗎？

如果在上面的例子中，`JdbcTemplate` 操作抛出异常，整个事务都会回滚，包括之前异步操作的 R2DBC 操作。这是因为这两个操作是在同一个事务中执行的。

如果先操作同步的 `JdbcTemplate` 再操作异步的 R2DBC，当同步操作抛出异常时，整个事务都会回滚，包括异步操作的 R2DBC 操作。这是因为在默认情况下，Spring 会将同步和异步操作都绑定在同一个线程中，它们都处于同一个事务中。在这种情况下，任何一个操作抛出异常都会导致整个事务回滚。

为了避免这种情况，我们可以将同步和异步操作放在不同的事务中。可以使用 `TransactionTemplate` 或者使用 Spring 的编程式事务管理 API，在代码中显式地控制事务的边界。例如：

```java
@Service
public class MyService {

	private final R2dbcRepository r2dbcRepository;

	private final JdbcTemplate jdbcTemplate;

	private final TransactionTemplate transactionTemplate;

	public MyService(R2dbcRepository r2dbcRepository, JdbcTemplate jdbcTemplate, PlatformTransactionManager transactionManager) {
		this.r2dbcRepository = r2dbcRepository;
		this.jdbcTemplate = jdbcTemplate;
		this.transactionTemplate = new TransactionTemplate(transactionManager);
	}

	public void myMethod() {
		// 使用事务模板控制异步操作的事务边界
		transactionTemplate.execute(
			status -> {
				r2dbcRepository
					.findById(1L)
					.doOnNext(
						item -> System.out.println("Found item: " + item)
					)
					.block();
				return null;
			}
		);

		// 使用 JdbcTemplate 进行同步操作，放在另一个事务中
		transactionTemplate.execute(status -> {
			jdbcTemplate.update("INSERT INTO my_table (id, name) VALUES (?, ?)", 1, "test");
			return null;
		});
	}
}
```

在上面的例子中，我们使用 `TransactionTemplate` 来控制异步操作的事务边界，将异步操作和同步操作分别放在不同的事务中。这样，当同步操作抛出异常时，只会回滚同步操作的事务，不会影响异步操作的事务，因为它们是独立的。

## 這個範例中的注入能改為用 `@Autowired` 嗎

是的，这个例子中的依赖注入可以改为使用 `@Autowired` 注解。在 Spring Boot 中，`@Autowired` 注解可以用于自动装配 Spring Bean。下面是将 `JdbcTemplate` 和 `DatabaseClient` 注入到 `UserService` 中的示例代码：

```java
@Service
public class UserService {

	private final JdbcTemplate jdbcTemplate;

	private final DatabaseClient databaseClient;

	@Autowired
		public UserService(JdbcTemplate jdbcTemplate, DatabaseClient databaseClient) {
		this.jdbcTemplate = jdbcTemplate;
	this.databaseClient = databaseClient;
	}

	// ...
}
```

在这个示例中，`JdbcTemplate` 和 `DatabaseClient` 都是通过构造函数注入到 `UserService` 中的。使用 `@Autowired` 注解时，Spring 会自动查找类型匹配的 Bean，并将它们注入到构造函数参数中。

## 我想問的是能 `@Autowired` 而非透過構造函數注入嗎，包含 `TransactionTemplate`？

是的，你可以使用 `@Autowired` 注解将 `JdbcTemplate`、`DatabaseClient`、`TransactionTemplate` 等 Spring Bean 注入到你的服务类中，而不必通过构造函数注入。

以下是将 `JdbcTemplate`、`DatabaseClient` 和 `TransactionTemplate` 注入到服务类中的示例代码：

```java
@Service
public class MyService {

	@Autowired
	private JdbcTemplate jdbcTemplate;

	@Autowired
	private DatabaseClient databaseClient;

	@Autowired
	private TransactionTemplate transactionTemplate;

	//...
}
```

在这个示例中，`JdbcTemplate`、`DatabaseClient` 和 `TransactionTemplate` 都是通过字段注入到 `MyService` 中的。在 Spring Boot 中，你可以使用 `@Autowired` 注解将一个 Spring Bean 注入到另一个 Spring Bean 中。这里，Spring 会自动查找类型匹配的 Bean，并将它们注入到对应的字段中。

需要注意的是，使用字段注入时，需要确保注入的 Bean 已经被实例化。如果 Bean 还未被实例化，可能会导致空指针异常。因此，通常推荐使用构造函数注入。

## 如何確保 `TransactionTemplate` 已被離實例化

如果你要在 Spring Bean 中使用 `TransactionTemplate`，你可以通过将 `TransactionTemplate` 包装在一个 @PostConstruct 注解的方法中来确保它已被实例化。`@PostConstruct` 注解表示在 Bean 初始化完成后执行该方法。

以下是一个示例：

```java
@Service
public class MyService {

	private TransactionTemplate transactionTemplate;

	@Autowired
	private PlatformTransactionManager transactionManager;

	@PostConstruct
	public void init() {
		transactionTemplate = new TransactionTemplate(transactionManager);
	}

	//...
}
```

在这个示例中，我们首先在类中声明了一个 `TransactionTemplate` 对象，然后使用 `@Autowired` 注解注入了一个 `PlatformTransactionManager` 对象。在 `init()` 方法中，我们创建了一个新的 `TransactionTemplate` 实例，并将它赋值给 `transactionTemplate` 字段。

通过这种方式，我们可以确保 `TransactionTemplate` 对象已经被实例化，并且可以在 `MyService` 中被安全地使用。

需要注意的是，`TransactionTemplate` 的构造函数需要一个 `PlatformTransactionManager` 对象作为参数。在这个示例中，我们使用 `@Autowired` 注解注入了一个 `PlatformTransactionManager` 对象，这是因为 `PlatformTransactionManager` 是由 Spring 管理的事务管理器。如果你使用的是其他类型的事务管理器，你需要根据具体情况进行相应的修改。
