面对日益增加的系统访问量，数据库的吞吐量面临着巨大瓶颈。对于同一时间有大量并发读操作和较少写操作类型的应用系统来说，将单一的数据库拆分为主库和从库，主库负责处理事务性的增删改操作，从库负责处理查询操作，能够有效的避免由数据更新导致的行锁，使得整个系统的查询性能得到极大的改善。透明化读写分离所带来的影响，让使用方尽量像使用一个数据库一样使用主从数据库，是读写分离中间件的主要功能。

Sharding-JDBC 已经提供了读写分离的支持，可以看看如下两个文档：

ShardingSphere > 概念 & 功能 > 读写分离
ShardingSphere > 用户手册 > Sharding-JDBC > 使用手册 > 读写分离

本文不涉及数据库主从同步的相关配置，只是在读库进行手动插入数据来模拟。

一、引入依赖



    
        org.springframework.boot
        spring-boot-starter-parent
        2.3.0.RELEASE
         
    
    4.0.0

    dynamic-datasource-sharding-jdbc-02

    
        
        
            org.springframework.boot
            spring-boot-starter-jdbc
        
         
            mysql
            mysql-connector-java
            5.1.48
        

        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            2.1.1
        

        
        
            org.apache.shardingsphere
            sharding-jdbc-spring-boot-starter
            4.0.0-RC2
        

        
        
            org.springframework
            spring-aspects
        

        
        
            org.springframework.boot
            spring-boot-starter-test
            test

二、Application

package cn.iocoder.springboot.lab17.dynamicdatasource;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @description 启动类
 * @ClassName: Application
 * @author: 郭秀志 [email protected]
 * @date: 2020/6/30 17:17
 * @Copyright:
 */
@SpringBootApplication
@MapperScan(basePackages = "cn.iocoder.springboot.lab17.dynamicdatasource.mapper")
@EnableAspectJAutoProxy(exposeProxy = true) // http://www.voidcn.com/article/p-zddcuyii-bpt.html
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

三、配置文件

在 [resources] 目录下，创建 [application.yaml]配置文件。配置如下：

spring:
  # ShardingSphere 配置项
  shardingsphere:
    # 数据源配置
    datasource:
      # 所有数据源的名字
      names: ds-master, ds-slave-1, ds-slave-2
      # 订单 orders 主库的数据源配置
      ds-master:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://101.133.227.13:3306/test_orders?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: IA8oD
      # 订单 orders 从库数据源配置
      ds-slave-1:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://101.133.227.13:3306/test_orders_01?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: IA8o
      # 订单 orders 从库数据源配置
      ds-slave-2:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://101.133.227.13:3306/test_orders_02?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: IA8
    # 读写分离配置，对应 YamlMasterSlaveRuleConfiguration 配置类
    masterslave:
      name: ms # 名字，任意，需要保证唯一
      master-data-source-name: ds-master # 主库数据源
      slave-data-source-names: ds-slave-1, ds-slave-2 # 从库数据源

# mybatis 配置内容
mybatis:
  config-location: classpath:mybatis-config.xml # 配置 MyBatis 配置文件路径
  mapper-locations: classpath:mapper/*.xml # 配置 Mapper XML 地址
  type-aliases-package: cn.iocoder.springboot.lab17.dynamicdatasource.dataobject # 配置数据库实体包路径

spring.shardingsphere.datasource 配置项下，我们配置了一个主数据源 ds-master 、两个从数据源 ds-slave-1、ds-slave-2 。
spring.shardingsphere.masterslave 配置项下，配置了读写分离。对于从库来说，Sharding-JDBC 提供了多种负载均衡策略，默认为轮询。
mybatis 配置项，设置 mybatis-spring-boot-starter MyBatis 的配置内容。

四、创建表

因为本地并未搭建 MySQL 一主多从的环境，所以是通过创建了 test_orders_01、test_orders_02 库，手动模拟作为 test_orders 的从库。
对应的创建表的 SQL 如下：

CREATE DATABASE `test_orders` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

-- 在 `test_orders` 库中。
CREATE TABLE `orders` (
  `id` int(11) DEFAULT NULL COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

五、MyBatis 配置文件

六、OrderDO

package cn.iocoder.springboot.lab17.dynamicdatasource.dataobject;

/**
 * 订单 DO
 */
public class OrderDO {

    /**
     * 订单编号
     */
    private Integer id;
    /**
     * 用户编号
     */
    private Integer userId;

    public Integer getId() {
        return id;
    }

    public OrderDO setId(Integer id) {
        this.id = id;
        return this;
    }

    public Integer getUserId() {
        return userId;
    }

    public OrderDO setUserId(Integer userId) {
        this.userId = userId;
        return this;
    }

    @Override
    public String toString() {
        return "OrderDO{" +
                "id=" + id +
                ", userId=" + userId +
                '}';
    }

}

七、OrderMapper

package cn.iocoder.springboot.lab17.dynamicdatasource.mapper;

import cn.iocoder.springboot.lab17.dynamicdatasource.dataobject.OrderDO;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
/**
 * @description 
 * @ClassName: OrderMapper
 * @author: 郭秀志 [email protected]
 * @date: 2020/6/30 17:42    
 * @Copyright:  
 */
@Repository
public interface OrderMapper {

    OrderDO selectById(@Param("id") Integer id);

    int insert(OrderDO entity);

}

