sharding‐jdbc之分库分表（mysql主从同步的数据库安装和使用）

news2024/11/19 14:28:00

水平分表

创建基础工程..

引入sharding‐jdbc的maven依赖包  注意需要数据库连接池等依赖

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

表结构

-- 创建库
CREATE DATABASE `order_db` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

-- 创建表1
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE `t_order_1` (
  `order_id` bigint(20) NOT NULL COMMENT '订单id',
  `price` decimal(10,2) NOT NULL COMMENT '订单价格',
  `user_id` bigint(20) NOT NULL COMMENT '下单用户id',
  `status` varchar(50) NOT NULL COMMENT '订单状态',
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;
-- 创建表2
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE `t_order_2` (
  `order_id` bigint(20) NOT NULL COMMENT '订单id',
  `price` decimal(10,2) NOT NULL COMMENT '订单价格',
  `user_id` bigint(20) NOT NULL COMMENT '下单用户id',
  `status` varchar(50) NOT NULL COMMENT '订单状态',
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC;

配置文件

server.port=56081

spring.application.name = sharding-jdbc-simple-demo

server.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = UTF-8
spring.http.encoding.force = true

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

mybatis.configuration.map-underscore-to-camel-case = true

#sharding-jdbc分片规则配置
#数据源
spring.shardingsphere.datasource.names = m1
# 指定数据源 m1 对应的数据库信息
spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db?useUnicode=true
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = root

# 指定 t_order 表的数据分布情况，t_order是表的前缀， 配置数据节点 m1.t_order_1 => t_order_1 ,m1.t_order_2 => t_order_2
#  分多少表  分片键 就到多少$->{1..10}
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m1.t_order_$->{1..3}

# 指定t_order表的主键生成策略为 雪花算法 SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE

# 指定t_order表的分片策略，分片策略包括分片键和分片算法；
# order_id：主键。计算表的后缀 ：order_id_?;   $->{order_id % 2 + 1} = 偶数0 + 1 = 1 即 order_id_1 ；  $->{order_id % 2 + 1} = 奇数 1 + 1 = 2 即 order_id_2
#   分 几 个表  分片键就除以几  {order_id % 10 + 1}
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column = order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression = t_order_$->{order_id % 3 + 1}

# 打开sql输出日志
spring.shardingsphere.props.sql.show = true

swagger.enable = true

logging.level.root = info
logging.level.org.springframework.web = info
logging.level.com.itheima.dbsharding  = debug
logging.level.druid.sql = debug

 编写插入语句

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

/**
 * Created by Administrator.
 */
@Mapper
@Component
public interface OrderDao {

    /**
     * 插入订单
     * @param price
     * @param userId
     * @param status
     * @return
     */
    @Insert("insert into t_order(price,user_id,status)values(#{price},#{userId},#{status})")
    int insertOrder(@Param("price")BigDecimal price,@Param("userId")Long userId,@Param("status")String status);

    /**
     * 根据id列表查询订单
     * @param orderIds
     * @return
     */
    @Select("<script>" +
            "select" +
            " * " +
            " from t_order t " +
            " where t.order_id in " +
            " <foreach collection='orderIds' open='(' separator=',' close=')' item='id'>" +
            " #{id} " +
            " </foreach>" +
            "</script>")
    List<Map> selectOrderbyIds(@Param("orderIds") List<Long> orderIds);
}

单元测试

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;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @author Administrator
 * @version 1.0
 **/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ShardingJdbcSimpleBootstrap.class})
public class OrderDaoTest {

    @Autowired
    OrderDao orderDao;

    @Test
    public void testInsertOrder(){
        for(int i=1;i<20;i++){
            orderDao.insertOrder(new BigDecimal(i),1L,"SUCCESS");
        }
    }

//    @Test
    public void testSelectOrderbyIds(){
        List<Long> ids = new ArrayList<>();
        ids.add(373897739357913088L);
        ids.add(373897037306920961L);

        List<Map> maps = orderDao.selectOrderbyIds(ids);
        System.out.println(maps);
    }
}

数据库 表1 插入数据

表2

流程分析

