在
Spring Boot应用中使用多
数据源可以实现读写分离，提高系统的性能和可用性，同时也可以满足不同业务场景下的需求。下面我们来介绍如何使用
Spring Boot多
数据源实现读写分离。
1. 添加依赖
在pom.xml文件中添加以下依赖：
```
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-
boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>
```
其中，
spring-
boot-starter-jdbc是
Spring Boot提供的JDBC Starter，用于连接
数据库。druid是阿里巴巴开源的
数据库连接池。
2. 配置
数据源
在application.yml文件中添加
数据源配置：
```
spring:
datasource:
master:
url: jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
slave:
url: jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&useSSL=false
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
```
其中，我们配置了两个
数据源：master和slave。分别连接了两个不同的
数据库，用于实现读写分离。
3. 配置
数据源和事务
管理器
在
Spring Boot中，我们需要自己配置
数据源和事务
管理器。可以在代码中通过@Primary和@Qualifier注解实现
数据源的动态切换。
```
@Configuration
public class DataSourceConfig {
@Bean(name = "masterDataSource")
@ConfigurationProperties(prefix = "
spring.datasource.master")
public DataSource masterDataSource() {
return DruidDataSourceBuilder.create().build();
}
@Bean(name = "slaveDataSource")
@ConfigurationProperties(prefix = "
spring.datasource.slave")
public DataSource slaveDataSource() {
return DruidDataSourceBuilder.create().build();
}
@Bean(name = "dynamicDataSource")
@Primary
public DynamicDataSource dynamicDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
@Qualifier("slaveDataSource") DataSource slaveDataSource) {
Map<Object, Object> targetDataSources = new HashMap<>();
targetDataSources.put(DynamicDataSource.DataSourceType.MASTER, masterDataSource);
targetDataSources.put(DynamicDataSource.DataSourceType.SLAVE, slaveDataSource);
return new DynamicDataSource(masterDataSource, targetDataSources);
}
@Bean(name = "transactionManager")
public DataSourceTransactionManager transactionManager(@Qualifier("dynamicDataSource") DynamicDataSource dynamicDataSource) {
return new DataSourceTransactionManager(dynamicDataSource);
}
}
```
其中，我们定义了DataSourceConfig配置类，用于配置
数据源和事务
管理器。我们通过@Bean注解创建
数据源对象并读取application.yml配置文件中的
数据源信息。然后通过@Primary注解指定默认的
数据源为Master
数据源。最后，我们创建了DynamicDataSource对象，用于动态切换
数据源，同时创建了事务
管理器对象，用于
管理事务。
4. 定义
数据源切换注解
我们可以通过自定义注解来实现动态切换
数据源。
```
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface TargetDataSource {
DynamicDataSource.DataSourceType value() default DynamicDataSource.DataSourceType.MASTER;
}
```
其中，@TargetDataSource注解用于标记
数据源类型，我们通过value()方法指定
数据源类型，默认为Master
数据源。
5. 定义动态
数据源
我们可以通过继承AbstractRoutingDataSource类来实现动态
数据源的切换。
```
public class DynamicDataSource extends AbstractRoutingDataSource {
private DataSource masterDataSource;
private Map<Object, Object> targetDataSources;
public DynamicDataSource(DataSource masterDataSource, Map<Object, Object> targetDataSources) {
this.masterDataSource = masterDataSource;
this.targetDataSources = targetDataSources;
super.setDefaultTargetDataSource(masterDataSource);
super.setTargetDataSources(targetDataSources);
super.afterPropertiesSet();
}
@Override
protected Object determineCurrentLookupKey() {
return DataSourceContextHolder.getDataSourceType();
}
public enum DataSourceType {
MASTER, SLAVE
}
}
```
其中，我们定义了DynamicDataSource类，继承了AbstractRoutingDataSource类。在DynamicDataSource类中，我们重写了determineCurrentLookupKey()方法，根据当前线程的
数据源类型，返回对应的
数据源。我们通过
枚举类型DataSourceType定义了Master和Slave两种
数据源类型。
6. 实现
数据源切换
我们可以通过AOP的方式，在方法执行前切换
数据源。
```
@Aspect
@Component
public class DataSourceAspect {
@Pointcut("@annotation(com.example.demo.annotation.TargetDataSource)")
public void dataSourcePointCut() {
}
@Around("dataSourcePointCut()")
public Object around(ProceedingJoinPoint point) throws Throwable {
MethodSignature signature = (MethodSignature) point.getSignature();
TargetDataSource dataSource = signature.getMethod().getAnnotation(TargetDataSource.class);
if (dataSource == null) {
DataSourceContextHolder.setDataSourceType(DynamicDataSource.DataSourceType.MASTER);
} else {
DataSourceContextHolder.setDataSourceType(dataSource.value());
}
try {
return point.proceed();
} finally {
DataSourceContextHolder.clearDataSourceType();
}
}
}
```
其中，我们定义了DataSourceAspect切面类，用于切换
数据源。我们通过@Around注解标记了切点，在方法执行前，根据注解中指定的
数据源类型，切换
数据源。执行完毕后，再切换回默认的Master
数据源。
7. 编写业务代码
最后，我们编写业务代码，通过@TargetDataSource注解指定
数据源类型。
```
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Override
@TargetDataSource(DynamicDataSource.DataSourceType.MASTER)
public void addUser(User user) {
userMapper.addUser(user);
}
@Override
@TargetDataSource(DynamicDataSource.DataSourceType.SLAVE)
public User getUserById(int id) {
return userMapper.getUserById(id);
}
}
```
其中，我们定义了UserServiceImpl类，实现了UserService接口。在addUser()方法中，我们指定
数据源类型为Master
数据源，在getUserById()方法中，我们指定
数据源类型为Slave
数据源。
通过以上步骤，我们就可以实现
Spring Boot多
数据源的读写分离了。
1805
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
