應(yīng)用程序 → Dynamic-Datasource → 主庫(kù)（寫(xiě)操作）
                     ↓
                   從庫(kù)（讀操作）

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- MyBatis-Plus 啟動(dòng)器 -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.2</version>
    </dependency>
    
    <!-- Dynamic-Datasource 啟動(dòng)器（核心依賴） -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        <version>3.6.1</version>
    </dependency>
    
    <!-- MySQL 驅(qū)動(dòng) -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    
    <!-- 連接池（可選，HikariCP已內(nèi)置） -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.16</version>
    </dependency>
</dependencies>

spring:
  datasource:
    dynamic:
      primary: master  # 設(shè)置默認(rèn)數(shù)據(jù)源為主庫(kù)
      strict: false   # 是否嚴(yán)格匹配數(shù)據(jù)源，false時(shí)未匹配到指定數(shù)據(jù)源則使用默認(rèn)數(shù)據(jù)源
      datasource:
        # 主庫(kù)配置（寫(xiě)操作）
        master:
          url: jdbc:mysql://master-host:3306/core?useSSL=false&serverTimezone=Asia/Shanghai
          username: admin
          password: master@123
          driver-class-name: com.mysql.cj.jdbc.Driver
        # 從庫(kù)配置（讀操作）- 支持多個(gè)從庫(kù)
        slave1:
          url: jdbc:mysql://slave1-host:3306/core?useSSL=false&serverTimezone=Asia/Shanghai
          username: readonly
          password: slave@123
          driver-class-name: com.mysql.cj.jdbc.Driver
        slave2:
          url: jdbc:mysql://slave2-host:3306/core?useSSL=false&serverTimezone=Asia/Shanghai
          username: readonly
          password: slave@123
          driver-class-name: com.mysql.cj.jdbc.Driver
      
      # 負(fù)載均衡策略配置（多個(gè)從庫(kù)時(shí)生效）
      strategy: 
        slave: round_robin  # 從庫(kù)負(fù)載均衡策略：random(隨機(jī))/round_robin(輪詢)
      
      # 連接池配置（HikariCP）
      hikari:
        max-pool-size: 20      # 最大連接數(shù)
        min-idle: 5           # 最小空閑連接
        connection-timeout: 30000  # 連接超時(shí)時(shí)間(ms)
        idle-timeout: 600000  # 空閑連接超時(shí)時(shí)間(ms)
        max-lifetime: 1800000 # 連接最大生命周期(ms)

# MyBatis-Plus 配置
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true  # 開(kāi)啟駝峰命名轉(zhuǎn)換
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 打印SQL日志(調(diào)試用)
  global-config:
    db-config:
      id-type: auto  # 主鍵策略自增

@Configuration
@MapperScan("com.example.mapper")  // 指定MyBatis mapper接口的掃描路徑
public class DataSourceConfig {
    
    /**
     * 配置動(dòng)態(tài)數(shù)據(jù)源
     * Dynamic-Datasource會(huì)自動(dòng)根據(jù)application.yml的配置創(chuàng)建數(shù)據(jù)源
     * 此處可以添加自定義配置
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.dynamic")
    public DynamicDataSourceProperties dynamicDataSourceProperties() {
        return new DynamicDataSourceProperties();
    }
    
    /**
     * 配置MyBatis-Plus攔截器（分頁(yè)插件等）
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分頁(yè)插件
        PaginationInnerInterceptor paginationInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
        paginationInterceptor.setMaxLimit(1000L);  // 設(shè)置最大分頁(yè)限制
        interceptor.addInnerInterceptor(paginationInterceptor);
        
        // 可以添加其他插件，如樂(lè)觀鎖插件等
        return interceptor;
    }
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    
    /**
     * 寫(xiě)操作：使用@DS("master")指定主庫(kù)
     * 注意：寫(xiě)操作建議都使用主庫(kù)，確保數(shù)據(jù)一致性
     */
    @DS("master")  // 指定使用主庫(kù)
    @Transactional(rollbackFor = Exception.class)  // 添加事務(wù)管理
    @Override
    public boolean createUser(User user) {
        // 參數(shù)校驗(yàn)
        if (user == null || StringUtils.isBlank(user.getUsername())) {
            throw new IllegalArgumentException("用戶信息不完整");
        }
        
        // 設(shè)置創(chuàng)建時(shí)間
        user.setCreateTime(LocalDateTime.now());
        user.setUpdateTime(LocalDateTime.now());
        
        // 執(zhí)行插入操作，這里會(huì)使用主庫(kù)
        boolean result = save(user);
        
        // 這里可以添加其他業(yè)務(wù)邏輯
        log.info("創(chuàng)建用戶成功，用戶ID: {}", user.getId());
        
        return result;
    }
    