通过日志分析，Sharding-JDBC在拿到用户要执行的sql之后干了哪些事儿：
（1）解析sql，获取片键值，在本例中是order_id
（2）Sharding-JDBC通过规则配置 t_order_$->{order_id % 2 + 1}，知道了当order_id为偶数时，应该往t_order_1表插数据，为奇数时，往t_order_2插数据。
（3）于是Sharding-JDBC根据order_id的值改写sql语句，改写后的SQL语句是真实所要执行的SQL语句。
（4）执行改写后的真实sql语句
（5）将所有真正执行sql的结果进行汇总合并，返回。
 

分片策略

      包含分片键和分片算法，由于分片算法的独立性，将其独立抽离。真正可用于分片操作的是分片键 + 分片算法，也就是分片策略。内置的分片策略大致可分为尾数取模、哈希、范围、标签、时间等。由用户方配置的分片策略则更加灵活，常用的使用行表达式配置分片策略，它采用Groovy表达式表示，如: t_user_$->{u_id % 8} 表示t_user表根据u_id模8，而分成8张表，表名称为 t_user_0 到 t_user_7 。

SQL解析

    当Sharding-JDBC接受到一条SQL语句时，会陆续执行 SQL解析 => 查询优化 => SQL路由 => SQL改写 => SQL执行 =>结果归并 ，最终返回执行结果。

SQL解析过程分为词法解析和语法解析。 词法解析器用于将SQL拆解为不可再分的原子符号，称为Token。并根据不同数据库方言所提供的字典，将其归类为关键字，表达式，字面量和操作符。 再使用语法解析器将SQL转换为抽象语法树。
 

例如

SELECT id, name FROM t_user WHERE status = 'ACTIVE' AND age > 18

解析之后的为抽象语法树见下图：
 

SQL路由

SQL路由就是把针对逻辑表的数据操作映射到对数据结点操作的过程。
根据解析上下文匹配数据库和表的分片策略，并生成路由路径。 对于携带分片键的SQL，根据分片键操作符不同可以划分为单片路由(分片键的操作符是等号)、多片路由(分片键的操作符是IN)和范围路由(分片键的操作符是BETWEEN)，不携带分片键的SQL则采用广播路由。根据分片键进行路由的场景可分为直接路由、标准路由、笛卡尔路由等

标准路由
笛卡尔路由
全库表路由


SQL改写

   工程师面向逻辑表书写的SQL，并不能够直接在真实的数据库中执行，SQL改写用于将逻辑SQL改写为在真实数据库中可以正确执行的SQL

如一个简单的例子，若逻辑SQL为：

SELECT order_id FROM t_order WHERE order_id=1;

假设该SQL配置分片键order_id，并且order_id=1的情况，将路由至分片表1。那么改写之后的SQL应该为：

SELECT order_id FROM t_order_1 WHERE order_id=1;

SQL执行

      Sharding-JDBC采用一套自动化的执行引擎，负责将路由和改写完成之后的真实SQL安全且高效发送到底层数据源执行。 它不是简单地将SQL通过JDBC直接发送至数据源执行；也并非直接将执行请求放入线程池去并发执行。它更关注平衡数据源连接创建以及内存占用所产生的消耗，以及最大限度地合理利用并发等问题。 执行引擎的目标是自动化的平衡资源控制与执行效率，他能在以下两种模式自适应切换：

内存限制模式
    使用此模式的前提是，Sharding-JDBC对一次操作所耗费的数据库连接数量不做限制。 如果实际执行的SQL需要对某数据库实例中的200张表做操作，则对每张表创建一个新的数据库连接，并通过多线程的方式并发处理，以达成执行效率最大化。
连接限制模式
    使用此模式的前提是，Sharding-JDBC严格控制对一次操作所耗费的数据库连接数量。 如果实际执行的SQL需要对某数据库实例中的200张表做操作，那么只会创建唯一的数据库连接，并对其200张表串行处理。 如果一次操作中的分片散落在不同的数据库，仍然采用多线程处理对不同库的操作，但每个库的每次操作仍然只创建一个唯一的数据库连接。


内存限制模式适用于OLAP操作，可以通过放宽对数据库连接的限制提升系统吞吐量； 连接限制模式适用于OLTP操作，OLTP通常带有分片键，会路由到单一的分片，因此严格控制数据库连接，以保证在线系统数据库资源能够被更多的应用所使用，是明智的选择。
 

