一、基本概念：

传统情况Java 使用 JDBC 来操作关系型数据库，而 JDBC 是阻塞的、同步的，即使使用线程池进行改善也是有限的。基于此，Spring官方（Pivotal）提出了R2DBC（Reactive Relational Database Connectivity）。R2DBC是一项API规范计划，它声明了一个反应式API，该方法将由数据库厂商实现以访问其关系数据库。

目前实现了R2DBC的数据库驱动有：H2、MariaDB、Microsoft SQL Server、MySQL 、jasync-sql MySQL、Postgres 。

使用maven添加两个依赖：r2dbc 接口、数据库驱动实现。

例如：

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-r2dbc</artifactId>
            <version>1.2.1</version>
        </dependency>
        <dependency>
            <groupId>com.github.jasync-sql</groupId>
            <artifactId>jasync-r2dbc-mysql</artifactId>
            <version>1.1.4</version>
        </dependency>

 

注：Maven Central到目前为止还没有R2DBC工件，因此我们还需要在项目中添加几个Spring的存储库。

<repositories>
    <repository>
        <id>spring-milestones</id>
        <name>Spring Milestones</name>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
   </repository>
   <repository>
       <id>spring-snapshots</id>
       <name>Spring Snapshots</name>
       <url>https://repo.spring.io/snapshot</url>
       <snapshots>
           <enabled>true</enabled>
       </snapshots>
    </repository>
</repositories>

 

 

二、直接使用r2bdc

使用r2dbc访问关系型数据库的核心是创建一个io.r2dbc.spi.ConnectionFactory接口的实例（通常使用单例）。如：

import io.r2dbc.spi.ConnectionFactories;
import io.r2dbc.spi.ConnectionFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import reactor.test.StepVerifier;

import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;

public class R2dbcApp {

  private static final Log log = LogFactory.getLog(R2dbcApp.class);

  public static void main(String[] args) {

    ConnectionFactory connectionFactory = ConnectionFactories.get("r2dbc:h2:mem:///test?options=DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");

    R2dbcEntityTemplate template = new R2dbcEntityTemplate(connectionFactory);

    template.getDatabaseClient().sql("CREATE TABLE person" +
        "(id VARCHAR(255) PRIMARY KEY," +
        "name VARCHAR(255)," +
        "age INT)")
      .fetch()
      .rowsUpdated()
      .as(StepVerifier::create)
      .expectNextCount(1)
      .verifyComplete();

    template.insert(Person.class)
      .using(new Person("joe", "Joe", 34))
      .as(StepVerifier::create)
      .expectNextCount(1)
      .verifyComplete();

    template.select(Person.class)
      .first()
      .doOnNext(it -> log.info(it))
      .as(StepVerifier::create)
      .expectNextCount(1)
      .verifyComplete();
  }
}

 

也可通过spring的方式创建连接工厂。

@Configuration
public class ApplicationConfiguration extends AbstractR2dbcConfiguration {

  @Override
  @Bean
  public ConnectionFactory connectionFactory() {
    return …
  }
}

 

ConnectionFactory创建完成后，可通过它得到访问数据库的操作类：R2dbcEntityTemplate（提供了面向实体的数据库访问操作）。

三、使用spring repository 支持

需要使用注解@EnableR2dbcRepositories开启功能。如下

@Configuration
@EnableR2dbcRepositories
class ApplicationConfig extends AbstractR2dbcConfiguration {

  @Override
  public ConnectionFactory connectionFactory() {
    return …
  }
}

 

再创建相应的repository接口

public interface PersonRepository extends ReactiveCrudRepository<Person, Long> {

  // additional custom query methods go here
}

 

然后就可以使用repository特性来进行数据库操作了，例如：

@ExtendWith(SpringExtension.class)
@ContextConfiguration
class PersonRepositoryTests {

  @Autowired
  PersonRepository repository;

  @Test
  void readsAllEntitiesCorrectly() {

    repository.findAll()
      .as(StepVerifier::create)
      .expectNextCount(1)
      .verifyComplete();
  }

  @Test
  void readsEntitiesByNameCorrectly() {

    repository.findByFirstname("Hello World")
      .as(StepVerifier::create)
      .expectNextCount(1)
      .verifyComplete();
  }
}

 

 

四、r2dbc动态数据源的实现方案

r2dbc提供了org.springframework.r2dbc.connection.lookup.AbstractRoutingConnectionFactory抽象类，并需要我们自己实现protected abstract Mono<Object> determineCurrentLookupKey();方法以达到动态切换数据源的目的。

项目中实现动态数据源的流程如下：

1、spring ioc启动时，通过jdbc方式加载中心库数据源，由中心库查询对话库配置信息及相应公司id与serverKey对应关系(serverKey与数据源一对一，公司id与serverKey多对一)

2、通过对话库配置信息创建多个ConnectionFactory，得到 Map<String, ConnectionFactory> connectionFactoryMap。此hash的key为serverKey，value为一个可用的ConnectionFactory

3、调用AbstractRoutingConnectionFactory的public void setTargetConnectionFactories(Map<?, ?> targetConnectionFactories)方法设置值连接工厂集合

4、调用AbstractRoutingConnectionFactory的public void setDefaultTargetConnectionFactory(Object defaultTargetConnectionFactory)设置默认连接工厂

5、重写protected abstract Mono<Object> determineCurrentLookupKey()方法。从**Context**中获取公司id对应的**serverKey**

 

注：此处需要使用到reactor的高级特性：Context（具有与ThreadLocal类似的功能），它是一个键值对的数据结构。它作用于一个 Flux 或一个 Mono上，而不是应用于一个线程（Thread）。

并且它使用 Subscription的传播机制来让自己对每一个操作符都可见（从最后一个 subscribe沿链向上）。因此需要在调用链最后或尽可能后的位置 (调用 subscribe()前 )创建Context并将其绑定到Flux或Mono上。

6、将我们自己实现的AbstractRoutingConnectionFactory的子类通过@Bean注入ioc容器

7、在进行数据库操作时将公司id绑定到Flux或Mono中的Context上。

 

参考文档：

https://docs.spring.io/spring-data/r2dbc/docs/current/reference/html/#get-started:first-steps:what

https://projectreactor.io/docs/core/release/reference/index.html#context