    /**
     * 讀操作：使用@DS("slave")指定從庫(kù)
     * 框架會(huì)根據(jù)負(fù)載均衡策略選擇slave1或slave2
     */
    @DS("slave")  // 指定使用從庫(kù)（負(fù)載均衡）
    @Override
    public User getUserById(Long id) {
        // 參數(shù)校驗(yàn)
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("用戶ID不合法");
        }
        
        // 查詢用戶信息，這里會(huì)使用從庫(kù)
        User user = getById(id);
        
        if (user == null) {
            log.warn("未找到對(duì)應(yīng)用戶，用戶ID: {}", id);
            throw new RuntimeException("用戶不存在");
        }
        
        return user;
    }
    
    /**
     * 批量查詢：同樣使用從庫(kù)
     */
    @DS("slave")
    @Override
    public List<User> listUsersByCondition(UserQuery query) {
        // 構(gòu)建查詢條件
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        
        if (StringUtils.isNotBlank(query.getUsername())) {
            wrapper.like(User::getUsername, query.getUsername());
        }
        
        if (query.getStatus() != null) {
            wrapper.eq(User::getStatus, query.getStatus());
        }
        
        // 添加排序
        wrapper.orderByDesc(User::getCreateTime);
        
        // 執(zhí)行查詢，使用從庫(kù)
        return list(wrapper);
    }
    
    /**
     * 更新操作：必須使用主庫(kù)
     */
    @DS("master")
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean updateUser(User user) {
        if (user == null || user.getId() == null) {
            throw new IllegalArgumentException("用戶信息不完整");
        }
        
        // 設(shè)置更新時(shí)間
        user.setUpdateTime(LocalDateTime.now());
        
        // 執(zhí)行更新，使用主庫(kù)
        boolean result = updateById(user);
        
        if (result) {
            log.info("更新用戶成功，用戶ID: {}", user.getId());
        } else {
            log.error("更新用戶失敗，用戶ID: {}", user.getId());
        }
        
        return result;
    }
    
    /**
     * 刪除操作：必須使用主庫(kù)
     */
    @DS("master")
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean deleteUser(Long id) {
        if (id == null || id <= 0) {
            throw new IllegalArgumentException("用戶ID不合法");
        }
        
        // 執(zhí)行刪除，使用主庫(kù)
        boolean result = removeById(id);
        
        if (result) {
            log.info("刪除用戶成功，用戶ID: {}", id);
        } else {
            log.warn("刪除用戶失敗，用戶ID: {}", id);
        }
        
        return result;
    }
}

@Aspect
@Component
@Slf4j
public class DataSourceAspect {
    
    /**
     * 定義切點(diǎn)：攔截Service層的所有方法
     */
    @Pointcut("execution(* com.example.service..*.*(..))")
    public void servicePointcut() {}
    
    /**
     * 前置通知：在方法執(zhí)行前選擇數(shù)據(jù)源
     */
    @Before("servicePointcut()")
    public void before(JoinPoint joinPoint) {
        // 獲取方法名
        String methodName = joinPoint.getSignature().getName();
        
        // 根據(jù)方法名前綴判斷是讀操作還是寫(xiě)操作
        if (isReadOperation(methodName)) {
            // 讀操作使用從庫(kù)
            DynamicDataSourceContextHolder.push("slave");
            log.debug("切換數(shù)據(jù)源到從庫(kù)，方法名: {}", methodName);
        } else {
            // 寫(xiě)操作使用主庫(kù)
            DynamicDataSourceContextHolder.push("master");
            log.debug("切換數(shù)據(jù)源到主庫(kù)，方法名: {}", methodName);
        }
    }
    
    /**
     * 后置通知：清理數(shù)據(jù)源上下文
     */
    @After("servicePointcut()")
    public void after() {
        DynamicDataSourceContextHolder.clear();
        log.debug("清除數(shù)據(jù)源上下文");
    }
    
    /**
     * 判斷是否為讀操作
     * 可以根據(jù)方法名前綴進(jìn)行判斷
     */
    private boolean isReadOperation(String methodName) {
        // 常見(jiàn)的讀操作方法前綴
        String[] readPrefixes = {"get", "select", "list", "query", "find", "search", "count", "check"};
        
        for (String prefix : readPrefixes) {
            if (methodName.startsWith(prefix)) {
                return true;
            }
        }
        return false;
    }
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
    
