ShardingJDBC 和 ShardingProxy 的入门学习

系统管理员 2022-12-27 08:55 430阅读 0赞

### 文章目录 ###

*   *  1、水平分表（表）
     *   *  1.1、创建数据库和表
         *  1.2、创建 springboot2.x 项目
         *  1.3、编写实体对象和Mapper
         *  1.4、ShardingJDBC 水平分表（表）配置
         *  1.5、测试代码
         *  1.6、异常说明：
         *   *  Invalid bean definition with name 'dataSource' defined in class path resource
     *  2、水平分库（库）
     *   *  2.1、需求分析
         *  2.2、创建数据库和表
         *  2.3、水平分库（库）配置：
     *  3、垂直分库（库）
     *   *  3.1、需求分析
         *  3.2、创建数据库和表
         *  3.3、编写实体类和Mapper
         *  3.4、垂直分库（专库专用）配置
         *  3.5、测试代码
         *  3.6、问题： 插入数据时，报 Table 'user\_db.user' doesn't exist 异常
         *   *  1）问题描述
             *  2）分析：
             *  3）解决方法
     *  4、ShardingJDBC 实现公共表
     *   *  4.1、创建公共表
         *  4.2、编写实体对象和Mapper
         *  4.3、公共表配置
         *  4.4、测试代码：
     *  5、windows MySQL 主从复制配置
     *  6、ShardingJDBC 读写分离
     *   *  6.1、读写分离 ShardingJDBC 配置
         *  6.2、测试代码
     *  7、ShardingProxy 配置 和水平分表（表）
     *   *  7.1、修改 \`server.yaml\` 内容
         *  7.2、修改 \`config-sharding.yaml\` 内容
         *  7.3、复制MySQL驱动到 lib 目录下
         *  7.4、将后缀统一修改为 \`jar\`
         *   *  提示 “找不到该项目” 异常解决
         *  7.5、启动 ShardingProxy
         *  7.6、使用mysql 命令，登录 ShardingProxy 的代理端查看
         *  7.7、创建数据库SQL
         *  7.8、在 代理库 sharding\_db 中，向 t\_order 表插入数据：
     *  8、ShardingProxy 水平分库（库）
     *   *  8.1、创建水平数据库
         *  8.2、修改 config-sharding.yaml 内容：
         *  8.3、启动 ShardingProxy
         *  8.4、进入 ShardingProxy 的代理端查看
         *  8.5、创建数据库
         *  8.6、在 代理库 sharding\_db 中，向 t\_order 表插入数据：
     *  9、ShardingProxy 读写分离
     *   *  9.1、windows MySQL 主从复制配置
         *  9.2、配置文件修改
         *  9.3、启动 ShardingProxy
         *  9.4 、测试

## 1、水平分表（表） ##

### 1.1、创建数据库和表 ###

创建数据库： course\_db

创建表： course\_1、course\_2

CREATE DATABASE /*!32312 IF NOT EXISTS*/`course_db` /*!40100 DEFAULT CHARACTER SET utf8 */;
    
    USE `course_db`;
    
    CREATE TABLE `course_1` (
      `cid` bigint(20) NOT NULL,
      `cname` varchar(20) NOT NULL,
      `user_id` bigint(20) NOT NULL,
      `cstatus` varchar(20) NOT NULL,
      PRIMARY KEY (`cid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    
    CREATE TABLE `course_2` (
      `cid` bigint(20) NOT NULL,
      `cname` varchar(20) NOT NULL,
      `user_id` bigint(20) NOT NULL,
      `cstatus` varchar(20) NOT NULL,
      PRIMARY KEY (`cid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

![在这里插入图片描述][20201209203619823.png]

### 1.2、创建 springboot2.x 项目 ###

创建 springboot2.2.1 + MyBatisPlus + ShardingJDBC+Druid 连接池

groupId：com.atguigu
    artifactId：shardingjdbcdemo

pom.xml 内容如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.2.1.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.test</groupId>
        <artifactId>shardingjdbcdemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>shardingjdbcdemo</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.20</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.shardingsphere</groupId>
                <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
                <version>4.0.0-RC1</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.0.5</version>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

### 1.3、编写实体对象和Mapper ###

import lombok.Data;
    
    @Data
    public class Course { 
        private Long cid;
        private String cname;
        private Long userId;
        private String cstatus;
    }

@Repository
    public interface CourseMapper extends BaseMapper<Course> { 
    
    }

### 1.4、ShardingJDBC 水平分表（表）配置 ###

application.properties：

# 配置数据源，给数据源起名称
    spring.shardingsphere.datasource.names=m1
    
    # 一个实体类对应两张表，覆盖
    # spring.main.allow-bean-definition-overriding=true
    
    #配置数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/course_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m1.username=root
    spring.shardingsphere.datasource.m1.password=root
    
    #指定course表分布情况，配置表在哪个数据库里面，表名称都是什么  m1.course_1 , m1.course_2
    spring.shardingsphere.sharding.tables.course.actual-data-nodes=m1.course_$->{1..2}
    
    # 指定course表里面主键cid 生成策略  SNOWFLAKE
    spring.shardingsphere.sharding.tables.course.key-generator.column=cid
    spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE
    
    # 指定分片策略  约定cid值偶数添加到course_1表，如果cid是奇数添加到course_2表
    spring.shardingsphere.sharding.tables.course.table-strategy.inline.sharding-column=cid
    spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithm-expression=course_$->{cid % 2 + 1}
    
    # 打开sql输出日志
    spring.shardingsphere.props.sql.show=true

### 1.5、测试代码 ###

package com.test.shardingjdbcdemo;
    
    import com.test.shardingjdbcdemo.entity.Course;
    import com.test.shardingjdbcdemo.entity.Udict;
    import com.test.shardingjdbcdemo.entity.User;
    import com.test.shardingjdbcdemo.mapper.CourseMapper;
    import com.test.shardingjdbcdemo.mapper.UdictMapper;
    import com.test.shardingjdbcdemo.mapper.UserMapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    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;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ShardingjdbcTests01 { 
    
        //注入mapper
        @Autowired
        private CourseMapper courseMapper;
    
    
        //======================测试水平分库=====================
        //单个添加操作
        @Test
        public void addCourseDb() { 
            Course course = new Course();
            course.setCname("javademo1");
            //分库根据user_id
            course.setUserId(111L);
            course.setCstatus("Normal1");
            courseMapper.insert(course);
        }
    
        //查询操作
        @Test
        public void findCourseDb() { 
            QueryWrapper<Course>  wrapper = new QueryWrapper<>();
            //设置userid值
            wrapper.eq("user_id",111L);
            //设置cid值
            wrapper.eq("cid",542729462081388545L);
            Course course = courseMapper.selectOne(wrapper);
            System.out.println("查询结果： "+ course);
        }
    
        //=======================测试水平分表===================
        //批量添加课程的方法
        @Test
        public void addCourse() { 
            for(int i=1;i<=10;i++) { 
                Course course = new Course();
                course.setCname("java"+i);
                course.setUserId(100L);
                course.setCstatus("Normal"+i);
                courseMapper.insert(course);
            }
        }
        //查询课程的方法
        @Test
        public void findCourse() { 
            QueryWrapper<Course>  wrapper = new QueryWrapper<>();
            wrapper.eq("cid",542730328716869633L);
            Course course = courseMapper.selectOne(wrapper);
            System.out.println(course);
        }
    }

### 1.6、异常说明： ###

#### Invalid bean definition with name ‘dataSource’ defined in class path resource ####

***************************
    APPLICATION FAILED TO START
    ***************************
    
    Description:
    
    The bean 'dataSource', defined in class path resource [org/apache/shardingsphere/shardingjdbc/spring/boot/SpringBootConfiguration.class], could not be registered. A bean with that name has already been defined in class path resource [com/alibaba/druid/spring/boot/autoconfigure/DruidDataSourceAutoConfigure.class] and overriding is disabled.
    
    Action:
    
    Consider renaming one of the beans or enabling overriding by setting spring.main.allow-bean-definition-overriding=true
    
    2020-12-07 15:39:40.351 ERROR 9584 --- [           main] o.s.test.context.TestContextManager      : Caught exception while allowing TestExecutionListener [org.springframework.boot.test.autoconfigure.SpringBootDependencyInjectionTestExecutionListener@459e9125] to prepare test instance [com.test.shardingjdbcdemo.ShardingjdbcTests01@7dcf94f8]
    
    java.lang.IllegalStateException: Failed to load ApplicationContext
    	at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:132) ~[spring-test-5.2.1.RELEASE.jar:5.2.1.RELEASE]
    	at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:123) ~[spring-test-5.2.1.RELEASE.jar:5.2.1.RELEASE]
    	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.injectDependencies(DependencyInjectionTestExecutionListener.java:118) ~[spring-test-5.2.1.RELEASE.jar:5.2.1.RELEASE]
    	at org.springframework.test.context.support.DependencyInjectionTestExecutionListener.prepareTestInstance(DependencyInjectionTestExecutionListener.java:83) ~[spring-test-5.2.1.RELEASE.jar:5.2.1.RELEASE]
    	at 
    	
    	
    	Caused by: org.springframework.beans.factory.support.BeanDefinitionOverrideException: Invalid bean definition with name 'dataSource' defined in class path resource [org/apache/shardingsphere/shardingjdbc/spring/boot/SpringBootConfiguration.class]: Cannot register bean definition [Root bean: class [null]; scope=; abstract=false; lazyInit=null; autowireMode=3; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=org.apache.shardingsphere.shardingjdbc.spring.boot.SpringBootConfiguration; factoryMethodName=dataSource; initMethodName=null; destroyMethodName=(inferred); defined in class path resource [org/apache/shardingsphere/shardingjdbc/spring/boot/SpringBootConfiguration.class]] for bean 'dataSource': There is already [Root bean: class [null]; scope=; abstract=false; lazyInit=null; autowireMode=3; dependencyCheck=0; autowireCandidate=true; primary=false; factoryBeanName=com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure; factoryMethodName=dataSource; initMethodName=init; destroyMethodName=(inferred); defined in class path resource [com/alibaba/druid/spring/boot/autoconfigure/DruidDataSourceAutoConfigure.class]] bound.
    	at org.springframework.beans.factory.support.DefaultListableBeanFactory.registerBeanDefinition(DefaultListableBeanFactory.java:927)
    	at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForBeanMethod(ConfigurationClassBeanDefinitionReader.java:287)
    	at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitionsForConfigurationClass(ConfigurationClassBeanDefinitionReader.java:144)
    	at org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader.loadBeanDefinitions(ConfigurationClassBeanDefinitionReader.java:120)

解决方法：

在 application.properties 中添加如下配置：

spring.main.allow-bean-definition-overriding=true

## 2、水平分库（库） ##

水平分库（库），再加上一步的水平分表（表） 。

### 2.1、需求分析 ###

![在这里插入图片描述][20201209203649322.png]

**数据库的规则：**

userid 为 `偶数` 时，数据添加到 edu\_db\_1数据库中；

userid 为 `奇数` 时，数据添加到 edu\_db\_2数据库中。

**表的规则：**

cid 为 `偶数` 时，数据添加到 course\_1 表中；

cid 为 `奇数` 时，数据添加到 course\_2 表中；

### 2.2、创建数据库和表 ###

创建数据库 edu\_db\_1，及其表 course\_1、course\_2 。

创建数据库 edu\_db\_2，及其表 course\_1、course\_2 。

CREATE DATABASE /*!32312 IF NOT EXISTS*/`edu_db_1` /*!40100 DEFAULT CHARACTER SET utf8 */;
    
    USE `edu_db_1`;
    
    /*Table structure for table `course_1` */
    
    CREATE TABLE `course_1` (
      `cid` bigint(20) NOT NULL,
      `cname` varchar(20) NOT NULL,
      `user_id` bigint(20) NOT NULL,
      `cstatus` varchar(20) NOT NULL,
      PRIMARY KEY (`cid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    /*Data for the table `course_1` */
    
    /*Table structure for table `course_2` */
    
    CREATE TABLE `course_2` (
      `cid` bigint(20) NOT NULL,
      `cname` varchar(20) NOT NULL,
      `user_id` bigint(20) NOT NULL,
      `cstatus` varchar(20) NOT NULL,
      PRIMARY KEY (`cid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE DATABASE /*!32312 IF NOT EXISTS*/`edu_db_2` /*!40100 DEFAULT CHARACTER SET utf8 */;
    
    USE `edu_db_2`;
    
    /*Table structure for table `course_1` */
    
    CREATE TABLE `course_1` (
      `cid` bigint(20) NOT NULL,
      `cname` varchar(20) NOT NULL,
      `user_id` bigint(20) NOT NULL,
      `cstatus` varchar(20) NOT NULL,
      PRIMARY KEY (`cid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    /*Data for the table `course_1` */
    
    /*Table structure for table `course_2` */
    
    CREATE TABLE `course_2` (
      `cid` bigint(20) NOT NULL,
      `cname` varchar(20) NOT NULL,
      `user_id` bigint(20) NOT NULL,
      `cstatus` varchar(20) NOT NULL,
      PRIMARY KEY (`cid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

![在这里插入图片描述][20201209203658886.png]

### 2.3、水平分库（库）配置： ###

### 水平分库（库），  再加上前面的水平分表（表）
    
    # 配置数据源，给数据源起名称,
    # 水平分库，配置两个数据源
    spring.shardingsphere.datasource.names=m1,m2
    
    # 一个实体类对应两张表，覆盖
    spring.main.allow-bean-definition-overriding=true
    
    #配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m1.username=root
    spring.shardingsphere.datasource.m1.password=root
    
    #配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m2.username=root
    spring.shardingsphere.datasource.m2.password=root
    
    #指定数据库分布情况，数据库里面表分布情况
    # m1  m2    course_1 course_2
    spring.shardingsphere.sharding.tables.course.actual-data-nodes=m$->{1..2}.course_$->{1..2}
    
    # 指定course表里面主键cid 生成策略  SNOWFLAKE
    spring.shardingsphere.sharding.tables.course.key-generator.column=cid
    spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE
    
    # 表（表）的分片策略，约定cid值偶数添加到course_1表，如果cid是奇数添加到course_2表
    spring.shardingsphere.sharding.tables.course.table-strategy.inline.sharding-column=cid
    spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithm-expression=course_$->{cid % 2 + 1}
    
    # 数据库（库）的分片策略，约定user_id是偶数添加m1，是奇数添加m2
    spring.shardingsphere.sharding.tables.course.database-strategy.inline..sharding-column=user_id
    spring.shardingsphere.sharding.tables.course.database-strategy.inline.algorithm-expression=m$->{user_id % 2 + 1}
    
    # 打开sql输出日志
    spring.shardingsphere.props.sql.show=true

\#\#\#　2.4、测试代码

import com.test.shardingjdbcdemo.entity.Course;
    import com.test.shardingjdbcdemo.entity.Udict;
    import com.test.shardingjdbcdemo.entity.User;
    import com.test.shardingjdbcdemo.mapper.CourseMapper;
    import com.test.shardingjdbcdemo.mapper.UdictMapper;
    import com.test.shardingjdbcdemo.mapper.UserMapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    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;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ShardingjdbcTests02 { 
    
        //注入mapper
        @Autowired
        private CourseMapper courseMapper;
    
    
        //======================测试水平分库=====================
        //添加操作
        @Test
        public void addCourseDb() { 
            for(int i=1;i<=10;i++) { 
                Course course = new Course();
                course.setCname("javademo1"+i);
                //分库根据 user_id
                //course.setUserId(100L);
                course.setUserId(111L);
                course.setCstatus("Normal1");
                courseMapper.insert(course);
            }
        }
    
        //查询操作
        @Test
        public void findCourseDb() { 
            QueryWrapper<Course>  wrapper = new QueryWrapper<>();
            //设置userid值
            wrapper.eq("user_id",100L);
            //设置cid值
            wrapper.eq("cid",465162909769531393L);
            Course course = courseMapper.selectOne(wrapper);
            System.out.println(course);
        }
    }

**说明：**

userid 为 `偶数` 时，数据插 入到 edu\_db\_1 数据库中；

![在这里插入图片描述][20201209203710254.png]

userid 为 `奇数` 时，数据插 入到 edu\_db\_2数据库中。

![在这里插入图片描述][20201209203718652.png]

cid 是雪花算法生成的，

cid 为 `偶数` 时，数据添加到 course\_1 表中；

cid 为 `奇数` 时，数据添加到 course\_2 表中；

## 3、垂直分库（库） ##

把单一的数据库按照来务进行划分，专库专用。

### 3.1、需求分析 ###

![在这里插入图片描述][20201209203727823.png]

### 3.2、创建数据库和表 ###

CREATE DATABASE /*!32312 IF NOT EXISTS*/`user_db` /*!40100 DEFAULT CHARACTER SET utf8 */;
    
    USE `user_db`;
    
    CREATE TABLE `t_user` (
      `user_id` bigint(20) NOT NULL,
      `username` varchar(20) NOT NULL,
      `ustatus` varchar(20) NOT NULL,
      PRIMARY KEY (`user_id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

![在这里插入图片描述][20201209203736622.png]

### 3.3、编写实体类和Mapper ###

import com.baomidou.mybatisplus.annotation.TableName;
    import lombok.Data;
    
    @Data
    // @TableName(value = "t_user") //指定对应表
    public class User { 
        private Long userId;
        private String username;
        private String ustatus;
    }

import com.test.shardingjdbcdemo.entity.User;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface UserMapper extends BaseMapper<User> { 
    
    }

### 3.4、垂直分库（专库专用）配置 ###

#### 垂直分库（库）
    
    # 配置数据源，给数据源起名称,
    # 水平分库，配置两个数据源
    spring.shardingsphere.datasource.names=m0
    
    # 一个实体类对应两张表，覆盖
    spring.main.allow-bean-definition-overriding=true
    
    
    #配置第三个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m0.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m0.url=jdbc:mysql://localhost:3306/user_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m0.username=root
    spring.shardingsphere.datasource.m0.password=root
    
    # 配置user_db数据库里面t_user 专库专表
    spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user
    
    # 指定course表里面主键cid 生成策略  SNOWFLAKE
    spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
    spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
    
    # 指定表分片策略  约定cid值偶数添加到course_1表，如果cid是奇数添加到course_2表
    spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column=user_id
    spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression=t_user
    
    
    # 打开sql输出日志
    spring.shardingsphere.props.sql.show=true

### 3.5、测试代码 ###

import com.test.shardingjdbcdemo.entity.Course;
    import com.test.shardingjdbcdemo.entity.Udict;
    import com.test.shardingjdbcdemo.entity.User;
    import com.test.shardingjdbcdemo.mapper.CourseMapper;
    import com.test.shardingjdbcdemo.mapper.UdictMapper;
    import com.test.shardingjdbcdemo.mapper.UserMapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    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;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ShardingjdbcTests03 { 
    
        //注入user的mapper
        @Autowired
        private UserMapper userMapper;
    
        //======================测试垂直分库==================
        //添加操作
        @Test
        public void addUserDb() { 
            User user = new User();
            user.setUsername("lucy");
            user.setUstatus("a");
            userMapper.insert(user);
        }
    
        //查询操作
        @Test
        public void findUserDb() { 
            QueryWrapper<User>  wrapper = new QueryWrapper<>();
            //设置userid值
            wrapper.eq("user_id",543017187456057345L);
            User user = userMapper.selectOne(wrapper);
            System.out.println(user);
        }
    
    }

主要日志

Actual SQL: m0 ::: INSERT INTO t_user   (username, ustatus, user_id) VALUES (?, ?, ?) ::: [lucy, a, 543017187456057345]

![在这里插入图片描述][20201209203751501.png]

### 3.6、问题： 插入数据时，报 Table ‘user\_db.user’ doesn’t exist 异常 ###

#### 1）问题描述 ####

![在这里插入图片描述][20201209203802849.png]

#### 2）分析： ####

实体类是 User, 对应的表默认是 user，但是数据库表是 t\_user ，对应不上，所以插入失败。

#### 3）解决方法 ####

为 实体类是 User 指定数据库中的对应的表名称， 在User类的上面添加注释 `@TableName(value = "t_user") //指定对应表`，

@Data
    @TableName(value = "t_user")  //指定对应表
    public class User { 
        private Long userId;
        private String username;
        private String ustatus;
    }

## 4、ShardingJDBC 实现公共表 ##

公共表：

（1）存储固定数据的表，表数据很少发生变化，查询时经常需要关联。

（2）在每个数据库中创建相同结构的公共表。

### 4.1、创建公共表 ###

在 `edu_db_1`、`edu_db_2`、`user_db` 数据库中创建 `t_udict` 表。

CREATE TABLE `t_udict` (
      `dictid` bigint(20) NOT NULL,
      `ustatus` varchar(20) NOT NULL,
      `uvalue` varchar(20) NOT NULL,
      PRIMARY KEY (`dictid`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8

![在这里插入图片描述][20201209203811364.png]

### 4.2、编写实体对象和Mapper ###

@Data
    @TableName(value = "t_udict")
    public class Udict { 
        private Long dictid;
        private String ustatus;
        private String uvalue;
    }

import com.test.shardingjdbcdemo.entity.Udict;
    import com.test.shardingjdbcdemo.entity.User;
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface UdictMapper extends BaseMapper<Udict> { 
        
    }

### 4.3、公共表配置 ###

配置公共表的配置如下：

############### begin 配置公共表  ###############
    spring.shardingsphere.sharding.broadcast-tables=t_udict
    spring.shardingsphere.sharding.tables.t_udict.key-generator.column=dictid
    spring.shardingsphere.sharding.tables.t_udict.key-generator.type=SNOWFLAKE
    ############### end  配置公共表  ###############

完整的的配置如下：

################# 公共表配置 #####################
    
    # 配置数据源，给数据源起名称,
    # 水平分库，配置两个数据源
    spring.shardingsphere.datasource.names=m1,m2,m0
    
    # 一个实体类对应两张表，覆盖
    spring.main.allow-bean-definition-overriding=true
    
    #配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m1.username=root
    spring.shardingsphere.datasource.m1.password=root
    
    #配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m2.username=root
    spring.shardingsphere.datasource.m2.password=root
    
    #配置第三个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    spring.shardingsphere.datasource.m0.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m0.url=jdbc:mysql://localhost:3306/user_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m0.username=root
    spring.shardingsphere.datasource.m0.password=root
    
    
    ################ begin 配置公共表  ###############
    spring.shardingsphere.sharding.broadcast-tables=t_udict
    spring.shardingsphere.sharding.tables.t_udict.key-generator.column=dictid
    spring.shardingsphere.sharding.tables.t_udict.key-generator.type=SNOWFLAKE
    ################ end  配置公共表   ################
    
    
    # 配置user_db数据库里面t_user 专库专表
    spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user
    
    # 指定course表里面主键cid 生成策略  SNOWFLAKE
    spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
    spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
    
    # 指定表分片策略  约定cid值偶数添加到course_1表，如果cid是奇数添加到course_2表
    spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column=user_id
    spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression=t_user
    
    
    #指定数据库分布情况，数据库里面表分布情况
    # m1  m2    course_1 course_2
    spring.shardingsphere.sharding.tables.course.actual-data-nodes=m$->{1..2}.course_$->{1..2}
    
    # 指定course表里面主键 cid 生成策略  SNOWFLAKE
    spring.shardingsphere.sharding.tables.course.key-generator.column=cid
    spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE
    
    # 指定表分片策略  约定 cid 值偶数添加到 course_1 表，如果cid是奇数添加到  course_2 表
    spring.shardingsphere.sharding.tables.course.table-strategy.inline.sharding-column=cid
    spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithm-expression=course_$->{cid % 2 + 1}
    
    # 指定数据库分片策略 约定 user_id 是偶数添加 m1 ，是奇数添加 m2
    #spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
    #spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=m$->{user_id % 2 + 1}
    
    spring.shardingsphere.sharding.tables.course.database-strategy.inline..sharding-column=user_id
    spring.shardingsphere.sharding.tables.course.database-strategy.inline.algorithm-expression=m$->{user_id % 2 + 1}
    
    # 打开sql输出日志
    spring.shardingsphere.props.sql.show=true

### 4.4、测试代码： ###

import com.test.shardingjdbcdemo.entity.Course;
    import com.test.shardingjdbcdemo.entity.Udict;
    import com.test.shardingjdbcdemo.entity.User;
    import com.test.shardingjdbcdemo.mapper.CourseMapper;
    import com.test.shardingjdbcdemo.mapper.UdictMapper;
    import com.test.shardingjdbcdemo.mapper.UserMapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    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;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class ShardingjdbcTests04 { 
    
    
        @Autowired
        private UdictMapper udictMapper;
    
        //======================测试公共表===================
        //添加操作
        @Test
        public void addDict() { 
            Udict udict = new Udict();
            udict.setUstatus("a");
            udict.setUvalue("已启用");
            udictMapper.insert(udict);
        }
    
        //删除操作
        @Test
        public void deleteDict() { 
            QueryWrapper<Udict>  wrapper = new QueryWrapper<>();
            //设置userid值
            wrapper.eq("dictid",543031152684826625L);
            udictMapper.delete(wrapper);
        }
    }

查看插入数据的日志：

![在这里插入图片描述][20201209203827193.png]

向配置文件中所有的数据源的 t\_udict 表中插入数据。

![在这里插入图片描述][20201209203835720.png]

## 5、windows MySQL 主从复制配置 ##

参考： [win10上， MySQL 主从复制配置][win10_ MySQL]

## 6、ShardingJDBC 读写分离 ##

### 6.1、读写分离 ShardingJDBC 配置 ###

# 主从复制配置
    
    # 配置数据源，给数据源起名称,
    # 水平分库，配置两个数据源
    spring.shardingsphere.datasource.names=m0,s0
    
    # 一个实体类对应两张表，覆盖
    spring.main.allow-bean-definition-overriding=true
    
    ### m0 是主服务，s0是从服务
    
    #配置第三个数据源具体内容，包含连接池，驱动，地址，用户名和密码
    # user_db主服务器
    spring.shardingsphere.datasource.m0.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.m0.url=jdbc:mysql://localhost:3306/user_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m0.username=root
    spring.shardingsphere.datasource.m0.password=root
    
    # user_db从服务器
    spring.shardingsphere.datasource.s0.type=com.alibaba.druid.pool.DruidDataSource
    spring.shardingsphere.datasource.s0.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.shardingsphere.datasource.s0.url=jdbc:mysql://localhost:3307/user_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.s0.username=root
    spring.shardingsphere.datasource.s0.password=root
    
    # 指定 t_user 表里面主键 user_id 生成策略  SNOWFLAKE
    spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
    spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
    
    # 主库从库逻辑数据源定义 ds0 为 user_db
    spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-source-name=m0
    spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-source-names=s0
    
    # 配置user_db数据库里面t_user 专库专表
    #spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user
    # t_user分表策略，固定分配至ds0的t_user真实表
    spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds0.t_user
    
    
    # 打开sql输出日志
    spring.shardingsphere.props.sql.show=true

### 6.2、测试代码 ###

**插入操作**

执行插入操作是日志是

Actual SQL: m0 ::: INSERT INTO t_user   (username, ustatus, user_id) VALUES (?, ?, ?) ::: [Lily, a, 543458781976068097]

![在这里插入图片描述][20201209203852645.png]

数据插入到主数据库后，自动同步到从服务中。查询如下：

![在这里插入图片描述][20201209203914621.png]

![在这里插入图片描述][2020120920392384.png]

**查询操作：**

查询时，是到 从服务 s0 中查询的：

![在这里插入图片描述][20201209203932836.png]

## 7、ShardingProxy 配置 和水平分表（表） ##

当前使用的是 `apache-shardingsphere-4.1.1-sharding-proxy-bin.tar.gz`

### 7.1、修改 `server.yaml` 内容 ###

在 conf 目录中，修改 `server.yaml` 内容，删除如下的注释：

authentication:
      users:
        root:
          password: root
        sharding: 
          password: sharding 
          authorizedSchemas: sharding_db
    
    props:
      max.connections.size.per.query: 1
      acceptor.size: 16 # The default value is available processors count * 2.
      executor.size: 16 # Infinite by default.
      proxy.frontend.flush.threshold: 128 # The default value is 128.
        # LOCAL: Proxy will run with LOCAL transaction.
        # XA: Proxy will run with XA transaction.
        # BASE: Proxy will run with B.A.S.E transaction.
      proxy.transaction.type: LOCAL
      proxy.opentracing.enabled: false
      query.with.cipher.column: true
      sql.show: false

### 7.2、修改 `config-sharding.yaml` 内容 ###

schemaName: sharding_db
    
    dataSources:
      ds_0:
        url: jdbc:mysql://127.0.0.1:3306/edu_1?serverTimezone=UTC&useSSL=false
        username: root
        password: root
        connectionTimeoutMilliseconds: 30000
        idleTimeoutMilliseconds: 60000
        maxLifetimeMilliseconds: 1800000
        maxPoolSize: 50
    
    
    shardingRule:
      tables:
        t_order:
          actualDataNodes: ds_${ 0}.t_order_${ 0..1}
          tableStrategy:
            inline:
              shardingColumn: order_id
              algorithmExpression: t_order_${ order_id % 2}
          keyGenerator:
            type: SNOWFLAKE
            column: order_id
            
      bindingTables:
        - t_order
      defaultTableStrategy:
        none:

### 7.3、复制MySQL驱动到 lib 目录下 ###

![在这里插入图片描述][20201210162506319.png]

### 7.4、将后缀统一修改为 `jar` ###

lib 目录下,，有些文件的后缀丢失，将后缀丢失的统一修改为 `.jar` 。

#### 提示 “找不到该项目” 异常解决 ####

如果后缀为 `.` 时，如下图所示：

![在这里插入图片描述][20201210162523431.png]

在添加`jar` 后缀时，会报 “找不到该项目” ，如下图所示：

![在这里插入图片描述][20201210162535350.png]

解决方法是 使用 `Git Bash` （如下图所示） ，在 linux shell 模式下进行修改。  
![在这里插入图片描述][20201210162556912.png]

使用 linux 的 `mv` 命令进行重命名：

mv sharding-orchestration-core-registrycenter-4.1.1.  sharding-orchestration-core-registrycenter-4.1.1.jar

![在这里插入图片描述][2020121016261589.png]

### 7.5、启动 ShardingProxy ###

双击 `lib` 目录下的 `start.bat` 进行启动。

如果出现 端口号是 3307， ACTIVE 等 内容，如下图所示，表示启动成功。  
![在这里插入图片描述][20201210162624988.png]

### 7.6、使用mysql 命令，登录 ShardingProxy 的代理端查看 ###

mysql -P3307 -uroot -p

注意：`P` 是大写。

![在这里插入图片描述][20201210162636348.png]

### 7.7、创建数据库SQL ###

create table t_order(order_id bigint not null ,user_id int not null ,status varchar(20), primary key (order_id) ) ;

![在这里插入图片描述][20201210162648805.png]

在 ShardingProxy 代理库 sharding\_db 中，则出现 t\_order 表。  
![在这里插入图片描述][20201210162701153.png]

在数据库中可以看到 t\_order\_0、t\_order\_1 ，

![在这里插入图片描述][20201210162712974.png]

### 7.8、在 代理库 sharding\_db 中，向 t\_order 表插入数据： ###

insert into t_order(order_id,user_id,status) values(1001,100,'a');
    insert into t_order(order_id,user_id,status) values(1002,100,'a');
    
    insert into t_order(order_id,user_id,status) values(1003,101,'b');
    insert into t_order(order_id,user_id,status) values(1004,101,'b');

查询数据：

select * from t_order where order_id=1001;

![在这里插入图片描述][20201210162730553.png]

## 8、ShardingProxy 水平分库（库） ##

### 8.1、创建水平数据库 ###

数据库 edu\_db\_1、edu\_db\_2

### 8.2、修改 config-sharding.yaml 内容： ###

schemaName: sharding_db
    
    dataSources:
      ds_0:
        url: jdbc:mysql://127.0.0.1:3306/edu_db_1?serverTimezone=UTC&useSSL=false
        username: root
        password: root
        connectionTimeoutMilliseconds: 30000
        idleTimeoutMilliseconds: 60000
        maxLifetimeMilliseconds: 1800000
        maxPoolSize: 50
      ds_1:
        url: jdbc:mysql://127.0.0.1:3306/edu_db_2?serverTimezone=UTC&useSSL=false
        username: root
        password: root
        connectionTimeoutMilliseconds: 30000
        idleTimeoutMilliseconds: 60000
        maxLifetimeMilliseconds: 1800000
        maxPoolSize: 50
    
    shardingRule:
      tables:
        t_order:
          actualDataNodes: ds_${ 0..1}.t_order_${ 1..2}
          tableStrategy:
            inline:
              shardingColumn: order_id
              algorithmExpression: t_order_${ order_id % 2 + 1}
          keyGenerator:
            type: SNOWFLAKE
            column: order_id
        
      bindingTables:
        - t_order
      defaultDatabaseStrategy:
        inline:
          shardingColumn: user_id
          algorithmExpression: ds_${ user_id % 2}
      defaultTableStrategy:
        none:

### 8.3、启动 ShardingProxy ###

先删除 log 日志目录，再双击 `bin` 目录下的 `start.bat` 启动 ShardingProxy 服务。

如果出现 端口号是 3307， ACTIVE 等 内容，表示启动成功，如下图所示 。

![在这里插入图片描述][20201210162746215.png]

### 8.4、进入 ShardingProxy 的代理端查看 ###

mysql -P3307 -uroot -p

注意：`P` 是大写。

![在这里插入图片描述][2020121016275780.png]

### 8.5、创建数据库 ###

create table  t_order (order_id bigint not null ,user_id int not null ,status varchar(20), primary key (order_id) ) ;

在 ShardingProxy 代理库 sharding\_db 中，则出现 t\_order 表， 如下图所示：

![在这里插入图片描述][20201210162823752.png]

在数据库中可以看到 edu\_db\_1、edu\_db\_2 里面分别创建 t\_order\_1、t\_order\_2， 如下图所示：

![在这里插入图片描述][20201210162832452.png]

### 8.6、在 代理库 sharding\_db 中，向 t\_order 表插入数据： ###

insert into t_order(order_id,user_id,status) values(1001,100,'a');
    insert into t_order(order_id,user_id,status) values(1003,101,'b');
    insert into t_order(order_id,user_id,status) values(1002,102,'a');
    insert into t_order(order_id,user_id,status) values(1004,103,'b');

查询数据：

select * from t_order where order_id=1001;

![在这里插入图片描述][20201210162845201.png]

查看 edu\_db\_1、edu\_db\_2 中的数据：

![在这里插入图片描述][2020121016285654.png]

## 9、ShardingProxy 读写分离 ##

### 9.1、windows MySQL 主从复制配置 ###

参考 5、windows MySQL 主从复制配置

### 9.2、配置文件修改 ###

将 config-sharding.yaml 内容注释掉。

修改 config-master\_slave.yaml 内容：

schemaName: master_slave_db
    
    dataSources:
      master_ds:
        url: jdbc:mysql://127.0.0.1:3306/user_db?serverTimezone=UTC&useSSL=false
        username: root
        password: root
        connectionTimeoutMilliseconds: 30000
        idleTimeoutMilliseconds: 60000
        maxLifetimeMilliseconds: 1800000
        maxPoolSize: 50
      slave_ds_0:
        url: jdbc:mysql://127.0.0.1:3407/user_db?serverTimezone=UTC&useSSL=false
        username: root
        password: root
        connectionTimeoutMilliseconds: 30000
        idleTimeoutMilliseconds: 60000
        maxLifetimeMilliseconds: 1800000
        maxPoolSize: 50 
    
    masterSlaveRule:
      name: ms_ds
      masterDataSourceName: master_ds
      slaveDataSourceNames:
        - slave_ds_0

### 9.3、启动 ShardingProxy ###

略

### 9.4 、测试 ###

略

[20201209203619823.png]: /images/20221120/2d3bada27b9644c49347820adb89e3ed.png
[20201209203649322.png]: /images/20221120/04475bb7335d426c8c6e1afb379aced4.png
[20201209203658886.png]: /images/20221120/8f30b3bbeff44b5d8de24ec78ee5d0cf.png
[20201209203710254.png]: /images/20221120/0ad5ec282bd8462a8b798c43048b6703.png
[20201209203718652.png]: /images/20221120/1f50fe07f09a465ea636880b7d88af0f.png
[20201209203727823.png]: /images/20221120/f031e121ca2449e4ba0349ca89526705.png
[20201209203736622.png]: /images/20221120/2537404238f64a42bf41eff0c220099c.png
[20201209203751501.png]: /images/20221120/496c5088265242409121cc0ca135f3a5.png
[20201209203802849.png]: /images/20221120/d62a58a4758342d7b07d4112511f094e.png
[20201209203811364.png]: /images/20221120/b96c57689b7d41afaf3023aa55e46ec6.png
[20201209203827193.png]: /images/20221120/0074cf9dafd2446594f5aa2781d54362.png
[20201209203835720.png]: /images/20221120/866ae39ac01e4262bfa5bed45905ef14.png
[win10_ MySQL]: https://xiaojin21cen.blog.csdn.net/article/details/110939968
[20201209203852645.png]: /images/20221120/dd44575f76e9450fa3acbd599194fdfe.png
[20201209203914621.png]: /images/20221120/16c19b12ddcd46a1b51fd4e3d3dbc77b.png
[2020120920392384.png]: /images/20221120/99e62e2d693f47deb3a2e22683f8572b.png
[20201209203932836.png]: /images/20221120/99fd653bea944b52952f3f6f1a1a6a79.png
[20201210162506319.png]: /images/20221120/5c4b701b99ab4353b6a7f5f94ab21dd8.png
[20201210162523431.png]: /images/20221120/09d23b3845dd438f836dea13a2cd0b4b.png
[20201210162535350.png]: /images/20221120/53a426e65901411f8a375e06f06e7304.png
[20201210162556912.png]: /images/20221120/a2b3b8be80894f7ab2d90969f43af07b.png
[2020121016261589.png]: /images/20221120/6c0ae580f6b34bc080baedf5594a9136.png
[20201210162624988.png]: /images/20221120/72a07cde752b478f8e147f0744a3a707.png
[20201210162636348.png]: /images/20221120/618e769e9f114e0ab93382a0b7abfba6.png
[20201210162648805.png]: /images/20221120/4cc9c5be906f40b18b6b553362521f67.png
[20201210162701153.png]: /images/20221120/45216d1d896b4c61b543561f8a015568.png
[20201210162712974.png]: /images/20221120/8041a11b9e4c4d6bbcc8f8531cce1c9f.png
[20201210162730553.png]: /images/20221120/71de83c19e6b48348d7ff75ca920a8c7.png
[20201210162746215.png]: /images/20221120/e5b1ad18c9ad4391a4559d33b13fb723.png
[2020121016275780.png]: /images/20221120/0c00b91fea484838bca6aa89ee28534d.png
[20201210162823752.png]: /images/20221120/45478d2fd0244d16b809ed33be435340.png
[20201210162832452.png]: /images/20221120/ccdbc830bb1d41d4ab0270a9f2cb1c5c.png
[20201210162845201.png]: /images/20221120/de3b070498f04d62ac072075afd687e1.png
[2020121016285654.png]: /images/20221120/fb93b2bd0d9948498bbfd8250c4a8ae0.png