结果归并

将从各个数据节点获取的多数据结果集，组合成为一个结果集并正确的返回至请求客户端，称为结果归并。Sharding-JDBC支持的结果归并从功能上可分为遍历、排序、分组、分页和聚合5种类型，它们是组合而非互斥的关系。

归并引擎的整体结构划分如下图

结果归并从结构划分可分为流式归并、内存归并和装饰者归并。流式归并和内存归并是互斥的，装饰者归并可以在流式归并和内存归并之上做进一步的处理。

内存归并
    他是将所有分片结果集的数据都遍历并存储在内存中，再通过统一的分组、排序以及聚合等计算之后，再将其封装成为逐条访问的数据结果集返回。
流式归并
    是指每一次从数据库结果集中获取到的数据，都能够通过游标逐条获取的方式返回正确的单条数据，它与数据库原生的返回结果集的方式最为契合
装饰者归并
    是对所有的结果集归并进行统一的功能增强，比如归并时需要聚合SUM前，在进行聚合计算前，都会通过内存归并或流式归并查询出结果集。因此，聚合归并是在之前介绍的归并类型之上追加的归并能力，即装饰者模式。

1、每个表先排序
2、从第一个表里面找到最大的，和后边的比较，找到最大值100
3、然后拿第一表的第二大值90去和99、95比较大小， 找到第二大值 99
4、然后拿第二个表的第二大值89和95比较，找到第三大值 95
依次类推.....，一个一个的去比对，就像一个游标

分库

配置文件

server.port=56081

spring.application.name = sharding-jdbc-simple-demo

server.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = UTF-8
spring.http.encoding.force = true

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

mybatis.configuration.map-underscore-to-camel-case = true

#sharding-jdbc分片规则配置
#数据源
spring.shardingsphere.datasource.names = m1,m2

spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver‐class‐name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true
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.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = root


# 分库策略，以user_id为分片键，分片策略为user_id % 2 + 1，user_id为偶数操作m1数据源，否则操作m2。
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression =m$->{user_id % 2 + 1 }

# 计算表（共多少表）
# 指定 t_order 表的数据分布情况，t_order是表的前缀， 配置数据节点 m1.t_order_1,m1.t_order_2,,m1.t_order_3, m2.t_order_1,m2.t_order_2,m2.t_order_3
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m$->{1..2}.t_order_$->{1..3}
#分库策略，如何将一个逻辑表映射到多个数据源
spring.shardingsphere.sharding.tables.<逻辑表名称>.database-strategy.<分片策略>.<分片策略属性名>= #分片策略属性值
#分表策略，如何将一个逻辑表映射为多个实际表
spring.shardingsphere.sharding.tables.<逻辑表名称>.table-strategy.<分片策略>.<分片策略属性名>= #分片策略属性值
# 指定t_order表的主键 order_id 生成策略为 雪花算法 SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE

# 计算数据落到哪个表里面
# 指定t_order表的分片策略，分片策略包括分片键:order_id 和 分片算法: t_order_$->{order_id % 3 + 1}
# order_id：主键。计算表的后缀 ：order_id_?;   $->{order_id % 2 + 1} = 偶数0 + 1 = 1 即 order_id_1；$->{order_id % 2 + 1}=奇数 1+1=2 即 order_id_2；分几个表 分片键就除以几  {order_id % 10 + 1}
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column = order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression = t_order_$->{order_id % 3 + 1}


# 打开sql输出日志
spring.shardingsphere.props.sql.show = true

swagger.enable = true

logging.level.root = info
logging.level.org.springframework.web = info
logging.level.com.itheima.dbsharding  = debug
logging.level.druid.sql = debugc

 插入数据

/**
 * 插入订单
 * @param price
 * @param userId
 * @param status
 * @return
 */
@Insert("insert into t_order(price,user_id,status)values(#{price},#{userId},#{status})")
int insertOrder(@Param("price")BigDecimal price,@Param("userId")Long userId,@Param("status")String status);

测试插入

@Test
public void testInsertOrder(){
    for(int i=1;i<=20;i++){
        orderDao.insertOrder(new BigDecimal(i),1L,"SUCCESS");
    }
}