    @Transactional(rollbackFor = Exception.class)
    @Override
    public boolean createUser(User user) {
        // 自動(dòng)使用主庫(kù)（AOP根據(jù)方法名判斷）
        user.setCreateTime(LocalDateTime.now());
        return save(user);
    }
    
    @Override
    public User getUserById(Long id) {
        // 自動(dòng)使用從庫(kù)（AOP根據(jù)方法名前綴"get"判斷）
        return getById(id);
    }
    
    // 其他方法無(wú)需添加@DS注解，由AOP自動(dòng)處理
}

@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
    
    /**
     * 單數(shù)據(jù)源事務(wù)：所有操作都在主庫(kù)執(zhí)行
     * 使用@DS("master")確保即使有AOP配置也使用主庫(kù)
     */
    @DS("master")  // 顯式指定主庫(kù)
    @Transactional(rollbackFor = Exception.class)  // 聲明式事務(wù)
    @Override
    public void createOrder(Order order) {
        // 1. 保存訂單主信息（主庫(kù)）
        save(order);
        
        // 2. 更新庫(kù)存（主庫(kù)）
        updateStock(order);
        
        // 3. 記錄操作日志（主庫(kù)）
        logOrderOperation(order);
        
        // 如果任何一步失敗，整個(gè)事務(wù)回滾
    }
    
    /**
     * 只讀事務(wù)：可以指定從庫(kù)
     */
    @DS("slave")
    @Transactional(readOnly = true)  // 只讀事務(wù)，有優(yōu)化效果
    @Override
    public Order getOrderDetail(Long orderId) {
        return getById(orderId);
    }
}

@Service
@Slf4j
public class DistributedTransactionService {
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private OrderService orderService;
    
    /**
     * 使用@DSTransactional實(shí)現(xiàn)多數(shù)據(jù)源分布式事務(wù)
     * 注意：需要集成Seata等分布式事務(wù)框架
     */
    // @DSTransactional  // 分布式事務(wù)注解（需要額外配置）
    @Transactional(rollbackFor = Exception.class)
    public void placeOrder(Order order, User user) {
        try {
            // 1. 用戶操作（主庫(kù)）
            userService.updateUser(user);
            
            // 2. 訂單操作（主庫(kù)）
            orderService.createOrder(order);
            
            // 模擬業(yè)務(wù)異常
            if (order.getAmount() == null) {
                throw new RuntimeException("訂單金額不能為空");
            }
            
            log.info("下單成功");
        } catch (Exception e) {
            log.error("下單失敗，已回滾", e);
            throw e;  // 拋出異常觸發(fā)回滾
        }
    }
}

spring:
  datasource:
    dynamic:
      datasource:
        master:
          # 主庫(kù)配置...
        slave1:
          # 從庫(kù)1配置...
        slave2:
          # 從庫(kù)2配置...
        slave3:
          # 從庫(kù)3配置...
      strategy:
        slave: round_robin  # 負(fù)載均衡策略
        # 可選值:
        # random - 隨機(jī)選擇（默認(rèn)）
        # round_robin - 輪詢
        # weight_round_robin - 加權(quán)輪詢（需要額外配置權(quán)重）

@Component
@Slf4j
public class DataSourceHealthCheck {
    
    @Autowired
    private DataSource dataSource;
    
    /**
     * 定時(shí)檢查從庫(kù)健康狀態(tài)
     */
    @Scheduled(fixedRate = 60000)  // 每分鐘執(zhí)行一次
    public void checkSlaveHealth() {
        // 這里可以實(shí)現(xiàn)從庫(kù)健康檢查邏輯
        // 如果某個(gè)從庫(kù)不可用，可以動(dòng)態(tài)將其從負(fù)載均衡池中移除
        
        log.info("執(zhí)行從庫(kù)健康檢查...");
        // 實(shí)際實(shí)現(xiàn)中可以使用JDBC測(cè)試連接或查詢數(shù)據(jù)庫(kù)狀態(tài)
    }
    
    /**
     * 獲取從庫(kù)同步延遲
     */
    public Long getReplicationDelay(String slaveName) {
        // 執(zhí)行SQL查詢從庫(kù)同步狀態(tài)
        // SHOW SLAVE STATUS 可以獲取Seconds_Behind_Master等信息
        // 如果延遲過(guò)大，可以臨時(shí)將該從庫(kù)標(biāo)記為不可用
        
        return 0L;  // 返回延遲秒數(shù)
    }
}

@SpringBootTest
@Slf4j
class ReadWriteSeparationTest {
    
    @Autowired
    private UserService userService;
    
