精华内容
下载资源
问答
  • shardingsphere分库分表
    千次阅读 多人点赞
    2021-09-19 10:54:20

    🍅 作者简介:哪吒,CSDN2021博客之星亚军🏆、新星计划导师✌、博客专家💪 

    🍅 哪吒多年工作总结:Java学习路线总结,搬砖工逆袭Java架构师

    🍅 关注公众号【哪吒编程】,回复1024,获取Java学习路线思维导图、大厂面试真题、加入万粉计划交流群、一起学习进步

    目录

    一、分库分表

    二、分库分表的方式

    1、垂直

    更多相关内容
  • Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈,它由 JDBC、Proxy 和 Sidecar(规划中)这 3 款相互独立,却又能够混合部署配合使用的产品组成。 它们均提供标准化的数据片、分布式...
  • ShardingSphere分库分表

    2022-06-19 10:32:26
    ShardingSphere是一款起源于...并逐渐由原本只关注于关系型数据库增强工具的ShardingJDBC升级成为一整套以数据片为基础的数据生态圈,更名为ShardingSphere。到2020年4月,已经成为了Apache软件基金会的顶级项目。...

    ShardingSphere是一款起源于当当网内部的应用框架。2015年在当当网内部诞生,最初就叫ShardingJDBC。2016年的时候,由其中一个主要的开发人员张亮,带入到京东数科,组件团队继续开发。在国内历经了当当网、电信翼支付、京东数科等多家大型互联网企业的考验,在2017年开始开源。并逐渐由原本只关注于关系型数据库增强工具的ShardingJDBC升级成为一整套以数据分片为基础的数据生态圈,更名为ShardingSphere。到2020年4月,已经成为了Apache软件基金会的顶级项目。

    ShardingSphere包含三个重要的产品,ShardingJDBC、ShardingProxy和ShardingSidecar。其中sidecar是针对service mesh定位的一个分库分表插件,目前在规划中。而我们今天学习的重点是ShardingSphere的JDBC 。

    ​其中,ShardingJDBC是用来做客户端分库分表的产品,而ShardingProxy是用来做服务端分库分表的产品。

    ShardingJDBC只是客户端的一个工具包,可以理解为一个特殊的JDBC驱动包,所有分库分表逻辑均由业务方自己控制,所以他的功能相对灵活,支持的数据库也非常多,但是对业务侵入大,需要业务方自己定制所有的分库分表逻辑。而ShardingProxy是一个独立部署的服务,对业务方无侵入,业务方可以像用一个普通的MySQL服务一样进行数据交互,基本上感觉不到后端分库分表逻辑的存在,但是这也意味着功能会比较固定,能够支持的数据库也比较少。这两者各有优劣。

    ShardingJDBC

    springboot项目pom引入

    <!-- sharding 分库分表-->
    		<dependency>
    			<groupId>org.apache.shardingsphere</groupId>
    			<artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    			<version>4.1.1</version>
    		</dependency>

    浅看一下源码,spring.factories引入了

    org.apache.shardingsphere.shardingjdbc.spring.boot.SpringBootConfiguration

    spring.shardingsphere.enabled默认配置true

     这里还有一个注意点,@AutoConfigureBefore(DataSourceAutoConfiguration.class)

     在springboot配置类之前注入

    数据源默认是第一个shardingDataSource(替换了springboot默认的实现类),因为下面几个condition都不满足,需要额外在配置文件里配置

    springboot默认导入的数据源配置类是org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

    可以看到条件已经不满足了,因为sharding配置类的优先级高,所以是先导入了自己的datasource,默认的也就没用了

     

    核心概念

    • 逻辑表:水平拆分的数据库的相同逻辑和数据结构表的总称

    • 真实表:在分片的数据库中真实存在的物理表。

    • 数据节点:数据分片的最小单元。由数据源名称和数据表组成

    • 绑定表:分片规则一致的主表和子表。

    • 广播表:也叫公共表,指素有的分片数据源中都存在的表,表结构和表中的数据在每个数据库中都完全一致。例如字典表。

    • 分片键:用于分片的数据库字段,是将数据库(表)进行水平拆分的关键字段。SQL中若没有分片字段,将会执行全路由,性能会很差。

    • 分片算法:通过分片算法将数据进行分片,支持通过=、BETWEEN和IN分片。分片算法需要由应用开发者自行实现,可实现的灵活度非常高。

    • 分片策略:真正用于进行分片操作的是分片键+分片算法,也就是分片策略。在ShardingJDBC中一般采用基于Groovy表达式的inline分片策略,通过一个包含分片键的算法表达式来制定分片策略,如t_user_$->{u_id%8}标识根据u_id模8,分成8张表,表名称为t_user_0到t_user_7。

    ShardingJDBC的分片算法

    ShardingSphere目前提供了一共五种分片策略:

    • NoneShardingStrategy

      不分片。这种严格来说不算是一种分片策略了。只是ShardingSphere也提供了这么一个配置。

    • InlineShardingStrategy

      最常用的分片方式

      • 配置参数: inline.shardingColumn 分片键;inline.algorithmExpression 分片表达式
      • 实现方式: 按照分片表达式来进行分片。
    • StandardShardingStrategy

      只支持单分片键的标准分片策略。

      • 配置参数:standard.sharding-column 分片键;standard.precise-algorithm-class-name 精确分片算法类名;standard.range-algorithm-class-name 范围分片算法类名

      • 实现方式:

        shardingColumn指定分片算法。

        preciseAlgorithmClassName 指向一个实现了io.shardingsphere.api.algorithm.sharding.standard.PreciseShardingAlgorithm接口的java类名,提供按照 = 或者 IN 逻辑的精确分片 示例:com.roy.shardingDemo.algorithm.MyPreciseShardingAlgorithm

        rangeAlgorithmClassName 指向一个实现了 io.shardingsphere.api.algorithm.sharding.standard.RangeShardingAlgorithm接口的java类名,提供按照Between 条件进行的范围分片。示例:com.roy.shardingDemo.algorithm.MyRangeShardingAlgorithm

      • 说明:

        其中精确分片算法是必须提供的,而范围分片算法则是可选的。

    • ComplexShardingStrategy

      支持多分片键的复杂分片策略。

      • 配置参数:complex.sharding-columns 分片键(多个); complex.algorithm-class-name 分片算法实现类。

      • 实现方式:

        shardingColumn指定多个分片列。

        algorithmClassName指向一个实现了org.apache.shardingsphere.api.sharding.complex.ComplexKeysShardingAlgorithm接口的java类名。提供按照多个分片列进行综合分片的算法。示例:com.roy.shardingDemo.algorithm.MyComplexKeysShardingAlgorithm

    • HintShardingStrategy

      不需要分片键的强制分片策略。这个分片策略,简单来理解就是说,他的分片键不再跟SQL语句相关联,而是用程序另行指定。对于一些复杂的情况,例如select count(*) from (select userid from t_user where userid in (1,3,5,7,9)) 这样的SQL语句,就没法通过SQL语句来指定一个分片键。这个时候就可以通过程序,给他另行执行一个分片键,例如在按userid奇偶分片的策略下,可以指定1作为分片键,然后自行指定他的分片策略。

      • 配置参数:hint.algorithm-class-name 分片算法实现类。

      • 实现方式:

        algorithmClassName指向一个实现了org.apache.shardingsphere.api.sharding.hint.HintShardingAlgorithm接口的java类名。 示例:com.roy.shardingDemo.algorithm.MyHintShardingAlgorithm

        在这个算法类中,同样是需要分片键的。而分片键的指定是通过HintManager.addDatabaseShardingValue方法(分库)和HintManager.addTableShardingValue(分表)来指定。

        使用时要注意,这个分片键是线程隔离的,只在当前线程有效,所以通常建议使用之后立即关闭,或者用try资源方式打开。

    分片策略2个库,1个库2个表

    分库策略和分表策略都是5种

     

     

    ## oms_order分片策略
    ## 节点 ds0.oms_order_0,ds0.oms_order_1,ds1.oms_order_0,ds1.oms_order_1
    spring.shardingsphere.sharding.tables.oms_order.actual-data-nodes=ds$->{0..1}.oms_order_$->{0..1}
    ##分库策略
    spring.shardingsphere.sharding.tables.oms_order.database-strategy.inline.sharding-column=id
    spring.shardingsphere.sharding.tables.oms_order.database-strategy.inline.algorithm-expression=ds$->{id % 2}
    ## 分表策略
    spring.shardingsphere.sharding.tables.oms_order.table-strategy.inline.sharding-column=id
    ## 注意下,对于除法,groovy会计算出浮点数,而不是整数。即 3/2=1.5,如果需要计算出整数 3.intdiv(2)=1
    spring.shardingsphere.sharding.tables.oms_order.table-strategy.inline.algorithm-expression = oms_order_$->{((id+1) % 4).intdiv(2)}

    ShardingProxy

    hardingProxy目前只支持MySQL和PostgreSQL。并且,客户端连接ShardingProxy时,最好使用MySQL的JDBC客户端。下面我们来部署一个ShardingProxy服务。

    ShardingProxy部署

    从ShardingSphere官网下载4.1.1版本的ShardingProxy发布包apache-shardingsphere-4.1.1-sharding-proxy-bin.tar.gz,解压到本地目录。

    首先,我们需要把MySQL的JDBC驱动包mysql-connector-java-8.0.20.jar手动复制到ShardingProxy的lib目录下。ShardingProxy默认只附带了PostgreSQL的JDBC驱动包,而不包含MySQL的JDBC驱动包。

    然后到conf目录下,修改server.yaml,将配置文件中的authentication和props两段配置的注释打开。

    在ShardingProxy中复制config-sharding.yaml配置:

    schemaName: sharding_db
        
    dataSources:
      ds:
        url: jdbc:mysql://localhost:3306/micromall?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      ds0:
        url: jdbc:mysql://localhost:3306/micromall_ds_0?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      ds1:
        url: jdbc:mysql://localhost:3306/micromall_ds_1?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
    
    shardingRule:
      tables:
        oms_order:
          actualDataNodes: ds$->{0..1}.oms_order_$->{0..1}
          databaseStrategy:
            inline:
              shardingColumn: id
              algorithmExpression: ds$->{id % 2}
          tableStrategy:
            inline:
              shardingColumn: id
              algorithmExpression: oms_order_$->{(id+1) % 4 /2}
          keyGenerator:
            column: id
            type: SNOWFLAKE
            props:
              worker.id: 123
        oms_order_item:
          actualDataNodes: ds$->{0..1}.oms_order_item_$->{0..1}
          databaseStrategy:
            inline:
              shardingColumn: order_id
              algorithmExpression: ds$->{id % 2}
          tableStrategy:
            inline:
              shardingColumn: order_id
              algorithmExpression: oms_order_item_$->{(order_id+1) % 4 / 2}
          keyGenerator:
            column: id
            type: SNOWFLAKE
            props:
              worker.id: 123
      bindingTables: 
        - oms_order,oms_order_item
      defaultDataSourceName: ds
    

    直接运行start.bat/start.sh脚本,默认占用的是3307端口。

    在springboot怎么使用,启动类中排除之前导入的shardingjdbc配置类,就可以用默认的数据源配置了。

     

     

    分库分表带来的问题

    定制主键生成策略:主键是分库分表中非常重要的业务要素,通常分库分表都会采用主键来作为分片键,这个时候主键就不再只是用来提升查询效率了,还需要坚固数据分片的效率。要如何定制高效的主键生成策略?

    很多SQL不支持:例如MySQL里会配for each标签来执行批量SQL,原始数据库是支持的,但是分库分表不支持。查询的SQL比较多时,路由策略是否支持?参见官网文档: SQL :: ShardingSphere 

    其他问题:数据迁移、扩缩容(一开始就设计好了8张表,按id取模--x%8分片策略,突然表不够用要扩容成16张,怎么把数据迁移x%16)、公共表、读写分离、配置往注册中心集中配置

    分布式事务处理:一旦涉及到分布式事务,就会带来非常多麻烦的事情

    展开全文
  • 最近,在研究后台数据库过大的时候,相关的分库分表解决方案。 1.分库分表 当一个数据库里的数据库和数据表足够大的时候,就面临很多问题。由于数据库大多采用B树存储,当数据量太大的时候,会发生资源访问过大,...

    最近,在研究后台数据库过大的时候,相关的分库分表解决方案。

    1.分库分表

    当一个数据库里的数据库和数据表足够大的时候,就面临很多问题。由于数据库大多采用B树存储,当数据量太大的时候,会发生资源访问过大,数据迟缓问题。面对这类问题,比较好的方案是分库分表。

    分库分表的方案有两种:垂直切分和水平切分。

    垂直切分一般为不同业务和不同字段分割到不同部分,水平切分一般为同一数据库或数据表根据一定规则分到不同的数据库和表里。

    一般来说,库一般采用垂直切分,优点是专库专用;表采用水平切分,避免数量过大。

    2.归并结果

    分库分表切分完成后,数据实际会被切分到不同数据库里。当然,在逻辑上,不同数据库里的数据依然在一个集合里。因此,操作数据库的过程必然是:

    1)在输入数据时,数据按照一定规则分到不同的实体数据库或数据表里;

    2)在进行查询的时候,分表去不同物理实体里查询;等到查询完成数据的时候,会进行数据归并。

    因此,查询完数据之后,会进行数据归并。

    3.ShardingSphere的技术方案

    按照Apache的官网说明,“ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈,它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar(计划中)这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能,可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。”

    ShardingSphere是目前较好的技术方案,采用配置后即可完成分库分表的相关方案。

    4.读写分离

    读写分离,是ShardingSphere的另一个方案。其基本想法是:用主表进行写,用辅表进行读。这会让读取速度更快,让写入更少干扰。唯一的问题是:会造成主表和辅表可能存在数据不一致。

    5.分布式事务

    分布式事务,是ShardingSphere的重要功能。分布式事务有几种机制:

    1)两阶段法:分别提交,使事务最终一致;

    2)柔性事务:保持事务的最终一致。

    6.参考文献

    [1]概览 :: ShardingSphere

    展开全文
  • ShardingSphere 分库分表

    2021-05-30 10:55:09
    目录一、ShardingSphere1.1 简介1.2 什么是分库分表1.3 分库分表之垂直拆分1.4 分库分表之水平切分二、 ShardingSphere-JDBC2.1 简介2.2 Sharding-JDBC 分表实操2.3 实现水平分表2.3.1 配置 Sharding-JDBC 分片策略...

    一、ShardingSphere

    1.1 简介

    Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案组成的生态圈,它由 JDBC、Proxy 和 Sidecar(规划中)这 3 款相互独立,却又能够混合部署配合使用的产品组成。 它们均提供标准化的数据分片、分布式事务和数据库治理功能,可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。

    • 一套开源的分布式数据库中间件解决方案。
    • 有三个产品:JDBC、Proxy、Sidecar。

    1.2 什么是分库分表

    当我们使用读写分离、索引、缓存后,数据库的压力还是很大的时候,这就需要使用到数据库拆分了。

    数据库拆分简单来说,就是指通过某种特定的条件,按照某个维度,将我们存放在同一个数据库中的数据分散存放到多个数据库(主机)上面以达到分散单库(主机)负载的效果。

    1.3 分库分表之垂直拆分

    专库专用。一个数据库由很多表的构成,每个表对应着不同的业务,垂直切分是指按照业务将表进行分类,分布到不同的数据库上面,这样也就将数据或者说压力分担到不同的库上面。如下图:

    在这里插入图片描述
    优点:

    1. 拆分后业务清晰,拆分规则明确。
    2. 系统之间整合或扩展容易。
    3. 数据维护简单。

    缺点:

    1. 部分业务表无法 join,只能通过接口方式解决,提高了系统复杂度。
    2. 受每种业务不同的限制存在单库性能瓶颈,不易数据扩展跟性能提高。
    3. 事务处理复杂。

    1.4 分库分表之水平切分

    垂直拆分后遇到单机瓶颈,可以使用水平拆分。相对于垂直拆分的区别是:垂直拆分是把不同的表拆到不同的数据库中,而水平拆分是把同一个表拆到不同的数据库中。

    相对于垂直拆分,水平拆分不是将表的数据做分类,而是按照某个字段的某种规则来分散到多个库之中,每个表中包含一部分数据。简单来说,我们可以将数据的水平切分理解为是按照数据行的切分,就是将表中的某些行切分到一个数据库,而另外的某些行又切分到其他的数据库中,主要有分表,分库两种模式。 如下图:
    在这里插入图片描述
    优点:

    1. 不存在单库大数据,高并发的性能瓶颈。
    2. 对应用透明,应用端改造较少。
    3. 按照合理拆分规则拆分,join 操作基本避免跨库。
    4. 提高了系统的稳定性跟负载能力。

    缺点:

    1. 拆分规则难以抽象。
    2. 分片事务一致性难以解决。
    3. 数据多次扩展难度跟维护量极大。
    4. 跨库 join 性能较差。

    二、 ShardingSphere-JDBC

    2.1 简介

    定位为轻量级 Java 框架,在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库,以 jar 包形式提供服务,无需额外部署和依赖,可理解为增强版的 JDBC 驱动,完全兼容 JDBC 和各种 ORM 框架。

    • 适用于任何基于 JDBC 的 ORM 框架,如:JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC。
    • 支持任何第三方的数据库连接池,如:DBCP, C3P0, BoneCP, Druid, HikariCP 等。
    • 支持任意实现 JDBC 规范的数据库,目前支持 MySQL,Oracle,SQLServer,PostgreSQL 以及任何遵循 SQL92 标准的数据库。
      -在这里插入图片描述

    需要注意的是,分库分表并不是由 ShardingSphere-JDBC 来做,它是用来负责操作已经分完之后的 CRUD 操作。

    2.2 Sharding-JDBC 分表实操

    环境使用:Springboot 2.2.11 + MybatisPlus + ShardingSphere-JDBC 4.0.0-RC1 + Druid 连接池

    具体Maven依赖:

       <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>
    

    2.3 实现水平分表

    准备工作:

    1. 创建数据库 course_db
    2. 创建表 course_1 、 course_2
    3. 约定规则:如果添加的课程 id 为偶数添加到
      course_1 中,奇数添加到 course_2 中。

    SQL 如下:

    create database course_db;
    
    use course_db;
    
    create table course_1 (
        cid bigint(20) primary key ,
        cname varchar(50) not null,
        user_id bigint(20) not null ,
        cstatus varchar(10) not null
    ) engine = InnoDB;
    
    create table course_2 (
        cid bigint(20) primary key ,
        cname varchar(50) not null,
        user_id bigint(20) not null ,
        cstatus varchar(10) not null
    ) engine = InnoDB;
    

    配置对应实体类以及Mapper

    @Data
    public class Course {
        private Long cid;
        private String cname;
        private Long userId;
        private String status;
    }
    

    mapper

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

    启动类配置 MapperScan

    @SpringBootApplication
    @MapperScan(value = "com.beita.shardingspherejdbc.mapper")
    public class ShardingsphereApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(ShardingsphereApplication.class, args);
        }
    
    }
    

    2.3.1 配置 Sharding-JDBC 分片策略

    application.properties 内容:

    # sharding-jdbc 水平分表策略
    # 配置数据源,给数据源起别名
    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
    

    测试代码运行

    	@Test
        public void addCourse() {
            for (int i = 0; i < 10; i++) {
                Course course = new Course();
                //cid由我们设置的策略,雪花算法进行生成
                course.setCname("Java"+i);
                course.setUserId(100L);
                course.setStatus("Normal"+i);
                courseMapper.insert(course);
            }
        }
    

    查询数据库中的某一条记录,可以看到查询的表是正确的。
    在这里插入图片描述

    2.4 实现水平分库

    准备工作:

    1. 创建两个数据库,edu_db_1、edu_db_2。
    2. 每个库中包含:course_1、course_2。
    3. 数据库规则:userid 为偶数添加到 edu_db_1 库,奇数添加到 edu_db_2。
    4. 表规则:如果添加的 cid 为偶数添加到 course_1 中,奇数添加到 course_2 中。

    创建数据库和表结构

    create database edu_db_1;
    create database edu_db_2;
    
    use edu_db_1;
    
    create table course_1 (
       `cid` bigint(20) primary key,
       `cname` varchar(50) not null,
       `user_id` bigint(20) not null,
       `status` varchar(10) not null
    );
    
    create table course_2 (
       `cid` bigint(20) primary key,
       `cname` varchar(50) not null,
       `user_id` bigint(20) not null,
       `status` varchar(10) not null
    );
    
    use edu_db_2;
    
    create table course_1 (
       `cid` bigint(20) primary key,
       `cname` varchar(50) not null,
       `user_id` bigint(20) not null,
       `status` varchar(10) not null
    );
    
    create table course_2 (
       `cid` bigint(20) primary key,
       `cname` varchar(50) not null,
       `user_id` bigint(20) not null,
       `status` varchar(10) not null
    );
    

    配置分片策略
    application.properties内容:

    # sharding-jdbc 水平分库分表策略
    # 配置数据源,给数据源起别名
    # 水平分库需要配置多个数据库
    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
    
    # 指定分库策略    约定 user_id 值偶数添加到 m1 库,如果 user_id 是奇数添加到 m2 库
    # 默认写法(所有的表的user_id)
    #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}
    # 指定只有course表的user_id
    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}
    
    # 指定分表策略    约定 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
    

    测试代码运行

    @Test
        public void addCourse() {
            Course course = new Course();
            //cid由我们设置的策略,雪花算法进行生成
            course.setCname("python");
            //分库根据user_id
            course.setUserId(100L);
            course.setStatus("Normal");
            courseMapper.insert(course);
    
            course.setCname("c++");
            course.setUserId(111L);
            courseMapper.insert(course);
        }
    

    对应的我们 python 的 userId 为偶数所以添加到 edu_db_1 库中,而 c++是奇数所以添加到 edu_db_2 库中。

    运行结果
    看下对应的数据库数据,没有问题。
    在这里插入图片描述
    在这里插入图片描述

    2.4 实现垂直分库

    准备工作:
    我们再额外创建一个 user_db 数据库。当我们查询用户信息就去 user_db,课程信息就去 edu_db_1、edu_db_2。

    创建数据库和表结构

    create database user_db;
    
    use user_db;
    
    create table t_user(
       `user_id` bigint(20) primary key,
       `username` varchar(100) not null,
       `status` varchar(50) not null
    );
    

    配置对应实体类和 Mapper

    @Data
    @TableName("t_user")
    public class User {
        private Long userId;
        private String username;
        private String status;
    }
    

    mapper

    @Repository
    @Mapper
    public interface UserMapper extends BaseMapper<User> {
    }
    

    配置分片策略
    application.properties内容:

    # sharding-jdbc 水平分库分表策略
    # 配置数据源,给数据源起别名
    # 水平分库需要配置多个数据库
    # m0为用户数据库
    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
    
    # 配置user数据源的具体内容,包含连接池,驱动,地址,用户名,密码
    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=m0.t_user
    # 配置主键的生成策略
    spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
    spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
    # 指定分表策略
    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
    
    # 指定分库策略    约定 user_id 值偶数添加到 m1 库,如果 user_id 是奇数添加到 m2 库
    # 默认写法(所有的表的user_id)
    #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}
    # 指定只有course表的user_id
    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}
    
    # 指定分表策略    约定 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
    

    测试代码运行

    	@Test
        public void addUser(){
            User user = new User();
            user.setUsername("Jack");
            user.setStatus("Normal");
            userMapper.insert(user);
        }
    
        @Test
        public void findUser() {
            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.eq("user_id", 601890366953619457L);
            userMapper.selectOne(wrapper);
        }
    

    运行结果如下
    在这里插入图片描述

    在这里插入图片描述

    2.5 公共表

    概念

    1. 存储固定数据的表,表数据很少发生变化,查询时经常要进行关联。
    2. 在每个数据库中都创建出相同结构公共表。
    3. 操作公共表时,同时操作添加了公共表的数据库中的公共表,添加记录时,同时添加,删除时,同时删除。

    配置公共表的实体类和 mapper

    @Data
    @TableName("t_dict")
    public class Dict {
        private Long dictId;
        private String status;
        private String value;
    }
    
    @Repository
    @Mapper
    public interface DictMapper extends BaseMapper<Dict> {
    }
    
    

    配置分片策略

    # sharding-jdbc 水平分库分表策略
    # 配置数据源,给数据源起别名
    # 水平分库需要配置多个数据库
    # m0为用户数据库
    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
    
    # 配置user数据源的具体内容,包含连接池,驱动,地址,用户名,密码
    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=m0.t_user
    # 配置主键的生成策略
    spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
    spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
    # 指定分表策略
    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
    
    # 指定分库策略    约定 user_id 值偶数添加到 m1 库,如果 user_id 是奇数添加到 m2 库
    # 默认写法(所有的表的user_id)
    #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}
    # 指定只有course表的user_id
    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}
    
    # 指定分表策略    约定 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}
    
    # 公共表配置
    spring.shardingsphere.sharding.broadcast-tables=t_dict
    # 配置主键的生成策略
    spring.shardingsphere.sharding.tables.t_dict.key-generator.column=dict_id
    spring.shardingsphere.sharding.tables.t_dict.key-generator.type=SNOWFLAKE
    
    # 打开 sql 输出日志
    spring.shardingsphere.props.sql.show=true
    

    测试代码运行

    @Autowired
    private DictMapper dictMapper;
    
    @Test
    public void addDict() {
        Dict dict = new Dict();
        dict.setStatus("Normal");
        dict.setValue("启用");
        dictMapper.insert(dict);
    }
    
    @Test
    public void deleteDict() {
        QueryWrapper<Dict> wrapper = new QueryWrapper<>();
        wrapper.eq("dict_id", 536486065947541505L);
        dictMapper.delete(wrapper);
    }
    

    运行结果如下
    在这里插入图片描述
    在这里插入图片描述

    2.6 读写分离

    2.6.1 什么是读写分离

    了解读写分离前,我们先了解下什么是主从复制。

    主从复制,是用来建立一个和主数据库完全一样的数据库环境,称为从数据库,主数据库一般是准实时的业务数据库。一台服务器充当主服务器,而另外一台服务器充当从服务器。

    2.6.2 主从复制原理

    在这里插入图片描述
    主库将变更写入 binlog 日志,然后从库连接到主库之后,从库有一个 IO 线程,将主库的 binlog 日志拷贝到自己本地,写入一个 relay 中继日志(relay log)中。接着从库中有一个 SQL 线程会从中继日志读取 binlog,然后执行 binlog 日志中的内容,也就是在自己本地再次执行一遍 SQL 语句,从而使从服务器和主服务器的数据保持一致。

    也就是说:从库会生成两个线程,一个 I/O 线程,一个 SQL 线程; I/O 线程会去请求主库的 binlog,并将得到的 binlog 写到本地的 relay-log(中继日志)文件中; 主库会生成一个 log dump 线程, 用来给从库 I/O 线程传 binlog; SQL 线程,会读取 relay log 文件中的日志,并解析成 sql 语句逐一执行。

    注意:从库同步主库数据的过程是串行化的,也就是说主库上并行的操作,在从库上会串行执行。
    由于从库从主库拷贝日志以及串行执行 SQL 的特点,在高并发场景下,从库的数据是有延时的。
    在实际运用中,时常会出现这样的情况,主库的数据已经有了,可从库还是读取不到,可能要过几十毫秒,甚至几百毫秒才能读取到。

    • 半同步复制:解决主库数据丢失问题。也叫 semi-sync 复制,指的就是主库写入 binlog 日志之后,就会强制将数据立即同步到从库,从库将日志写入自己本地的 relay log 之后,接着会返回一个 ack 给主库,主库接收到至少一个从库的 ack 之后才会认为写操作完成了。
    • 并行复制:解决从库复制延迟的问题。指的是从库开启多个线程,并行读取 relay log 中不同库的日志,然后并行存放不同库的日志,这是库级别的并行。

    主从同步延迟问题
    MySQL 可以通过 MySQL 命令 show slave status 获知当前是否主从同步正常工作。

    另外一个重要指标就是 Seconds_Behind_Master,根据输出的 Seconds_Behind_Master 参数的值来判断:

    • NULL,表示 io_thread 或是 sql_thread 有任何一个发生故障。
    • 0,表示主从复制良好。
    • 正值,表示主从已经出现延时,数字越大表示从库延迟越严重。

    导致主从同步延迟情况

    • 主库的从库太多,导致复制延迟。
    • 从库硬件比主库差,导致复制延迟。
    • 慢 SQL 语句过多。
    • 主从复制的设计问题,例如主从复制单线程,如果主库写并发太大,来不及传送到从库,就会导致延迟。Mysql5.7
      之后可以支持多线程复制。设置参数slave_parallel_workers>0
      和slave_parallel_type=’LOGICAL_CLOCK’。
    • 网络延迟。

    主从同步解决方案

    • 使用 PXC 架构
    • 避免一些无用的 IO 消耗,可以上 SSD。
    • IO 调度要选择 deadline 模式。
    • 适当调整 buffer pool 的大小。
    • 避免让数据库进行各种大量运算,数据库只是用来存储数据的,让应用端多分担些压力,或者可以通过缓存来完成。

    说到底读写分离就是主库进行写操作,从库进行读操作。具体可以搭配一主一从、一主多从、多主多从。根据业务场景来进行选择。

    2.6.3 搭建一主一从 MySQL 环境

    我使用的是 Centos7 虚拟机,使用docker搭建mysql环境。

    这里不讲如何搭建 docker 环境了。

    首先安装启动主MySQL服务:

    docker run -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
    

    启动从MySQL服务:

    docker run -p 3307:3306 --name mysql-slave -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
    
    #进入主服务容器内部
    docker exec -it mysql /bin/bash
    
    #切换到/etc/mysql目录下
    cd /etc/mysql
    
    #然后vim my.cnf对my.cnf进行编辑,需要在容器内部安装vim
    apt-get update
    apt-get install vim
    
    #然后vim my.cnf配置主服务的配置
    [mysqld]
    ## 同一局域网内注意要唯一
    server-id=100  
    ## 开启二进制日志功能,可以随便取(关键)
    log-bin=mysql-bin
    
    #重启主服务
    docker restart mysql
    

    以上完毕之后我们登录主服务器的 MySQL,用navicat远程连接主库。

    [Err] 1055 - Expression #1 of ORDER BY clause is not in GROUP BY clause 解决办法 MySQL
    
    select version(),
    @@sql_mode;SET sql_mode=(SELECT REPLACE(@@sql_mode,'ONLY_FULL_GROUP_BY',''));
    
    #新建一个用户专门用来同步master
    CREATE USER 'backup'@'%' IDENTIFIED BY '123456';
    
    #给backup用户分配备份的权限
    GRANT REPLICATION SLAVE ON *.* to 'backup'@'%' identified by '123456';
    
    #主库配置完成。查看主库状态:
    show master status;
    
    记住查询结果,后面会用。
    File: mysql-bin.000001
    Position: 1083
    

    配置从库

    #进入从服务容器内部
    docker exec -it mysql-slave /bin/bash
    
    #切换到/etc/mysql目录下
    cd /etc/mysql
    
    #然后vim my.cnf对my.cnf进行编辑,需要在容器内部安装vim
    apt-get update
    apt-get install vim
    
    #然后vim my.cnf配置主服务的配置
    #设置从mysql的id
    server-id = 2
    #启用中继日志
    relay-log = mysql-relay
    
    #重启主服务
    docker restart mysql-slave
    

    以上完毕之后我们登录从服务器的 MySQL,用navicat远程连接。

    从库通过IO线程连接master,所以需要指定master的信息,包括host, port, user, password

    change master to master_host='169.254.188.10', 
        master_port=3306, 
        master_user='backup', 
        master_password='123456', 
        master_log_file='mysql-bin.000001', 
        master_log_pos=1083;
    start slave;
    

    查看从库状态,

    show slave status;
    

    如果显示
    则说明连接成功。

    测试
    在master上操作,更改都会显示在slave上。

    2.6.4 Sharding-JDBC 实现读写分离

    Sharding-JDBC 实现读写分离则是根据sql 语句语义分析,当 sql 语句有 insert、update、delete 时,Sharding-JDBC 就把这次操作在主数据库上执行;当 sql 语句有 select 时,就会把这次操作在从数据库上执行,从而实现读写分离过程。
    但 Sharding-JDBC 并不会做数据同步,数据同步是配置 MySQL 后由 MySQL 自己完成的。

    搭建环境成功后我们在主库和从库上都建库建表:

    create database user_db;
    
    use user_db;
    
    create table t_user(
       `user_id` bigint(20) primary key,
       `username` varchar(100) not null,
       `status` varchar(50) not null
    );
    

    配置读写分离策略
    application.properties:

    # 配置数据源,给数据源起别名
    # m0为用户数据库
    spring.shardingsphere.datasource.names=m0,s0
    
    # 一个实体类对应两张表,覆盖
    spring.main.allow-bean-definition-overriding=true
    
    #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://169.254.188.10:3306/user_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.m0.username=root
    spring.shardingsphere.datasource.m0.password=123456
    
    #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://169.254.188.10:3307/user_db?serverTimezone=GMT%2B8
    spring.shardingsphere.datasource.s0.username=root
    spring.shardingsphere.datasource.s0.password=123456
    
    # 主库从库逻辑数据源定义 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=m0.t_user
    # t_user 分表策略,固定分配至 ds0 的 t_user 真实表
    spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds0.t_user
    
    # 配置主键的生成策略
    spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
    spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
    # 指定分表策略
    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
    

    测试代码运行

    @Autowired
    private UserMapper userMapper;
    
    @Test
    public void addUser(){
        User user = new User();
        user.setUsername("Jack");
        user.setStatus("Normal");
        userMapper.insert(user);
    }
    
    @Test
    public void findUser() {
      QueryWrapper<User> wrapper = new QueryWrapper<>();
      wrapper.eq("user_id", 536553906142969857L);
      userMapper.selectOne(wrapper);
    }
    

    在这里插入图片描述
    在这里插入图片描述

    m0是主库,s0是从库,可以看到添加记录走的是主库,查询走的是从库。
    在这里插入图片描述

    展开全文
  • Spring Boot ShardingSphere 分库分表 附代码
  • 一、分库分表 1、随着时间和业务发展,数据库数据量不可控,造成表中数据越来越多,此时再进行CRUD操作的话,会造成很大的性能问题,比如查询实时数据,表数据达到了千万级别,要求一分钟查询一次,但你一个select...
  • shardingsphere 分库分表及配置示例

    千次阅读 2021-12-03 11:06:46
    shardingsphere 分库分表及配置示例。shardingsphere功能列表、配置参考、详细示例及参数配置
  • ) ::: [101] Order(id=479339444424409088, orderSn=222222, memberId=101, createTime=Mon Jun 15 17:23:47 CST 2020, status=1) 总结 shardingsphere分库分表可以解决单库单表的数据库的性能瓶颈问题,开发者使用...
  • ShardingSphere简述 Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈,它由 JDBC、Proxy 和 Sidecar(规划中)这 3 款既能够独立部署,又支持混合部署配合使用的产品组成。 它们均提供标准化的...
  • ShardingSphere分库分表实战与核心原理

    千次阅读 2021-12-01 14:23:09
    ShardingSphere分库分表实战与核心原理
  • 创建并启动从 容器3. 查看启动的容器二、主服务器 数据库配置2.1. 首先进入主库容器内部2.2. 修改 my.cnf2.3. 登录主库mysql数据库2.4. 在主库上创建同步用户并授权2.4. 创建用户并赋予权限2.4. 修复远程登录异常...
  • 在介绍完 ShardingSphere 所具备的分库分表、读写分离、分布式事务、数据脱敏等各项核心功能之后,我将带领你全面剖析这些核心功能背后的实现原理和机制。我们将通过深入解析 ShardingSphere 源码这一途径来实现这一...
  • 数据片后,不同数据节点生成全局唯一主键是非常棘手的问题。同一个逻辑表内的不同实际表之间的自增键由于无法互相感知而产生重复主键。 虽然可通过约束自增主键初始值和步长的方式避免碰撞,但需引入额外的运维...
  • ShardingSphere定位为轻量级 Java 框架,在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库,以 jar 包形式提供服务,无需额外部署和依赖,可理解为增强版的 JDBC 驱动,完全兼容 JDBC 和各种 ORM 框架。...
  • 这一部分,我们主要了解ShardingSphere进行分库分表的底层原理,并且深入到源码了解分库分表的实际运行过程。 一方面,我们之前在学习ShardingJDBC时,积累了大量的测试实例,对于学习底层原理是非常好的学习入口。 ...
  • 本实战记录使用Docker 19.03.5,mysql 5.7.24 ,Java 1.8.0_151,ShardingSphere 4.1.1,mysql-connector 5.1.32,使用教程参考官网手册Proxy和Scaling部分. Docker和mysql的安装可见Docker安装Mysql并配置 重要:记得my....
  • ShardingSphere分库分表实战

    万次阅读 多人点赞 2019-06-28 15:44:03
    我们做项目的时候,数据量比较大,单表千万级别的,需要分库分表,于是在网上搜索这方面的开源框架,最常见的就是mycat,sharding-sphere,最终我选择后者,用它来做分库分表比较容易上手。 二. 简介sharding-sphere ...
  • 我们开始使用主从架构,用户量和业务量进一步上升之后,微服务集群和数据库集群也就出现了,就应用而言,随着服务器的增加可以将请求量分摊到出去,而数据库是不是也可以采用类似的思想进行分而治之呢,分库分表就...
  • 单表 假设现在有一个存储商品信息的数据库db_product,db_product里面有一张Product商品信息表,里面存储了商品ID和商品名称,先 使用Springboot搭建一个项目,Mysql作为数据库,对Product表进行操作。 初始化...
  • 本文主要采用SpringBoot + MyBatisPlus + sharding-jdbc技术实现分库分表,基于yaml配置。 理论:ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈,它由Sharding-JDBC、Sharding-Proxy 和 ...
  • 你好,我是萧然,长期从事分布式系统的构建和优化工作,负责过大型电商以及物联网系统的设计和开发,曾带领团队完成业界领先的物联网数据平台建设工作,对基于 ShardingSphere 进行数据分库分表和治理工作有着丰富的...
  • shardingsphere 分库分表demo

    千次阅读 2022-03-28 16:35:09
    column=id spring.shardingsphere.sharding.tables.product_order.table-strategy.inline.algorithm-expression=product_order_$->{id % 2} #自定义分库分表策略 #spring.shardingsphere.sharding.tables.product_...
  • 在上一课时中,我详细介绍了 ShardingSphere 与 JDBC 规范之间的兼容性关系,我们知道 ShardingSphere 对 JDBC 规范进行了重写,并嵌入了片机制。基于这种兼容性,开发人员使用 ShardingSphere 时就像在使用 JDBC ...
  • 分库分表&主从 <sharding:inline-strategy id="databaseStrategy" sharding-column="id" algorithm-expression="smart_$->{id%2}"/> <sharding:inline-strategy id="tableStrategy" sharding-...
  • shardingjdbc分库分表----取模和按时间分表 每天多学一点点~ 话不多说,这就开始吧… 文章目录shardingjdbc分库分表----取模和按时间分表1.前言2. 取模分库分表配置3. 分片策略简介4. 根据日期分库分表配置5.结语 1....
  • shardingsphere分库分表多表关联查询

    万次阅读 2020-04-23 15:39:29
    shardingsphere分库分表表关联查询的应用 1.准备工具mysql 2.sql语句如下; demo_ds_0数据源表结构 CREATE DATABASE demo_ds_0 CHARSET=utf8; use demo_ds_0; DROP TABLE IF EXISTS t_user_0; CREATE TABLE t_user_0 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,419
精华内容 2,567
关键字:

shardingsphere分库分表