Sharding-JDBC + MyBatis-Plus + Druid 实现读写分离（yml方式 和 xml方式）

一、概述

1. 当业务数据越来越大时，就需要进行分库分表，而 Sharding-JDBC 框架就是能完整的实现分库分表、读写分离和分布式主键等功能。
2. 此处实现读写分离功能。因为是测试，就在同一个 MySQL 中创建两个数据库来模拟。
3. Sharding-JDBC 的配置方式四种：Java，YAML，Spring命名空间和Spring Boot Starter。此处只讲 YAML 和 XML 方式。

二、数据准备

1. 新建两个数据库：ds_0 和 ds_1

   CREATE DATABASE `ds_0` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'
   CREATE DATABASE `ds_1` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci'
   

2. 在两个数据库中创建相同的表，然后分别插入一条不同的数据

   CREATE TABLE `user` (
    `id` BIGINT(64) NOT NULL,
     `city` VARCHAR(20) NOT NULL,
     `name` varchar(20) NOT NULL,
     PRIMARY KEY (`id`)
   ) ENGINE=INNODB  DEFAULT CHARSET=utf8;
   
   -- ds_0 数据库添加
   INSERT into user values(1001, '上海', '咖啡');
   -- ds_1 数据库添加
   INSERT into user values(1002, '北京', '盖伦');
   

3. 在数据库中创建对应的实体

三、第一种方式：使用 Xml 配置

1. 引入 pom 文件：

   <dependency>
       <groupId>com.baomidou</groupId>
       <artifactId>mybatis-plus-boot-starter</artifactId>
       <version>3.3.1.tmp</version>
   </dependency>
   
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.1.12</version>
   </dependency>
   
   <dependency>
       <groupId>com.dangdang</groupId>
       <artifactId>sharding-jdbc-config-spring</artifactId>
       <version>1.5.4.1</version>
   </dependency>
   

2. 在 resource 目录下新建 sharding.xml。配置如下：

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:rdb="http://www.dangdang.com/schema/ddframe/rdb"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.dangdang.com/schema/ddframe/rdb
                           http://www.dangdang.com/schema/ddframe/rdb/rdb.xsd
                           ">
       <!-- 主数据 -->
       <bean id="ds_0" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close" primary="true">
           <property name="driverClassName" value="com.mysql.jdbc.Driver" />
           <property name="url" value="jdbc:mysql://localhost:3306/ds_0??autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false" />
           <property name="username" value="root" />
           <property name="password" value="123456" />
       </bean>
   
       <!-- 从数据 -->
       <bean id="ds_1" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close" >
           <property name="driverClassName" value="com.mysql.jdbc.Driver" />
           <property name="url" value="jdbc:mysql://localhost:3306/ds_1??autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false" />
           <property name="username" value="root" />
           <property name="password" value="123456" />
       </bean>
   
       <!-- 读写分离数据源 -->
       <rdb:master-slave-data-source id="dataSource" master-data-source-ref="ds_0" slave-data-sources-ref="ds_1" />
   
       <!-- 给 MyBatis-Plus 配置数据源 -->
       <bean id="mybatisSqlSessionFactoryBean" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
           <property name="dataSource" ref="dataSource"/>
       </bean>
   </beans>
   

3. 在启动类上添加对应注解，引入 sharding.xml。如下：

   @ImportResource(locations = "classpath:sharding.xml")
   @MapperScan("com.xjf.sharding.mapper")
   @SpringBootApplication
   public class ShardingApplication {
       public static void main(String[] args) {
           SpringApplication.run(ShardingApplication.class, args);
       }
   }
   

4. 对应的 mapper 、controller等文件的创建不讲解，用来测试。下面统一讲效果。

四、第二种方式：YAML 配置

1. 引入 pom 文件：

   <dependency>
       <groupId>org.apache.shardingsphere</groupId>
       <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
       <version>4.0.0-RC1</version>
   </dependency>
   

2. 配置 application.yml 文件，如下：

   # 数据源配置，实现读写分离
   spring:
     main:
       allow-bean-definition-overriding: true
     shardingsphere:
       datasource:
         names:
           master,slave
         # 主数据源
         master:
           type: com.alibaba.druid.pool.DruidDataSource
           driver-class-name: com.mysql.jdbc.Driver
           url: jdbc:mysql://localhost:3306/ds_0?characterEncoding=utf-8&useSSL=true
           username: root
           password: 123456
         # 从数据源
         slave:
           type: com.alibaba.druid.pool.DruidDataSource
           driver-class-name: com.mysql.jdbc.Driver
           url: jdbc:mysql://localhost:3306/ds_1?characterEncoding=utf-8&useSSL=true
           username: root
           password: 123456
       masterslave:
         # 读写分离配置
         load-balance-algorithm-type: round_robin
         # 最终的数据源名称
         name: dataSource
         # 主库数据源名称
         master-data-source-name: master
         # 从库数据源名称列表，多个逗号分隔
         slave-data-source-names: slave
       props:
         # 开启SQL显示，默认false
         sql:
           show: true
   
   # mybatis-plus 打印日志
   mybatis-plus:
     configuration:
       log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
   

3. 启动类配置和上面一种情况一样，不过不需要引入 xml 文件那个注解。
4. 对应的 mapper 、controller等文件的创建不讲解，用来测试。下面统一讲效果。

五、测试

1. 创建两个接口，一个是查询，一个是新增：

   @GetMapping("/list")
   public List<User> select(){
   
       LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
       List<User> userList = userMapper.selectList(queryWrapper);
   
       userList.forEach(System.err::println);
   
       return userList;
   }
   
   @GetMapping("/add")
   public boolean add(){
       User user = new User();
       user.setId(2L);
       user.setCity("弗雷尔卓德");
       user.setName("布隆");
   
       int insert = userMapper.insert(user);
   
       return insert > 0;
   }
   

2. 调用查询接口，如下图，可以看到查询的是从数据库 ds_1 中的数据：
   
   
3. 调用新增接口，可以从数据库查询数据，会发现数据新增到 ds_0 数据库中。
   
4. 由此可见，Sharding-JDBC 实现读写分离成功！！！

看《Spring Cloud微服务入门、实战与进阶》