    /**
     * 測(cè)試寫(xiě)操作（應(yīng)該路由到主庫(kù)）
     */
    @Test
    void testWriteOperation() {
        User user = new User();
        user.setUsername("testUser");
        user.setEmail("test@example.com");
        
        boolean result = userService.createUser(user);
        
        assertTrue(result);
        log.info("寫(xiě)操作測(cè)試通過(guò)，應(yīng)路由到主庫(kù)");
    }
    
    /**
     * 測(cè)試讀操作（應(yīng)該路由到從庫(kù)）
     */
    @Test
    void testReadOperation() {
        User user = userService.getUserById(1L);
        
        assertNotNull(user);
        log.info("讀操作測(cè)試通過(guò)，應(yīng)路由到從庫(kù)");
    }
    
    /**
     * 測(cè)試事務(wù)內(nèi)的數(shù)據(jù)源選擇
     */
    @Test
    void testTransactionalOperation() {
        // 測(cè)試事務(wù)方法，應(yīng)始終使用主庫(kù)
        User user = userService.getUserById(1L);
        assertNotNull(user);
        
        log.info("事務(wù)內(nèi)操作測(cè)試完成");
    }
}

# 開(kāi)啟MyBatis SQL日志
logging:
  level:
    com.example.mapper: debug  # Mapper接口的包路徑
    com.baomidou.dynamic.datasource: debug  # Dynamic-Datasource日志

2025-11-11 10:00:00 | Master DataSource  | INSERT INTO user ...
2025-11-11 10:00:05 | Slave DataSource   | SELECT * FROM user ...

@Service
public class CriticalReadService {
    
    @Autowired
    private UserMapper userMapper;
    
    /**
     * 對(duì)于一致性要求高的讀操作，強(qiáng)制走主庫(kù)
     */
    @DS("master")  // 強(qiáng)制使用主庫(kù)，避免讀取舊數(shù)據(jù)
    public User getCriticalUserInfo(Long userId) {
        // 例如：賬戶余額、訂單狀態(tài)等關(guān)鍵信息
        return userMapper.selectById(userId);
    }
    
    /**
     * 檢查數(shù)據(jù)是否已同步
     */
    public boolean waitForReplication(Long userId, int maxWaitSeconds) {
        for (int i = 0; i < maxWaitSeconds; i++) {
            User masterUser = getFromMaster(userId);
            User slaveUser = getFromSlave(userId);
            
            if (Objects.equals(masterUser, slaveUser)) {
                return true;  // 數(shù)據(jù)已同步
            }
            
            try {
                Thread.sleep(1000);  // 等待1秒
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        return false;  // 同步超時(shí)
    }
}

# 連接池監(jiān)控配置
spring:
  datasource:
    dynamic:
      druid:
        # 開(kāi)啟監(jiān)控統(tǒng)計(jì)
        filters: stat,wall,log4j
        web-stat-filter:
          enabled: true
        stat-view-servlet:
          enabled: true
          url-pattern: /druid/*
          reset-enable: false
          login-username: admin
          login-password: admin

@Service
public class TransactionalService {
    
    @Autowired
    private ApplicationContext applicationContext;
    
    @Transactional
    public void transactionalMethod() {
        // 方法內(nèi)需要切換數(shù)據(jù)源時(shí)，通過(guò)代理對(duì)象調(diào)用
        TransactionalService self = applicationContext.getBean(TransactionalService.class);
        
        // 通過(guò)代理對(duì)象調(diào)用，可以正常切換數(shù)據(jù)源
        self.readOperation();  // 使用從庫(kù)
        self.writeOperation();  // 使用主庫(kù)
    }
    
    @DS("slave")
    public void readOperation() {
        // 讀操作
    }
    
    @DS("master")
    public void writeOperation() {
        // 寫(xiě)操作
    }
}

@Service
public class DynamicDataSourceService {
    
    @Autowired
    private DynamicDataSourceProvider dataSourceProvider;
    
    /**
     * 運(yùn)行時(shí)動(dòng)態(tài)添加數(shù)據(jù)源
     */
    public void addDataSource(String dataSourceName, DataSourceProperty property) {
        DynamicDataSourceContextHolder.addDataSource(dataSourceName, property);
        log.info("動(dòng)態(tài)添加數(shù)據(jù)源: {}", dataSourceName);
    }
    
    /**
     * 運(yùn)行時(shí)移除數(shù)據(jù)源
     */
    public void removeDataSource(String dataSourceName) {
        DynamicDataSourceContextHolder.removeDataSource(dataSourceName);
        log.info("動(dòng)態(tài)移除數(shù)據(jù)源: {}", dataSourceName);
    }
}