插入数据

测试查询

@Test
public void testSelectOrderbyUserAndIds(){
    List<Long> ids = new ArrayList<>();
    ids.add(982641951578783745L);
    ids.add(982641951578783746L);
    ids.add(982641951247433729L);
    List<Map> maps = orderDao.selectOrderbyUserAndIds(2L,ids);
    System.out.println(maps);
}
 @Test
    public void testSelectOrderbyIds(){
        List<Long> ids = new ArrayList<>();
        ids.add(982641951578783745L);
        ids.add(982641951578783746L);
        ids.add(982641951247433729L);
        List<Map> maps = orderDao.selectOrderbyIds(ids);
        System.out.println(maps);
    }

dao层

/**
 * 根据id列表查询订单
 * @param orderIds
 * @return
 */
@Select("<script>" +
        "select" +
        " * " +
        " from t_order t " +
        " where t.order_id in " +
        " <foreach collection='orderIds' open='(' separator=',' close=')' item='id'>" +
        " #{id} " +
        " </foreach>" +
        "</script>")
List<Map> selectOrderbyIds(@Param("orderIds") List<Long> orderIds);

/**
 * 根据id列表和用户id查询订单
 * @param orderIds
 * @return
 */
@Select("<script>" +
        "select" +
        " * " +
        " from t_order t " +
        " where t.order_id in " +
        " <foreach collection='orderIds' open='(' separator=',' close=')' item='id'>" +
        " #{id} " +
        " </foreach>" +
        " and user_id = #{userId} " +
        "</script>")
List<Map> selectOrderbyUserAndIds(@Param("userId") Long userId,@Param("orderIds") List<Long> orderIds);

Sharding-JDBC支持以下几种分片策略：

不管理分库还是分表，策略基本一样。
    standard：标准分片策略，
        对应StandardShardingStrategy。提供对SQL语句中的=, IN和BETWEEN AND的分片操作支持。StandardShardingStrategy只支持单分片键，提供PreciseShardingAlgorithm和RangeShardingAlgorithm两个分片算法。PreciseShardingAlgorithm是必选的，用于处理=和IN的分片。RangeShardingAlgorithm是可选的，用于处理BETWEEN AND分片，如果不配置RangeShardingAlgorithm，SQL中的BETWEEN AND将按照全库路由处理。
    complex：符合分片策略
        对应ComplexShardingStrategy。复合分片策略。提供对SQL语句中的=, IN和BETWEEN AND的分片操作支持。ComplexShardingStrategy支持多分片键，由于多分片键之间的关系复杂，因此并未进行过多的封装，而是直接将分片键值组合以及分片操作符透传至分片算法，完全由应用开发者实现，提供最大的灵活度。
    inline：行表达式分片策略
        对应InlineShardingStrategy。使用Groovy的表达式，提供对SQL语句中的=和IN的分片操作支持，只支持单分片键。对于简单的分片算法，可以通过简单的配置使用，从而避免繁琐的Java代码开发，如: t_user_$->{u_id % 8} 表示t_user表根据u_id模8，而分成8张表，表名称为 t_user_0 到t_user_7 。
    hint：Hint分片策
        对应HintShardingStrategy。通过Hint而非SQL解析的方式分片的策略。对于分片字段非SQL决定，而由其他外置条件决定的场景，可使用SQL Hint灵活的注入分片字段。例：内部系统，按照员工登录主键分库，而数据库中并无此字段。SQL Hint支持通过Java API和SQL注释(待实现)两种方式使用。
    none：不分片策略
        对应NoneShardingStrategy。不分片的策略。
 

公共表

     公共表属于系统中数据量较小，变动少，而且属于高频联合查询的依赖表。参数表、数据字典表等属于此类型。可以将这类表在每个数据库都保存一份，所有更新操作都同时发送到所有分库执行。接下来看一下如何使用Sharding-JDBC实现公共表。
 

(1)创建数据库
分别在user_db、order_db_1、order_db_2中创建t_dict表：

