java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > SpringBoot+MySQL读写分离

Spring Boot + MySQL读写分离实现方案全过程

作者：ZePingPingZe

读写分离是数据库架构中的一种优化策略,它将读操作和写操作分开处理,通常通过将读请求和写请求分别发送到不同的数据库服务器来实现,这篇文章主要介绍了Spring Boot + MySQL读写分离实现方案的相关资料,需要的朋友可以参考下

一、MySQL主从复制搭建（一主一从）

1. 主库配置

# 1. 修改主库配置文件 /etc/my.cnf
[mysqld]
server-id=1 # 唯一ID
log-bin=mysql-bin # 启用二进制日志
binlog-format=mixed # 二进制日志格式

重启MySQL后执行：

# 2. 创建复制账号
CREATE USER 'repl'@'%' IDENTIFIED BY 'repl_password';
GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';

# 3. 查看二进制日志坐标
SHOW MASTER STATUS;
# 记录File和Position，例如：File 'mysql-bin.000001', Position 154

2. 从库配置

# 1. 修改从库配置文件 /etc/my.cnf
[mysqld]
server-id=2 # 必须与主库不同
relay-log=mysql-relay-bin # 中继日志
log-slave-updates=1 # 使从库也能作为其他从库的主库

重启MySQL后执行：

# 2. 配置主从连接
CHANGE MASTER TO 
MASTER_HOST='主库IP',
MASTER_USER='repl',
MASTER_PASSWORD='repl_password',
MASTER_LOG_FILE='mysql-bin.000001',
MASTER_LOG_POS=154;

# 3. 启动复制
START SLAVE;

# 4. 验证
SHOW SLAVE STATUS\G
# 确认Slave_IO_Running和Slave_SQL_Running都是Yes

💡 小贴士：主从复制需要确保网络通畅，主库防火墙开放3306端口，从库能访问主库的3306端口。

二、Spring Boot读写分离实现（推荐Dynamic-Datasource）

1. 添加Maven依赖（pom.xml）

<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- MyBatis-Plus -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.3.2</version>
    </dependency>
    
    <!-- Dynamic-Datasource（核心） -->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
        <version>3.6.1</version>
    </dependency>
    
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    
    <!-- 连接池（可选） -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.16</version>
    </dependency>
</dependencies>

2. 配置文件（application.yml）

spring:
  datasource:
    dynamic:
      primary: master # 默认数据源
      datasource:
        master:
          url: jdbc:mysql://主库IP:3306/db_name?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
          username: root
          password: master_password
          driver-class-name: com.mysql.cj.jdbc.Driver
          hikari:
            maximum-pool-size: 10
            minimum-idle: 5
        slave:
          url: jdbc:mysql://从库IP:3306/db_name?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
          username: root
          password: slave_password
          driver-class-name: com.mysql.cj.jdbc.Driver
          hikari:
            maximum-pool-size: 15
            minimum-idle: 8
      strategy:
        # 读写分离策略：读操作走从库，写操作走主库
        # 可选：round_robin（轮询）、random（随机）等
        datasource:
          master: slave

3. 代码实现

a. 定义数据源枚举

public enum DataSourceType {
    MASTER,  // 主库：写操作
    SLAVE    // 从库：读操作
}

b. 数据源上下文管理器

public class DataSourceContextHolder {
    private static final ThreadLocal<DataSourceType> CONTEXT_HOLDER = new ThreadLocal<>();

    public static void setDataSourceType(DataSourceType dataSourceType) {
        CONTEXT_HOLDER.set(dataSourceType);
    }

    public static DataSourceType getDataSourceType() {
        return CONTEXT_HOLDER.get() == null ? DataSourceType.MASTER : CONTEXT_HOLDER.get();
    }

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

c. 使用AOP标注读写操作

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    DataSourceType value() default DataSourceType.MASTER;
}

d. AOP切面实现

@Aspect
@Component
public class DataSourceAspect {
    @Before("@annotation(dataSource)")
    public void before(JoinPoint point, DataSource dataSource) {
        DataSourceType type = dataSource.value();
        DataSourceContextHolder.setDataSourceType(type);
    }

    @After("@annotation(dataSource)")
    public void after(JoinPoint point, DataSource dataSource) {
        DataSourceContextHolder.clearDataSourceType();
    }
}

e. 在Service层使用

@Service
public class OrderService {
    @Autowired
    private OrderMapper orderMapper;
    
    // 写操作：默认走主库（也可以显式指定）
    @DataSource(DataSourceType.MASTER)
    public void createOrder(Order order) {
        orderMapper.insert(order);
    }
    
    // 读操作：默认走从库
    @DataSource(DataSourceType.SLAVE)
    public Order getOrderById(Long id) {
        return orderMapper.selectById(id);
    }
}

三、Redis和MQ整合方案分析

项目引入 redis和mq ，针对【热门数据】的查询可以从redis查询，代码层面往MySQL主库执行增删改操作后往mq发送一条消息，然后由消费者将增删改的数据同步到redis中，当然这样的方案只适合少量的增删改操作，不适合大批量的增删改。

优点：

问题与建议：

  1. 不适合大批量操作：大批量增删改会导致MQ消息量过大，处理延迟高。建议：

    • 对于大批量操作，使用批量同步（如Redis的pipeline）而不是MQ。
    • 或者使用定时任务定期同步热点数据。

  2. 消息可靠性：需要考虑MQ消息丢失、重复消费问题：

    • 使用RocketMQ/RabbitMQ的事务消息。
    • 添加消息重试机制。
    • 消费者 添加 幂等性 处理。

  3. 更适合的场景：

    • 用户信息、商品详情等高频查询数据。
    • 但 不适用于 订单状态、交易流水等 高一致性 要求的数据。

优化：

@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    @DataSource(DataSourceType.MASTER)
    @Transactional
    public Order createOrder(Order order) {
        // 1. 写数据库
        Order savedOrder = orderMapper.insert(order);
        
        // 2. 发送MQ消息（只针对需要缓存的数据）
        if (isCacheableData(order)) {
            rabbitTemplate.convertAndSend("order-cache-topic", 
                new OrderCacheMessage(savedOrder.getId(), "CREATE"));
        }
        
        return savedOrder;
    }
}

// 消费者处理
@Component
public class OrderCacheConsumer {
    @RabbitListener(queues = "order-cache-queue")
    public void process(OrderCacheMessage message) {
        if ("CREATE".equals(message.getAction())) {
            Order order = orderMapper.selectById(message.getOrderId());
            redisTemplate.opsForValue().set("order:" + message.getOrderId(), order);
        }
        // 处理其他操作...
    }
}

四、总结

  1. 读写分离：使用Dynamic-Datasource，配置简单，社区支持好，比Sharding-JDBC更轻量

  2. Redis+MQ方案：

    • 适合 热点数据 的缓存更新。
    • 不适用于 大批量操作。
    • 建议对需要缓存的数据做分类，只对高频查询的数据使用MQ同步。

  3. 建议：

    • 在查询方法上使用@DataSource(DataSourceType.SLAVE)显式指定，避免默认路由错误。
    • 对于复杂查询，可以考虑在MyBatis中使用@Select指定数据源。
    • 监控主从延迟，避免从库数据不一致。

🌟 小技巧：在开发阶段，可以在配置中添加dynamic.datasource.log=true，这样能打印出实际使用的数据源，方便排查问题。

到此这篇关于Spring Boot + MySQL读写分离实现方案的文章就介绍到这了,更多相关SpringBoot+MySQL读写分离内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文