Sharding-JDBC实现读写分离

🍀 一.Sharding-JDBC实现读写分离环境准备

  上一篇文章中我们讲解了ShardingSphere中分库分表的核心概念以及底层原理，并且带领大家通过Docker搭建了一主一从的MySQL集群架构，那么这篇文章我们就来通过使用Sharding-JDBC来实现读写分离。文章的地址在下方，可以先搭建好环境，再来学习本篇文章！
ShardingSphere分库分表实战之MySQL主从集群搭建

🍀 二.Sharding-JDBC实现读写分离实战

  Sharding-JDBC读写分离则是根据SQL语义的分析，将读操作和写操作分别路由至主库与从库。它提供透明化读写分离，让使用方尽量像使用一个数据库一样使用主从数据库集群。

🥦 2.1 主库同步的数据库创建表，从库直接同步即可

注意:因为我们之前配置的主从同步的数据库是test，所有我们要在test数据库下进行案例的演示，以及数据的同步！

CREATE TABLE `products` (
  `pid` bigint(32) NOT NULL AUTO_INCREMENT,
  `pname` varchar(50) DEFAULT NULL,
  `price` int(11) DEFAULT NULL,
  `flag` varchar(2) DEFAULT NULL,
  PRIMARY KEY (`pid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

主从同步

🥦 2.2 创建SpringBoot程序 - 导入依赖

在pom.xml配置文件中导入需要依赖的环境，SpringBoot2.3.7+ MyBatisPlus + ShardingSphere-JDBC 5.1 + Hikari+ MySQL 5.7

  <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
            <version>5.1.1</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

🥦 2.3 创建SpringBoot程序 - 实体类

与数据库表中对应的实体类

@TableName("products")
@Data
public class Products {

    @TableId(value = "pid",type = IdType.AUTO)
    private Long pid;

    private String pname;

    private Integer price;

    private String flag;

}

🥦 2.4 创建SpringBoot程序 - 数据库Mapper接口

编写对应的数据库持久层ProductsMapper接口

@Mapper
public interface ProductsMapper extends BaseMapper<Products> {

}

🥦 2.5 创建SpringBoot程序 - 读写分离配置文件

配置读写分离相关配置的信息

# 应用名称
spring.application.name=shardingjdbc-write-read-demo

# 打印SQl
spring.shardingsphere.props.sql-show=true

# 定义读写分离的数据源
spring.shardingsphere.datasource.names=master,slave

# 数据源1
spring.shardingsphere.datasource.master.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.master.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.master.jdbc-url=jdbc:mysql://192.168.10.132:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.shardingsphere.datasource.master.username=root
spring.shardingsphere.datasource.master.password=root

# 数据源2
spring.shardingsphere.datasource.slave.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave.driver-class-name=com.mysql.jdbc.Driver
spring.shardingsphere.datasource.slave.jdbc-url=jdbc:mysql://192.168.10.133:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.shardingsphere.datasource.slave.username=root
spring.shardingsphere.datasource.slave.password=root

#读写分离 主从关系
# 读写分离类型，如: Static，Dynamic, ms1 包含了  m1 和 s1
spring.shardingsphere.rules.readwrite-splitting.data-sources.ms1.type=Static

# 写数据源名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.ms1.props.write-data-source-name=master

# 读数据源名称，多个从数据源用逗号分隔
spring.shardingsphere.rules.readwrite-splitting.data-sources.ms1.props.read-data-source-names=slave

拓展：负载均衡配置，因为我们演示的案例是一主一从的架构，所以我们无需配置负载均衡相关的内容，但是此处我给大家将内容总结出来，方便你在后续的工作学习当中使用到！

读写分离读库负载均衡算法

# 负载均衡算法名称
spring.shardingsphere.rules.readwrite-splitting.data-sources.myds.load-balancer-name=alg_round

# 负载均衡算法配置
# 负载均衡算法类型
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_round.type=ROUND_ROBIN  # 轮询
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_random.type=RANDOM      # 随机
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.type=WEIGHT      # 权重
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.props.slave1=1
spring.shardingsphere.rules.readwrite-splitting.load-balancers.alg_weight.props.slave2=2

🍀 三.读写分离测试

🥦 3.1 写测试

	@Autowired
    private ProductsMapper productsMapper;

    @Test
    public void testInsert(){
        Products products = new Products();
        products.setPname("平板电脑");
        products.setPrice(8000);
        products.setFlag("has");
        productsMapper.insert(products);
    }

运行结果：

数据插入成功

🥦 3.2 读测试

	@Test
    public void testSelect(){
        QueryWrapper<Products> wrapper = new QueryWrapper<>();
        wrapper.eq("pname","平板电脑");
        List<Products> list = productsMapper.selectList(wrapper);
        list.forEach(System.out::println);
    }

运行结果：

🥦 3.3 读写分离 + 事务测试

为了保证主从库间的事务一致性，避免跨服务的分布式事务，ShardingSphere-JDBC的主从模型中，事务中的数据读写均用主库。

注意：在JUnit环境下的@Transactional注解，默认情况下就会对事务进行回滚（即使在没加注解@Rollback，也会对事务回滚）

	@Test
    @Transactional
    public void testInsert(){
        Products products = new Products();
        products.setPname("平板电脑");
        products.setPrice(8000);
        products.setFlag("0");
        productsMapper.insert(products);

        QueryWrapper<Products> wrapper = new QueryWrapper<>();
        wrapper.eq("pname","平板电脑");
        List<Products> list = productsMapper.selectList(wrapper);
        list.forEach(System.out::println);
    }

运行结果：

🍀 四.总结

本篇文章主要讲解了Sharding-JDBC实现读写分离，实操过程非常重要，大家一定要动手亲自实践一下，必须掌握。下节预告，ShardingSphere分库分表实战之强制路由详解与实战，敬请期待。

💬 五.共勉