CREATE TABLE `t_dict` (
    `dict_id` BIGINT ( 20 ) NOT NULL COMMENT '字典id',
    `type` VARCHAR ( 50 ) CHARACTER 
    SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '字典类型',
    `code` VARCHAR ( 50 ) CHARACTER 
    SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '字典编码',
    `value` VARCHAR ( 50 ) CHARACTER 
    SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '字典值',
    PRIMARY KEY ( `dict_id` ) USING BTREE 
) ENGINE = INNODB CHARACTER 
SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

配置文件

# 指定t_dict为公共表
spring.shardingsphere.sharding.broadcast‐tables=t_dict

添加字典

/**
 * 新增字典
 * @param type 字典类型
 * @param code 字典编码
 * @param value 字典值
 * @return
 */
@Insert("insert into t_dict(dict_id,type,code,value) value(#{dictId},#{type},#{code},#{value})")
int insertDict(@Param("dictId") Long dictId, @Param("type") String type, @Param("code")String code, @Param("value")String value);
                        

测试

@Test
public void testInsertDict(){
    dictDao.insertDict(3L,"user_type","2","超级管理员");
    dictDao.insertDict(4L,"user_type","3","二级管理员");
}

删除

@Test
public void testDeleteDict(){
    dictDao.deleteDict(3L);
    dictDao.deleteDict(4L);
}

/**
 * 删除字典
 * @param dictId 字典id
 * @return
 */
@Delete("delete from t_dict where dict_id = #{dictId}")
int deleteDict(@Param("dictId") Long dictId);

 表数据都删除了

关联查询

@Test
public void testSelectUserInfobyIds(){
    List<Long> userIds = new ArrayList<>();
    userIds.add(1L);
    userIds.add(2L);
    List<Map> users = userDao.selectUserInfobyIds(userIds);
    System.out.println(users);
}
/**
 * 根据id列表查询多个用户   用户和字典关联
 * @param userIds 用户id列表
 * @return
 */
@Select({"<script>",
        " select",
        " * ",
        " from t_user t ,t_dict b",
        " where t.user_type = b.code and t.user_id in",
        "<foreach collection='userIds' item='id' open='(' separator=',' close=')'>",
        "#{id}",
        "</foreach>",
        "</script>"
})
List<Map> selectUserInfobyIds(@Param("userIds") List<Long> userIds);

主从复制数据库安装

刚开始只有一个

一、复制一份之前安装的安装目录，并修改名称为 mysql-5.7.20-winx64-s1

修改配置文件  my.ini

修改端口号和目录 

然后使用安装脚本

管理员运行cmd（可能不行）

mysqld install mysqls1 --defaults-file="D:\RuanJianKaiFa\mysql\mysql-5.7.20-winx64-s1\my.ini" 

二、或者使用安装脚本命令

D: 
cd D:\RuanJianKaiFa\mysql\mysql-5.7.20-winx64-s1\bin
mysqld --initialize-insecure --user=mysqls1
mysqld -install
net start mysql
mysql -u root -p

  修改密码脚本命令


D:
cd D:\RuanJianKaiFa\mysql\mysql-5.7.20-winx64-s1\bin
mysqladmin -uroot -p password 

安装成功

主库配置

# 主从同步配置
#主库开启日志
log-bin = mysql-bin
#设置服务id，主从不能一致
server-id = 1
#设置需要同步的数据库
binlog-do-db=user_db
#屏蔽系统库同步
binlog-ignore-db=mysql
binlog-ignore-db=information_schema
binlog-ignore-db=performance_schema

从库配置

#开启日志 从库配置
log-bin = mysql-bin
#设置服务id，主从不能一致
server-id = 2
#设置需要同步的数据库
replicate_wild_do_table=user_db.%
#屏蔽系统库同步
replicate_wild_ignore_table=mysql.%
replicate_wild_ignore_table=information_schema.%
replicate_wild_ignore_table=performance_schema.%

主库和从库都重启服务

连接从库

三，授权主从复制专用账号

主库操作

主库的用户

执行创建用户的命令   连接主库后执行

-- 授权主备复制专用账号
GRANT REPLICATION SLAVE ON *.* TO 'db_sync' @'%' IDENTIFIED BY 'db_sync';

-- 刷新权限
FLUSH PRIVILEGES;

主库创建用户成功

 确认位点 记录下文件名以及位点

-- 确认位点 记录下文件名以及位点
show master status;

从库操作

