SpringBoot+MyBatis-Plus实现配置多数据源并动态切换

读写分离：
  写操作 → master 库（主库）
  读操作 → slave 库（从库）
  好处：分摊主库压力
多库业务：
  用户数据 → user_db
  订单数据 → order_db
  好处：数据隔离，防止单库过大
第三方面对接：
  业务库 → 自己的 MySQL
  对接库 → 第三方的数据库

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

spring:
  datasource:
    dynamic:
      # 默认数据源（必须）
      primary: master
      # 是否启用严格模式（找不到数据源抛异常）
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/seckill_db?useUnicode=true&characterEncoding=utf-8
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
        slave:
          url: jdbc:mysql://192.168.1.100:3306/seckill_db?useUnicode=true&characterEncoding=utf-8
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
        order:
          url: jdbc:mysql://localhost:3306/order_db?useUnicode=true&characterEncoding=utf-8
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver

@Service
@DS("master")  // 类级别：整个类默认走 master
public class UserServiceImpl extends ServiceImpl<UserMapper, User>
        implements UserService {

    @Override
    @DS("slave")  // 方法级别：这个方法走 slave
    public List<User> listUsers() {
        return this.list();
    }

    @Override
    @DS("master") // 写操作走 master
    public boolean saveUser(User user) {
        return this.save(user);
    }
}

@DS("order")
public interface OrderMapper extends BaseMapper<Order> {
    // 这个 Mapper 的所有操作都走 order 数据源
}

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;    // order 库
    @Autowired
    private UserService userService;    // master 库

    public OrderVO getOrderDetail(Long orderId) {
        // 查订单（自动走 order 数据源）
        Order order = orderMapper.selectById(orderId);

        // 查用户（自动切回 master）
        User user = userService.getById(order.getUserId());

        return merge(order, user);
    }
}

@Service
@DS("master")  // 默认写库
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> {

    @DS("slave")  // 查询走从库
    public List<Product> listProducts() {
        return this.list();
    }

    @DS("slave")
    public Product getById(Long id) {
        return this.getById(id);
    }

    // 增删改不走 @DS，默认走 master
}

单库：所有请求打到一个库
      1000 次查询 + 100 次写入 = 1100 次请求

读写分离：写入走主库，查询走从库
          主库：100 次写入
          从库：1000 次查询
          主库压力小 10 倍

@Service
public class MultiDbService {

    @Autowired
    @Lazy
    private MultiDbService self;

    /**
     * 跨库操作：用户库 + 订单库
     * 不能用 @Transactional，需要用编程式事务
     */
    public void createUserAndOrder(User user, Order order) {
        // 使用 TransactionTemplate 控制事务
        TransactionTemplate userTx = new TransactionTemplate();
        TransactionTemplate orderTx = new TransactionTemplate();

        userTx.execute(status -> {
            try {
                // 插入用户（master 库）
                self.saveUser(user);
                // 插入订单（order 库）
                self.saveOrder(order);
                return null;
            } catch (Exception e) {
                status.setRollbackOnly();
                throw e;
            }
        });
    }

    @DS("master")
    public void saveUser(User user) {
        // 保存到用户库
    }

    @DS("order")
    public void saveOrder(Order order) {
        // 保存到订单库
    }
}

/**
 * @DS 注解的原理：
 * 通过 AOP 拦截，在执行前把数据源名称设置到 ThreadLocal 中
 * 执行完后清除
 */
@Aspect
@Component
public class DataSourceAspect {

    @Around("@annotation(ds)")
    public Object around(ProceedingJoinPoint pjp, DS ds) throws Throwable {
        // 切换数据源
        DynamicDataSourceContextHolder.push(ds.value());
        try {
            return pjp.proceed();
        } finally {
            // 使用完后清除
            DynamicDataSourceContextHolder.poll();
        }
    }
}

@Service
public class UserService {

    @Transactional  // 事务内
    public void doSomething() {
        // 此时数据源已经在事务开始时固定了
        // 内部的 @DS 切换不会生效！
    }
}

// MyBatis-Plus 分页插件在多数据源下仍然有效
// 只需要在配置类中配置一次即可
@Configuration
public class MyBatisPlusConfig {
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

spring:
  datasource:
    dynamic:
      datasource:
        master:
          password: ENC(加密后的密码)  # 配合 Jasypt 加密