<think>我们面对的需求是：在若依微服务框架中，
使用 dynamic-datasource-spring-boot-starter 来集成 ShardingSphere 的读写分离
数据源。
但是注意，用户要求的是配置
dynamic-datasource-spring-boot-starter 以支持 ShardingSphere 的读写分离
数据源，而不是直接用ShardingSphere替换
动态数据源。
根据引用，
dynamic-datasource-spring-boot-starter 本身是一个多
数据源管理工具，而ShardingSphere是一个分库分表、读写分离的框架。
我们想要结合两者，即利用
dynamic-datasource管理多个
数据源（可能是不同的业务库），而每个业务库内部又需要ShardingSphere来实现读写分离。
然而，需要注意的是：ShardingSphere本身也可以管理多个
数据源（分片
数据源和读写分离
数据源），所以两者在功能上有重叠。因此，我们需要明确如何整合。
一种常见的整合方式是：
1.
使用dynamic-datasource管理多个
数据源，其中每个
数据源实际上是一个ShardingSphere
数据源（已经配置了读写分离）。
2. 这样，我们可以通过
dynamic-datasource切换不同的业务
数据源（每个业务
数据源内部由ShardingSphere管理读写分离）。
具体步骤：
步骤1：引入依赖
需要同时引入
dynamic-datasource-spring-boot-starter 和 sharding
-jdbc
-spring-boot-starter 依赖。
步骤2：配置多个
数据源（每个
数据源对应一个ShardingSphere
数据源）
在application.yml中配置
dynamic-datasource的
数据源，但是每个
数据源不是普通的
DataSource，而是一个ShardingSphere
DataSource。
但是，
dynamic-datasource默认不支持直接配置ShardingSphere
数据源，因此我们需要通过编程方式创建ShardingSphere
数据源，并将其注册为
dynamic-datasource的
数据源。
步骤3：通过编程方式创建ShardingSphere
数据源
我们可以为每个需要读写分离的
数据源分别配置一个ShardingSphere
数据源，然后交给
dynamic-datasource管理。
步骤4：
使用@DS注解
切换数据源，同时每个
数据源内部由ShardingSphere实现读写分离。
但是，这种整合方式可能会比较复杂，因为ShardingSphere的配置本身也比较复杂。
另一种思路（更简单）：将ShardingSphere的读写分离
数据源作为一个普通
数据源注册到
dynamic-datasource中。
即，我们配置一个ShardingSphere
数据源（它已经包含了主库
和从库，并实现了读写分离），然后将这个ShardingSphere
数据源作为一个
数据源（比如叫做"sharding
-db"）注册到
dynamic-datasource中。
这样，我们可以用@DS("sharding
-db")来
使用这个
数据源，同时在这个
数据源内部实现了读写分离。
具体配置示例：
1. 引入依赖（注意版本兼容性）：
```xml
<!
-- dynamic-datasource -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>
dynamic-datasource-spring-boot-starter</artifactId>
<version>3.6.1</version>
</dependency>
<!
-- sharding
-jdbc
-->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding
-jdbc
-spring-boot-starter</artifactId>
<version>4.1.1</version>
</dependency>
```
2. 配置ShardingSphere的读写分离
数据源（以其中一个业务库为例，假设我们有两个业务库：order
和user，每个业务库都需要读写分离）：
但是注意，
dynamic-datasource和sharding
-jdbc的配置会有冲突，因为它们都会去创建
数据源。因此，我们禁用sharding
-jdbc的自动配置，改为手动创建ShardingSphere
数据源。
3. 通过@Bean手动创建ShardingSphere
数据源，并将其注册到
dynamic-datasource中。
配置示例（application.yml）：
```yaml
spring:
datasource:
dynamic:
primary: master # 设置默认的
数据源或者
数据源组,默认值即为master
strict: false # 严格匹配
数据源,默认false. true未匹配到指定
数据源时抛异常,false
使用默认
数据源
datasource:
master: # 这是默认
数据源（可以是一个普通
数据源，也可以是一个ShardingSphere
数据源，但我们这里用普通
数据源作为其他非分片库）
url: jdbc:mysql://localhost:3306/master?useUnicode=true&characterEncoding=utf8
username: root
password: 123456
driver
-class
-name: com.mysql.jdbc.Driver
# 注意：我们不在这里配置sharding
-db，而是通过@Bean配置
```
然后，我们创建一个配置类，手动创建ShardingSphere
数据源（例如，名为sharding
-db），并将其注册到
dynamic-datasource的
数据源集合中。
配置类示例：
```
java
@Configuration
public class Sharding
DataSourceConfig {
@Autowired
private
DataSourceProperties
dataSourceProperties;
// 假设我们有一个主库
和两个从库，用于读写分离
@Bean
@ConfigurationProperties(prefix = "
spring.
datasource.sharding.master")
public
DataSource master
DataSource() {
return
DataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "
spring.
datasource.sharding.slave0")
public
DataSource slave0
DataSource() {
return
DataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "
spring.
datasource.sharding.slave1")
public
DataSource slave1
DataSource() {
return
DataSourceBuilder.create().build();
}
// 创建ShardingSphere
数据源（读写分离）
@Bean
public
DataSource sharding
DataSource() throws SQLException {
// 实际
数据源映射
Map<String,
DataSource>
dataSourceMap = new HashMap<>();
dataSourceMap.put("master0", master
DataSource());
dataSourceMap.put("slave0", slave0
DataSource());
dataSourceMap.put("slave1", slave1
DataSource());
// 读写分离规则
MasterSlaveRuleConfiguration masterSlaveRuleConfig = new MasterSlaveRuleConfiguration(
"sharding
-db", // 读写分离
数据源的名称（逻辑
数据源名）
"master0", // 主库
数据源名称
Arrays.asList("slave0", "slave1") // 从库
数据源名称列表
);
// 创建ShardingSphere
数据源
return MasterSlave
DataSourceFactory.create
DataSource(
dataSourceMap, masterSlaveRuleConfig, new Properties());
}
// 将ShardingSphere
数据源注册到
dynamic-datasource中
@Bean
public
DynamicDataSourceProvider
dynamicDataSourceProvider() {
Map<String,
DataSource>
dataSourceMap = new HashMap<>();
try {
// 将sharding
DataSource加入到
dynamic-datasource的
数据源列表中
dataSourceMap.put("sharding
-db", sharding
DataSource());
} catch (SQLException e) {
throw new RuntimeException(e);
}
return new Abstract
DataSourceProvider() {
@Override
public Map<String,
DataSource> load
DataSources() {
return
dataSourceMap;
}
};
}
}
```
4. 在application.yml中，我们还需要配置
dynamic-datasource的其他
数据源（如果有的话）以及默认
数据源。
5.
使用：在需要访问读写分离
数据源的地方，
使用@DS("sharding
-db")注解。
注意：这种方式下，sharding
-db这个
数据源内部已经实现了读写分离（由ShardingSphere管理），而其他
数据源（如master）则是一个普通
数据源。
但是，上述配置中，我们手动创建了多个
数据源（master
DataSource, slave0
DataSource, slave1
DataSource）并组合成ShardingSphere
数据源，然后将其注册到
dynamic-datasource中。
另外，我们还需要在配置文件中配置这些
数据源的连接信息，例如：
```yaml
spring:
datasource:
dynamic:
primary: master # 默认
数据源
datasource:
master:
url: jdbc:mysql://localhost:3306/master_db?useUnicode=true&characterEncoding=utf8
username: root
password: 123456
driver
-class
-name: com.mysql.jdbc.Driver
sharding:
master:
url: jdbc:mysql://master
-host:3306/db?useUnicode=true&characterEncoding=utf8
username: root
password: 123456
driver
-class
-name: com.mysql.jdbc.Driver
slave0:
url: jdbc:mysql://slave0
-host:3306/db?useUnicode=true&characterEncoding=utf8
username: root
password: 123456
driver
-class
-name: com.mysql.jdbc.Driver
slave1:
url: jdbc:mysql://slave1
-host:3306/db?useUnicode=true&characterEncoding=utf8
username: root
password: 123456
driver
-class
-name: com.mysql.jdbc.Driver
```
注意：上面的配置中，我们
使用了自定义的配置前缀（
spring.
datasource.sharding）来配置ShardingSphere所需的主从
数据源。
另外，由于我们手动创建了
数据源，所以不需要ShardingSphere的自动配置，因此可以排除ShardingSphere的自动配置类：
```
java
@
SpringBootApplication(exclude = {ShardingSphereAutoConfiguration.class})
```
这样，我们就实现了将ShardingSphere的读写分离
数据源作为一个
数据源整合到
dynamic-datasource中。
但是，请注意：如果同时有多个这样的读写分离
数据源（比如多个业务库，每个库都需要读写分离），那么我们需要为每个读写分离
数据源创建一个ShardingSphere
数据源，并注册到
dynamic-datasource中。
总结：通过将ShardingSphere
数据源作为
dynamic-datasource的一个
数据源，我们可以在
使用dynamic-datasource切换数据源的同时，在特定的
数据源内部
使用ShardingSphere实现读写分离。
注意：这种整合方式可能比较复杂，需要仔细处理依赖
和配置。同时，版本兼容性也是一个需要注意的问题。
如果遇到问题，建议查看官方文档或社区支持。
由于整合过程较为复杂，这里只提供了一个基本的思路
和示例。</think>### 配置
dynamic-datasource-spring-boot-starter 集成 ShardingSphere 读写分离
数据源
#### 核心思路
将 ShardingSphere 的读写分离
数据源作为
dynamic-datasource 的一个独立
数据源进行管理，通过 `@DS` 注解实现
动态切换[^1][^3]。
#### 配置步骤
1. **添加依赖**
```xml
<!
-- dynamic-datasource 核心依赖
-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>
dynamic-datasource-spring-boot-starter</artifactId>
<version>3.6.1</version>
</dependency>
<!
-- ShardingSphere JDBC 依赖
-->
<dependency>
<groupId>org.apache.shardingsphere</groupId>
<artifactId>sharding
-jdbc
-spring-boot-starter</artifactId>
<version>5.3.2</version>
</dependency>
```
2. **配置
数据源（application.yml）**
```yaml
spring:
shardingsphere:
# 关闭ShardingSphere自动
数据源创建
enabled: false
datasource:
names: master,slave0,slave1 # 物理
数据源名称
master:
type: com.zaxxer.hikari.Hikari
DataSource
driver
-class
-name: com.mysql.cj.jdbc.Driver
jdbc
-url: jdbc:mysql://master
-host:3306/db
username: root
password: master
-pwd
slave0:
type: com.zaxxer.hikari.Hikari
DataSource
driver
-class
-name: com.mysql.cj.jdbc.Driver
jdbc
-url: jdbc:mysql://slave0
-host:3306/db
username: root
password: slave
-pwd
slave1:
type: com.zaxxer.hikari.Hikari
DataSource
driver
-class
-name: com.mysql.cj.jdbc.Driver
jdbc
-url: jdbc://slave1
-host:3306/db
username: root
password: slave
-pwd
datasource:
dynamic:
primary: default # 默认
数据源
strict: true # 严格匹配模式
datasource:
default: # 普通
数据源
url: jdbc:mysql://default
-host:3306/default_db
username: user
password: pass
sharding
-db: # ShardingSphere读写分离
数据源（通过Bean配置）
```
3. **创建 ShardingSphere
数据源 Bean**
```
java
@Configuration
public class Sharding
DataSourceConfig {
@Bean("sharding
DataSource")
public
DataSource sharding
DataSource(
@Qualifier("master")
DataSource master,
@Qualifier("slave0")
DataSource slave0,
@Qualifier("slave1")
DataSource slave1) {
// 1. 创建
数据源映射
Map<String,
DataSource>
dataSourceMap = new HashMap<>();
dataSourceMap.put("master", master);
dataSourceMap.put("slave0", slave0);
dataSourceMap.put("slave1", slave1);
// 2. 配置读写分离规则
MasterSlaveRuleConfiguration ruleConfig = new MasterSlaveRuleConfiguration(
"sharding
-db", // 逻辑
数据源名称
"master", // 主库名称
Arrays.asList("slave0", "slave1") // 从库列表
);
// 3. 创建ShardingSphere
数据源
try {
return MasterSlave
DataSourceFactory.create
DataSource(
dataSourceMap,
ruleConfig,
new Properties()
);
} catch (SQLException e) {
throw new RuntimeException("创建ShardingSphere
数据源失败", e);
}
}
}
```
4. **注册到
dynamic-datasource**
```
java
@Configuration
public class
DynamicDataSourceConfig {
@Autowired
private
DataSource sharding
DataSource; // 注入ShardingSphere
数据源
@Bean
public
DynamicDataSourceProvider
dynamicDataSourceProvider() {
return new Abstract
DataSourceProvider() {
@Override
public Map<String,
DataSource> load
DataSources() {
Map<String,
DataSource> dsMap = new HashMap<>();
// 添加ShardingSphere
数据源
dsMap.put("sharding
-db", sharding
DataSource);
return dsMap;
}
};
}
}
```
5. **
使用读写分离
数据源**
```
java
@Service
public class OrderService {
//
使用普通
数据源
public void defaultOperation() {
// 默认
使用default
数据源
}
//
使用ShardingSphere读写分离
数据源
@DS("sharding
-db") //
动态切换数据源注解[^1][^3]
public void readOperation() {
// 自动路由到从库
jdbcTemplate.query("SELECT * FROM orders");
}
@DS("sharding
-db")
@Transactional
public void writeOperation() {
// 自动路由到主库
jdbcTemplate.update("INSERT INTO orders (...) VALUES (...)");
}
}
```
#### 关键配置说明
1. **
数据源层级结构**：
```
Dynamic-Datasource
├── default (普通
数据源)
└── sharding
-db (ShardingSphere
数据源)
├── master (物理主库)
├── slave0 (物理从库1)
└── slave1 (物理从库2)
```
2. **读写分离规则**：
- 写
操作自动路由到主库
- 读
操作自动负载均衡到从库
- 事务内强制走主库
3. **
动态切换机制**：
- `@DS("sharding
-db")` 注解将当前
操作切换到 ShardingSphere
数据源
- 未注解方法
使用默认
数据源[^1][^3]
#### 性能优化建议
1. **从库负载均衡**：
```
java
// 在ShardingSphere配置中添加负载均衡策略
ruleConfig.setLoadBalanceAlgorithmType("ROUND_ROBIN");
```
2. **连接池配置**：
```yaml
master:
hikari:
maximum
-pool
-size: 20
minimum
-idle: 5
slave0:
hikari:
maximum
-pool
-size: 15
```
3. **强制主库读取**：
```
java
@DS("sharding
-db")
@Transactional
public void readFromMaster() {
// 通过HintManager强制走主库
try (HintManager hintManager = HintManager.getInstance()) {
hintManager.setMasterRouteOnly();
jdbcTemplate.query("SELECT * FROM orders");
}
}
```
> **验证方法**：在 SQL 前添加 `/* ShardingSphere hint: master */` 注释可验证主库路由
本文介绍了如何使用JdbcTemplate和dynamic-datasource-spring-boot-starter库在SpringBoot应用中实现动态数据源切换。通过@DS注解在类或方法级别指定数据源，以及利用DynamicDataSourceContextHolder在运行时切换数据源，实现了对多个数据库的读写操作。示例代码展示了数据查询和插入的示例，并提供了配置动态数据源的步骤。
最低0.47元/天 解锁文章
扫一扫
1144
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