-- 先停止同步
STOP SLAVE;

修改从库指向到主库，使用上一步记录的文件名以及位点

#修改从库指向到主库，使用上一步记录的文件名以及位点
CHANGE MASTER TO
master_host = 'localhost',
master_user = 'db_sync',
master_password = 'db_sync',
master_log_file = 'mysql-bin.000001',
master_log_pos = 154;

执行成功

启动同步

START SLAVE;

 -- 查看从库状态Slave_IO_Runing和Slave_SQL_Runing都为Yes说明同步成功，如果不为Yes，请检查error_log，然后排查相关异常。

show slave status

都是yes才行

请注意，主从MySQL下的数据(data)目录下有个文件auto.cnf，文件中定义了uuid，要保证主从数据库实例的uuid不一样，建议直接删除掉，重启服务后将会重新生成。
 

从库目录找到auto.cnf，由于是从库是复制的主库，这里文件是一样的，里面有一个uuid

将这个文件删除后重启服务，会从新生成此文件

 重新生成文件

再次查看 都是yes 了

测试 是否同步成功

添加主库数据，去从库数据，看从库数据是否修改

同步成功

注意 注意 注意

配置的数据库和要同步的库要一样

实现sharding-jdbc读写分离

配置文件

spring.shardingsphere.datasource.names = m0,m1,m2,s0

spring.shardingsphere.datasource.s0.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.s0.driver‐class‐name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.s0.url = jdbc:mysql://localhost:3307/user_db?useUnicode=true
spring.shardingsphere.datasource.s0.username = root
spring.shardingsphere.datasource.s0.password = root
 

 主库从库逻辑数据源定义

#主库
spring.shardingsphere.sharding.master‐slave‐rules.ds0.master-data-source-name=m0
#从库
spring.shardingsphere.sharding.master‐slave‐rules.ds0.slave-data-source-names=s0

t_user分表策略，固定分配至ds0的t_user真实表

# t_user分表策略，固定分配至ds0的t_user真实表
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes = ds0.t_user

测试查询 走的s0库（从库）

    @Test
    public void testSelectUserbyIds(){
        List<Long> userIds = new ArrayList<>();
        userIds.add(1L);
//        userIds.add(2L);
        List<Map> users = userDao.selectUserbyIds(userIds);
        System.out.println(users);
    }
/**
 * 根据id列表查询多个用户
 * @param userIds 用户id列表
 * @return
 */
@Select({"<script>",
        " select",
        " * ",
        " from t_user t ",
        " where t.user_id in",
        "<foreach collection='userIds' item='id' open='(' separator=',' close=')'>",
        "#{id}",
        "</foreach>",
        "</script>"
})
List<Map> selectUserbyIds(@Param("userIds") List<Long> userIds);

测试添加 走的m0库（主库）

@Test
public void testInsertUser(){
    for (int i = 2 ; i<3; i++){
        Long id = i + 1L;
        userDao.insertUser(id,"姓名"+ id );
    }
}
/**
 * 新增用户
 * @param userId 用户id
 * @param fullname 用户姓名
 * @return
 */
@Insert("insert into t_user(user_id, fullname) value(#{userId},#{fullname})")
int insertUser(@Param("userId")Long userId, @Param("fullname")String fullname);

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1570605.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【pycharm】在debug循环时，如何快速debug到指定循环次数

【pycharm】在debug循环时，如何快速debug到指定循环次数

【pycharm】在debug循环时&#xff0c;如何快速debug到指定循环次数 【先赞后看养成习惯】求关注收藏点赞&#x1f600; 在 PyCharm 中&#xff0c;可以使用条件断点来实现在特定循环次数后停止调试。这可以通过在断点处右键单击&#xff0c;然后选择 “Add Breakpoint” -&g…
阅读更多...
ES6学习（五）-- Module 语法

ES6学习（五）-- Module 语法

文章目录 Module 语法1.1 痛点介绍(1) 异步加载(2) 私密(3) 重名(4) 依赖 1.2 解决方法(1) 解决异步加载问题(2) 解决私密问题(3) 重名解决方法(4) 解决依赖问题 1.3 模块化使用案例 Module 语法 之前js 出现的某些痛点&#xff1a; 在script 中引入的变量名不可以重复&#…
阅读更多...
位运算-191. 位1的个数- 136. 只出现一次的数字

