Springboot实现根据用户ID切换动态数据源

下面详细讲解一下Spring Boot实现根据用户ID切换动态数据源的完整攻略。

1. 背景介绍

在一些需要多数据源分库分表的项目中，我们需要根据用户ID来动态切换数据源。比如将同一张表中不同用户的数据划分到不同的数据库中进行存储，这样可以有效地降低数据库的负载，提高系统的性能。

2. 实现步骤

2.1 引入相关依赖

我们可以通过引入Spring Boot的相关依赖来实现动态数据源的切换。具体来说，我们需要引入以下两个依赖：

<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
  <version>2.2.0</version>
</dependency>

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
  <version>3.12.0</version>
</dependency>

其中，dynamic-datasource-spring-boot-starter是一个可以动态配置多数据源的Spring Boot Starter，可以帮助我们快速实现多数据源切换功能；commons-lang3是一个Java工具库，我们可以使用它来生成随机字符串，作为数据源的key。

2.2 配置多数据源

在application.yml中，我们可以进行多数据源的配置，如下所示：

spring:
  datasource:
    username: root
    password: 123456

dynamic-datasource:
  datasource:
    master:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/master?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
      username: root
      password: 123456
    slave1:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3307/slave1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
      username: root
      password: 123456
    slave2:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3308/slave2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
      username: root
      password: 123456

在这里，我配置了三个数据源，分别为master、slave1和slave2。其中，master是主数据库，slave1和slave2是从数据库。

2.3 编写动态数据源切换逻辑

在DynamicDataSource类中，我们可以编写动态数据源切换逻辑。主要思路是通过一个ThreadLocal变量来保存当前线程正在使用的数据源key，从而实现不同线程使用不同的数据源key。具体代码如下：

public class DynamicDataSource extends AbstractRoutingDataSource {

    private static final Logger logger = LoggerFactory.getLogger(DynamicDataSource.class);

    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    @Override
    protected Object determineCurrentLookupKey() {
        return CONTEXT_HOLDER.get();
    }

    public static void setDataSourceKey(String key) {
        logger.debug("切换到数据源：{}", key);
        CONTEXT_HOLDER.set(key);
    }

    public static String getDataSourceKey() {
        return CONTEXT_HOLDER.get();
    }

    public static void clearDataSourceKey() {
        CONTEXT_HOLDER.remove();
    }
}

2.4 实现动态数据源路由

在DynamicDataSourceAutoConfiguration类中，我们可以实现动态数据源的路由。具体代码如下：

@Configuration
public class DynamicDataSourceAutoConfiguration {

    @Bean
    @ConfigurationProperties("dynamic-datasource.datasource")
    public Map<String, DataSourceProperties> dataSourceProperties() {
        return new HashMap<>();
    }

    @Bean
    public DynamicDataSource dynamicDataSource(Map<String, DataSourceProperties> dataSourcePropertiesMap) {
        Map<String, DataSource> dataSourceMap = new HashMap<>();
        for (Map.Entry<String, DataSourceProperties> entry : dataSourcePropertiesMap.entrySet()) {
            DataSourceProperties dataSourceProperties = entry.getValue();
            DataSource dataSource = DataSourceBuilder.create()
                .driverClassName(dataSourceProperties.getDriverClassName())
                .url(dataSourceProperties.getUrl())
                .username(dataSourceProperties.getUsername())
                .password(dataSourceProperties.getPassword())
                .build();
            dataSourceMap.put(entry.getKey(), dataSource);
        }
        return new DynamicDataSource(dataSourceMap);
    }
}

在这里，我们首先通过@ConfigurationProperties注解将application.yml中的数据源配置读取到内存中。然后，我们通过DataSourceBuilder来创建DataSource对象，并将其添加到DynamicDataSource中。

2.5 编写切面实现数据源切换

最后，我们可以借助AOP实现动态数据源切换逻辑。具体代码如下：

@Aspect
@Component
public class DataSourceSwitchAspect {

    @Pointcut("@annotation(com.example.demo.DS)")
    public void dataSourcePointCut() {
    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        DS ds = method.getAnnotation(DS.class);
        if (ds == null) {
            DynamicDataSource.setDataSourceKey("master");
            System.out.println(String.format("切换数据源：%s > %s", ds.name(), "master"));
        } else {
            DynamicDataSource.setDataSourceKey(ds.name());
            System.out.println(String.format("切换数据源：%s > %s", ds.name(), ds.name()));
        }
        try {
            return point.proceed();
        } finally {
            DynamicDataSource.clearDataSourceKey();
            System.out.println("清空数据源连接！");
        }
    }
}

在这里，我们定义了一个切点dataSourcePointCut()，然后通过@Around注解来实现切面的具体逻辑。我们首先通过@DS注解来获取需要切换的数据源key，然后调用DynamicDataSource来切换数据源。在方法执行完毕后，我们再调用DynamicDataSource来清空数据源连接。

3. 示范

下面给出两个示例，展示如何在Spring Boot项目中实现根据用户ID动态切换数据源。

3.1 示例1

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    @DS("master")
    public void saveUser(User user) {
        userMapper.insert(user);
    }

    @Override
    @DS(key = "slave1")
    public List<User> getAllUsers() {
        return userMapper.selectAll();
    }
}

在这里，我们通过@DS注解来实现根据用户ID切换数据源。当我们调用saveUser方法时，数据源会切换到master；当我们调用getAllUsers方法时，数据源会切换到slave1。

3.2 示例2

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/user")
    public void saveUser(@RequestBody User user) {
        userService.saveUser(user);
    }

    @GetMapping("/user")
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}

在这里，我们通过调用UserService接口中的方法来实现根据用户ID动态切换数据源。具体来说，当我们调用saveUser接口时，数据源会切换到master；当我们调用getAllUsers接口时，数据源会切换到slave1。

到这里，Spring Boot实现根据用户ID切换动态数据源的攻略就讲解完毕了。