八、OrderMapper.xml





    
        id, user_id
    

    

    
        INSERT INTO orders (
          user_id
        ) VALUES (
          #{userId}
        )

九、简单测试

创建 OrderMapperTest 测试类，我们来测试一下简单的 OrderMapper 的读写操作。代码如下：

// OrderMapper.java

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class OrderMapperTest {

 @Autowired
 private OrderMapper orderMapper;

 @Test
 public void testSelectById() { // 测试从库的负载均衡
 for (int i = 0; i < 10; i++) {
 OrderDO order = orderMapper.selectById(1);
 System.out.println(order);
 }
 }

 @Test
 public void testSelectById02() { // 测试强制访问主库
 try (HintManager hintManager = HintManager.getInstance()) {
 // 设置强制访问主库
 hintManager.setMasterRouteOnly();
 // 执行查询
 OrderDO order = orderMapper.selectById(1);
 System.out.println(order);
 }
 }

 @Test
 public void testInsert() { // 插入
 OrderDO order = new OrderDO();
 order.setUserId(10);
 orderMapper.insert(order);
 }

}

testSelectById() 方法，测试从库的负载均衡查询。
testSelectById02() 方法，测试强制访问主库。在一些业务场景下，对数据延迟敏感，所以只能强制读取主库。此时，可以使用 HintManager 强制访问主库。
- 不过要注意，在使用完后，需要去清理下 HintManager （HintManager 是基于线程变量，透传给 Sharding-JDBC 的内部实现），避免污染下次请求，一直强制访问主库。
- Sharding-JDBC 比较贴心，HintManager 实现了 AutoCloseable 接口，可以通过 Try-with-resources 机制，自动关闭。代码为：try (HintManager hintManager = HintManager.getInstance())
testInsert() 方法，测试主库的插入。

跑下测试用例。如果跑通，说明配置就算成功了。

另外，在 testSelectById()测试方法中，测试 slave 分组是不是真的在负载均衡。所以在数据库中，分别插入数据如下。

主库：[id = 1, user_id = 1]
从库 01：[id = 1, user_id = 2]
从库 02：[id = 1, user_id = 3]

这样，通过手动设置相同 id = 1 的记录，对应不同的 user_id ，那么我们就可以观察 testSelectById()测试方法的输出结果。如果是，user_id = 2 和 user_i = 3 交替循环输出，说明就正常了。

2个从库负载均衡读取

十、详细测试

在 cn.iocoder.springboot.lab17.dynamicdatasource.service 包路径下，创建 OrderService.java 类。代码如下：

// OrderService.java

@Service
public class OrderService {

 @Autowired
 private OrderMapper orderMapper;

 @Transactional
 public void add(OrderDO order) {
 // <1.1> 这里先假模假样的读取一下。读取从库
 OrderDO exists = orderMapper.selectById(1);
 System.out.println(exists);

 // <1.2> 插入订单
 orderMapper.insert(order);

 // <1.3> 这里先假模假样的读取一下。读取主库
 exists = orderMapper.selectById(1);
 System.out.println(exists);
 }

 public OrderDO findById(Integer id) {
 return orderMapper.selectById(id);
 }

}

在 #add(OrderDO order) 方法中，开启事务，插入一条订单记录。
- <1.1> 处，往从库发起一次订单查询。在 Sharding-JDBC 的读写分离策略里，默认读取从库。
- <1.2> 处，往主库发起一次订单写入。写入，肯定是操作主库的。
- <1.3> 处，往主库发起一次订单查询。在 Sharding-JDBC 中，读写分离约定：同一线程且同一数据库连接内，如有写入操作，以后的读操作均从主库读取，用于保证数据一致性。
在 #findById(Integer id) 方法，往从库发起一次订单查询。

我们创建了 [OrderServiceTest]测试类，可以测试上面编写的两个方法。

package cn.iocoder.springboot.lab17.dynamicdatasource.service;

import cn.iocoder.springboot.lab17.dynamicdatasource.Application;
import cn.iocoder.springboot.lab17.dynamicdatasource.dataobject.OrderDO;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @description 测试orderservice
 * @ClassName: OrderServiceTest
 * @author: 郭秀志 [email protected]
 * @date: 2020/7/1 10:52
 * @Copyright:
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class OrderServiceTest {

    @Autowired
    private OrderService orderService;

    @Test
    public void testAdd() {
        OrderDO order = new OrderDO();
        order.setUserId(20);
        orderService.add(order);
    }

    @Test
    public void testFindById() {
        OrderDO order = orderService.findById(1);
        System.out.println(order);
    }

}

运行测试：

testAdd方法

十一、源代码

本文源代码可从Gitee下载。

Sharding-JDBC 读写分离

一、引入依赖

二、Application

三、配置文件

四、创建表

五、MyBatis 配置文件

六、OrderDO

七、OrderMapper

八、OrderMapper.xml

九、简单测试

十、详细测试

十一、源代码

你可能感兴趣的:(Sharding-JDBC 读写分离)

Sharding-JDBC 读写分离

一、 引入依赖

二、Application

三、配置文件

四、创建表

五、MyBatis 配置文件

六、OrderDO

七、OrderMapper

八、OrderMapper.xml

九、简单测试

十、 详细测试

十一、源代码

你可能感兴趣的:(Sharding-JDBC 读写分离)

一、引入依赖

十、详细测试