位运算-191. 位1的个数- 136. 只出现一次的数字

位1的个数 已解答 简单 相关标签 相关企业 编写一个函数&#xff0c;输入是一个无符号整数&#xff08;以二进制串的形式&#xff09;&#xff0c;返回其二进制表达式中 设置位 的个数&#xff08;也被称为汉明重量&#xff09;。 示例 1&#xff1a; 输入&#xff1a;n 11 输…
阅读更多...
gpt4.0获取方法

gpt4.0获取方法

今天我们想要进行的一项尝试就是—— 如何从一个不知道内容的数据文件中&#xff0c;一键生成一篇像模像样的经济学"论文”。 在开始之前&#xff0c;我们要准备好必要的AI利器&#xff1a; GPT3.5镜像站&#xff08;简单问题极快回答&#xff09;&#xff1a; https:/…
阅读更多...
python写文件怎么读出来

python写文件怎么读出来

python中对文件的操作大概分为三步&#xff1a;打开文件、操作文件&#xff08;读、写、追加写入&#xff09;、关闭文件。 1、无论对文件做哪种操作&#xff0c;操作前首先要保证文件被打开了&#xff0c;即需要一个打开的操作。 例&#xff1a;open(XXX.txt) 打开文件的同…
阅读更多...
ARP 攻击神器：Macof 保姆级教程

ARP 攻击神器：Macof 保姆级教程

一、介绍 macof 是一个用于生成伪造数据流的网络工具&#xff0c;常用于进行网络攻击和测试。它的主要作用是生成大量的伪造 MAC 地址的数据包&#xff0c;并将这些数据包发送到网络中&#xff0c;从而混淆网络设备的 MAC 地址表&#xff0c;导致网络拥堵或服务中断。 以下是…
阅读更多...
C++数据结构——顺序表

C++数据结构——顺序表

C数据结构——顺序表 以下代码可以作为一个顺序表的模板&#xff0c;从顺序表的初始化创建到增删改查&#xff0c;都有详细的过程&#xff0c;供学习参考。 #include<iostream> #include<stdio.h>using namespace std;#define elemType intstruct SequentialList…
阅读更多...
关联规则(理论及实例)

关联规则(理论及实例)

目录 一、啤酒和尿布的故事 二、理论 三、实例 1. 自定义数据集 2. 数据需转换成one-hot编码 3.电影题材关联分析 一、啤酒和尿布的故事 在美国&#xff0c;一些年轻的父亲下班后经常要到超市去购买婴儿尿布&#xff0c;超市因此发现一个规律&#xff0c;在购买婴儿尿布的…
阅读更多...
scala实现通过Spark统计人均登录次数最终写入MySQL

scala实现通过Spark统计人均登录次数最终写入MySQL

谨以此博客作为记录 小编这里用的版本是&#xff1a; <hadoop.version>2.7.7</hadoop.version> <spark.version>2.4.5</spark.version> <scala.version>2.12.10</scala.version> 如果没用到Hadoop可以忽略 步骤 准备数据&#xff0c;知道…
阅读更多...
信息系统项目管理师——第18章项目绩效域管理（二）

信息系统项目管理师——第18章项目绩效域管理（二）

项目工作绩效域 预期目标 高效且有数的项目绩效 2.适合项目和环境的项目过程 3.干系人适当的沟通和参与 4.对实物资源进行了有效管理 5.对采购进行了有效管理 6.有效处理了变更 7.通过持续学习和过程改进提高了团队能力 绩效要点 1.项目过程 2.项目制约因素 3.专注于工作过…
阅读更多...
[调度算法]

[调度算法]

目录 一. 先到先服务(FCFS)二. 短作业优先(SJF)三. 高响应比优先(HRRN)四. 时间片轮转调度算法(RR)五. 优先级调度算法六. 多级反馈队列调度算法七. 多级队列调度算法 \quad 一. 先到先服务(FCFS) \quad 比如你要买一杯奶茶, 在你前面的要买20杯奶茶, 那么你就要等很久 \quad …
阅读更多...
pwn学习笔记（7）--堆相关源码

pwn学习笔记（7）--堆相关源码

相关源码&#xff1a; 1. chunk 相关源码&#xff1a; ​ 对于用户来说&#xff0c;只需要确保malloc()函数返回的内存不会发生溢出&#xff0c;并且在不用的时候使用free() 函数将其释放&#xff0c;以后也不再做任何操作即可。而对于glibc来说’它要在用户第一次调用malloc…
阅读更多...
【QT+QGIS跨平台编译】056：【pdal-dimbuilder+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

【QT+QGIS跨平台编译】056：【pdal-dimbuilder+Qt跨平台编译】（一套代码、一套框架，跨平台编译）

点击查看专栏目录 文章目录 一、pdal介绍二、dimbuilder介绍三、pdal下载四、文件分析五、pro文件六、编译实践七、生成Dimension.hpp八、生成pdal_features.hpp一、pdal介绍 PDAL（Point Data Abstraction Library）是一个开源库，用于处理点云数据的获取、过滤、转换、分析和…
阅读更多...
【opencv】示例 3calibration.cpp 利用OpenCV库进行三路相机校准

【opencv】示例 3calibration.cpp 利用OpenCV库进行三路相机校准

此代码是一个利用OpenCV库进行三路相机校准的C程序。这个示例程序主要用于校准水平摆放的三台相机。 以下是关键函数及其功能的简要总结&#xff1a; help(char** argv): 显示程序的使用方法。calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>&…
阅读更多...
设计模式 --5观察者模式

设计模式 --5观察者模式

观察者模式 观察者模式的优缺点 优点 当一个对象改变的时候 需要同时改变其他对象的相关动作的时候 &#xff0c;而且它不知道有多少具体的对象需要改变 应该考虑使用观察者模式 。观察者模式的工作就是解除耦合 让耦合双方都依赖与抽象 而不是具体 是的各自改变都不会影响另…
阅读更多...
07-app端文章搜索

07-app端文章搜索

app端文章搜索 1) 今日内容介绍 1.1)App端搜索-效果图 1.2)今日内容 文章搜索 ElasticSearch环境搭建 索引库创建 文章搜索多条件复合查询 索引数据同步 搜索历史记录 Mongodb环境搭建 异步保存搜索历史 查看搜索历史列表 删除搜索历史 联想词查询 联想词的来源 联…
阅读更多...
51单片机使用uart串口和助手简单调试

51单片机使用uart串口和助手简单调试

基础知识 参考 特殊功能寄存器PCON&#xff08;控制波特率是否加倍SMOD&#xff09;、TMOD&#xff08;T0,T1计时器的功能方式&#xff09;、TCON&#xff08;T0,T1计时器的控制&#xff09;、串口中断、SCON&#xff08;串口数据控制寄存器&#xff09; 关闭定时器1中断&…
阅读更多...
Cisco交换机安全配置

Cisco交换机安全配置

Cisco交换机安全配置 前提 我们以下命令一般都要先进入Config模式 S1> enable S1# conf t S1(config)#端口安全保护 禁用未使用的端口 以关闭fa0/1到fa0/24的端口为例 S1(config)# interface range fa0/1-24 S1(config-if-range)# shutdown缓解MAC地址表攻击 防止CAM…
阅读更多...
快递费用一目了然：taobao.item_fee API在电商中的应用

快递费用一目了然：taobao.item_fee API在电商中的应用

taobao.item_fee API在电商中的应用主要体现在精准计算快递费用&#xff0c;从而为用户提供一个更加透明和便捷的购物体验。这一接口允许淘宝或天猫的开发者根据商品ID、收货地址等信息&#xff0c;精确计算商品的快递费用。对于用户而言&#xff0c;这意味着在购物过程中能够实…
阅读更多...
【考研数学】如何做题，做什么题，才能打好基础？

【考研数学】如何做题，做什么题，才能打好基础？

还是建议做经验贴推荐的练习册去巩固基础&#xff01;毕竟目的是考研&#xff0c;考研习题册出的题目更加有针对性&#xff0c;如果拿课后习题练手的话还是差一些强度的&#xff01; 看到网上说1800适合零基础&#xff0c;兴致勃勃下单&#xff0c;买回来发现自己练零基础的题…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023