ShadingJDBC（快速入门）小白版本

分库分表专题

初始代码gitt仓库：https://gitee.com/liu332256/spring-sharding-jdbc.git

想要md文件的请发关注点赞私信我 免费赠送笔记

学习目标

1.理解分库分表的基本概念 【垂直分库分表、水平分库分表】

2.能够说出sharding-jdbc为我们解决什么问题

3.理解sharding-jdbc中的关键名词

4.理解sharding-jdbc的整体架构及原理

5.掌握sharding-jdbc集成SpringBoot的方式

第一章 分库分表介绍

1、分库分表概述

分库分表的本质就是为了解决由于数据库数据量过大而导致数据库性能降低

核心操作：

• 将原来的独立的数据库拆分成若干的数据库组成
• 将原来的达标(存储近千万数据的表)拆分成若干小表

目的：使得单一数据库、单一数据表的数据量变小，从而达到提升数据库性能的目的；

2、分库分表场景

2.1场景重现

我们以某宝为例：

实际业务中经常需要查询商品、商铺、地理位置等信息，效果如下：

随着公司业务快速发展，数据库中的店铺、商品等数据量会猛增，如果按照我们之前的开发思维将所有数据放在单库单表中，大数据量且并发高的访问会导致数据库性能急剧下降；

2.2原因分析

原因如下：

• 在系统应用中关系型数据库本身比较容易成为系统瓶颈（I/O）,比如：单机存储容量、数据库连接数、处理能力等都有上限；
• 当单表的数据量达到1000W或100G以后(大表)，即使做了优化索引等操作，查询性能仍会下降严重，更不要说复杂的多表关联查询了；
• 对于商家模块来说，当数据量过大是，会存在大表关联查询，导致查询性能急剧下降！[尽量避免大表的关联查询-查询优化-反三大范式]

第二章 分库分表方式

分库分表包括分库和分表两个部分，在生产中通常包括：垂直分库、水平分库、垂直分表、水平分表四种方式；

1、垂直分表

• 垂直分表就是在同一数据库内将一张表按照指定字段分成若干表，每张表仅存储其中一部分字段；
• 垂直分表拆解了原有的表结构，拆分的表之间一般是一对一的关系；

1.1场景复现

还是这张图

• 我们在浏览商品的时候大部分都是停留在这种页面，点击进入商品详情页面的概率就会更少，也就是说我们查看商品详情的频率很少，且该字段占用存储空间较大；
• 但是：商品名称、商品图片、商品价格等其他字段数据访问频次较高

所以我们可以这样垂直分库：

1.2垂直分表优势

• 充分提高了热点数据的操作效率，此时分开了商品描述字段就不会拖累商品信息的查找效率了（冷热数据分离）

• 避免了IO过度争抢并减少锁表的几率，查看商品详情的用户与商品信息浏览互不影响；

2、垂直分库

垂直分库是指按照业务将表进行归类，然后把不同类的表分布到不同的数据库上面，而每个库又可以放在不同的服务器上，它的核心理念是-专库专用；

2.1场景复现

经过思考，我们可以将原有的卖家库，拆分为分为商品库和店铺库，并把这两个库分散到不同服务器上，如下图：

注意事项：

由于商品信息与商品描述业务耦合度较高，因此一起被存放在商品库（避免跨库联查）；

店铺信息相对独立，因此可单独被存放在店铺库下；

对于地理区域表，因为商品信息和店铺信息都需要，且地理区域是不经常变动的常量表但是会存在与其他表联查的情况，所以可以将它作为公共表（后面也称广播表）分别等量部署到不同的数据库节点下；
以上操作就可以称为垂直分库。

2.1垂直分库优势

• 通过不同的业务聚合，使得是数据库维护更加清晰
• 能对不同的数据进行分级管理、维护、监控、扩展等
• 高并发场景下，垂直分库在一定程度上提高了磁盘IO和数据库连接数，并改善了单机硬件资源的瓶颈问题；

然而，垂直分库依然没有解决单表的数据量过大的问题

3、水平分表

• 水平分表就是在同一个数据库内，把同一个表的数据按一定规则拆到多个表中，表的结构没有变化；
• 水平分表解决单表数据量大的问题；

3.1场景复现

为了解决单表数据量过大的问题，我们可以把商品库中的表进行水平拆分，得到若干小表，但是需要注意的是这样分完后各个小表存储的数据不同（shadingjdbc能解决）且数据依旧保存在同一个数据库内

如下图：

分表算法举例：

更具商品ID为例 ，双数到商品信息1表，单数存在商品信息2表 公式：[商品ID%2 + 1];

这种操作就叫做：水平分表。

3.1水平分表的优势

水平分表是在同一个数据库内，把同一个表的数据按一定规则拆到多个表中，它带来的提升是：

• 优化单一表数据量过大而产生的性能问题;
• 避免IO争抢并减少锁表的几率;

然而，整体看来这仅仅解决了单表数据量过大的问题，但是没有解决单表数据量过大的问题

对当前库来说依旧压力很大

4、水平分表

• 水平分库可以看做是水平分表的进一步拆分，是把同一个表的数据按一定规则拆到不同的数据库中，每个库又可以部署到不同的服务器上；
• 水平分库解决了单库数据量大的问题，突破了服务器物理存储的瓶颈；

4.1场景复现

经过垂直分库和水平分表后，数据库性能问题得到一定程度的解决，但是随着业务量的增长，商品库单库存储数据已经超出预估。

假如当前有8w店铺，每个店铺平均150个不同规格的商品，那商品数量得往1200w+上预估，并且商品库属于访问非常频繁的资源，单台服务器已经无法支撑。

目前情况是那怕再次垂直分库也无法解决数据瓶颈问题。我们可以尝试水平分库，将商品ID为单数的和商品ID为双数的商品信息分别放在两个不同库中；

说明：

如果商品ID为双数，将此操作映射至【商品库-1】；
如果店铺ID为单数，将操作映射至【商品库-2】；
此操作要访问数据库名称的表达式为：商品库_(商品ID%2 + 1)；
这种操作就叫水平分库。
总之，水平分库后，各个库保存的表结构是一致的，但是表中内容不一样；

4.2水平分库优势

水平分库带来的提升是：

• 解决了单库大数据，高并发的性能瓶颈问题；
• 提高了系统的稳定性及可用性；

5、分库分表带来的问题

分库分表能有效的缓解了单机和单库带来的性能瓶颈和压力，突破网络IO、硬件资源、连接数的瓶颈，同时也带来了一些问题。

• 分布式事务一致性问题
• 跨节点关联查询
• 跨节点分页、排序函数
• 主键避重
• 公共表(小数据量的表且经常使用，可能存在联查的情况）

显然如果我们自己去解决上述问题，开发工作量较大，所以我们就有必要学习一种支持分库分表特性的技术：sharding-jdbc、mycat等；

6、分库分表小结

分库分表方式：垂直分表、垂直分库、水平分库和水平分表

**垂直分表：**可以把一个宽表的字段按访问频次、是否是大字段的原则拆分为多个表，这样既能使业务清晰，还能提升部分性能。拆分后，尽量从业务角度避免联查，否则性能方面将得不偿失【同一库中将单张表按照字段拆分成若干表，拆分后表的记录行数不变】。

**垂直分库：**可以把多个表按业务耦合松紧归类，分别存放在不同的库，这些库可以分布在不同服务器，从而使访问压力被多服务器负载，大大提升性能，同时能提高整体架构的业务清晰度，不同的业务库可根据自身情况定制优化方案。但是它需要解决跨库带来的所有复杂问题。 【根据业务将表分组形成不同的库，这些库又可以部署到不同的数据库中-专库专用】

**水平分表：**可以把一个表的数据(按数据行)分到多个同一个数据库的多张表中，每个表只有这个表的部分数据，这样做能小幅提升性能，它仅仅作为水平分库的一个补充优化。【同一数据库中将大表拆分成若干小表，每张表的结构一致，但保存的数据不同】

水平分库：可以把表的数据(按数据行)分 到多个不同的库，每个库只有这个表的部分数据，这些库可以分布在不同服务器，从而使访问压力被多服务器负载，大大提升性能。它不仅需要解决跨库带来的所有复杂问题，还要解决数据路由的问题(数据路由问题后边介绍)。

最佳实践：

一般来说，在系统设计阶段就应该根据业务耦合松紧来确定垂直分库，垂直分表方案。当然在数据量及访问压力不是特别大的情况，首先考虑缓存、读写分离、索引技术等方案。若数据量极大，且持续增长，再考虑水平分库水平分表方案。

总之，基于开发和维护成本比考虑，非必须，不要对数据库做分库分表处理！

第三章 Sharding-JDBC入门

1、ShardingSphere生态

Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，核心由： JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成；

功能特性：它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。

官方网站：https://shardingsphere.apache.org/index_zh.html

文档地址：https://shardingsphere.apache.org/document/legacy/4.x/document/cn/overview

主要介绍：Sharding-JDBC；

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

2、sharding-jdbc相关名词解释

此章节非常重要请大家好好理解

参考官网-核心概念

• 逻辑表（LogicTable）：水平拆分的数据库（表）的相同逻辑和数据结构表的总称。例：订单数据根据主键尾数拆分为10张表，分别是t_order_0到t_order_9，他们的逻辑表名为t_order。理解成前缀

• 真实表（ActualTable） ：在分片的数据库中真实存在的物理表。即上个示例中的t_order_0到t_order_9。

• 数据节点（DataNode）：数据分片的最小单元。由数据源名称和数据表组成，例：ds_0.t_order_0。

• 动态表（DynamicTable）：逻辑表和物理表不一定需要在配置规则中静态配置。如，按照日期分片的场景，物理表的名称随着时间的推移会产生变化（股票流水）。

• 广播表（公共表）：指所有的分片数据源中都存在的表，表结构和表中的数据在每个数据库中均完全一致。适用于数据量不大且需要与海量数据的表进行关联查询的场景，例如：字典表。

• 分片键（ShardingColumn）：分片字段用于将数据库（表）水平拆分的字段，支持单字段及多字段分片。例如上例中的order_id。

3、Sharding-JDBC执行原理

参考官网-内部剖析：

4、Sharding-JDBC分片方式介绍

参考：https://shardingsphere.apache.org/document/legacy/4.x/document/cn/manual/sharding-jdbc/configuration/config-spring-boot/

sharding-jdbc实现数据分片有4种策略：

• inline模式

  • 使用最简单，开发成本比较低；
  • 只能使用单个字段作为分片键；
  • 基于行表达式定义分片规则；

  通过groovy表达式来表示分库分表的策略；
  db0
    ├── t_order0
    └── t_order1
  db1
    ├── t_order0
    └── t_order1
    表达式：db${0..1}.t_order${0..1}
    	     t_order${orderId % 2}
  

• standard标准分片模式

  • 用户可通过代码自定义复杂的分片策略；
  • 同样只能使用单个字段作为分片键；

• complex复合分片模式

  • 用于多分片键的复合分片策略（多片键）

• Hint强制分片模式

  • 不指定片键，通过代码动态指定路由规则
  • 强制分片策略（强制路由）

5、standard标准分片模式实现水平分表

5.1 水平分表数据准备

order_db_1
  ├── t_order_1
  └── t_order_2

SQL

#创建数据库
CREATE DATABASE `order_db_1` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
#建表
USE order_db_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) CHARACTER
SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
 PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER
SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

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) CHARACTER
SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
 PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER
SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

5.2 工程集成sharding-jdbc

准备环境：jdk11

导入基础测试工程：https://gitee.com/liu332256/spring-sharding-jdbc.git

第一步：测试工程引入核心依赖

<dependencies>
  <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
  </dependency>
  <!--引入sharding依赖-->
  <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</artifactId>
    <version>1.2.8</version>
  </dependency>
</dependencies>

第二步：定义sharding相关配置

1) 主配置

注意：这些配置在我的初始文件中虽然有但是建议自己重写

#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis.mapper-locations=classpath:mappers/*xml
#指定Mybatis的实体目录
mybatis.type-aliases-package=com.itheima.sharding.entity
spring.profiles.active=test1

2) 环境application-test1.properties配置

参照官网：Spring Boot配置 :: ShardingSphere (apache.org) 建议直接复制官网源码

# 1.首先我们需要知道数据库的数据源 （从哪来）
#数据源名称，多数据源以逗号分隔
spring.shardingsphere.datasource.names=ds1

#数据库连接池类名称
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
#数据库驱动类名称
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库url连接
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://192.168.204.136:3306/order_db_1?serverTimezone=Asia/Shanghai&useSSL=false
#数据库用户名
spring.shardingsphere.datasource.ds1.username=root
#数据库密码
spring.shardingsphere.datasource.ds1.password=1234


# 2.配置指定的数据节点 （到哪去）
#由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持inline表达式。缺省表示使用已知数据源与逻辑表名称生成数据节点，
#用于广播表（即每个库中都需要一个同样的表用于关联查询，多为字典表）或只分库不分表且所有库的表结构完全一致的情况
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds1.t_order_$->{1..2}

# 4.配置分片策略
common.algorithm.tb=com.itheima.sharding.alg.Comm4Tb
#分片列名称
spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.sharding-column=order_id
#精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.precise-algorithm-class-name=${common.algorithm.tb}
#范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.range-algorithm-class-name=${common.algorithm.tb}

# 5.是否开启SQL显示，默认值: false
spring.shardingsphere.props.sql.show=true

通过阅读官方API，我们发现基于标准模式实现分表，需要为表定义精准查询和范围查询实现：

PreciseShardingAlgorithm ：精准查询库或者表（sql使用使用了= 、in）
RangeShardingAlgorithm ：范围查询库或者表 （between and 、 > 、 <）
所以，使用sharding-jdbc时尽量让分片键去查询，且遵循使用规范；

3） 定义标准分表策略

package com.itheima.sharding.alg;

import com.google.common.collect.Range;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingValue;

import java.util.Collection;

/**
 * 定义精准查询表的算法类 接口中的泛型与数据库的片键类型一致
 *      select * from t_order where order_id = ?
 */
public class Comm4Tb implements PreciseShardingAlgorithm<Long>, RangeShardingAlgorithm<Long> {
    /**
     * 定义精准匹配表的方法
     * @param collection 所有配置的物理表的集合t_order_${1..2} 包含t_order_1 t_order_2封装到该集合下
     * @param preciseShardingValue 数据库对应分片键的值 ---> order_id
     * @return 返回匹配的数据源
     */
    @Override
    public String doSharding(Collection<String> collection, PreciseShardingValue<Long> preciseShardingValue) {

        //获取逻辑表名称
        String logicTableName = preciseShardingValue.getLogicTableName();

        //1.获取分片键名称-->即数据库中列的名称 user_id
        String columnName = preciseShardingValue.getColumnName();

        //2.获取分片键的值
        Long value = preciseShardingValue.getValue();

        //3.根据分片键的值，计算出对应的数据源名称
        //   3.1 先计算出分片键的值对应的模数
        Long mod = value % 2 + 1;
        //   3.2 根据模数，从数据源集合中获取对应的数据源名称
        String dataSourceName = collection.stream().filter(dsName -> dsName.endsWith(mod+"")).findFirst().get();

        return dataSourceName;
    }

    /**
     *
     * @param collection 配置文件中的数据源集合 ds1 ds2
     * @param rangeShardingValue 分片值 即 BETWEEN user_id BETWEEN 1 AND 10
     * @return
     */
    @Override
    public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<Long> rangeShardingValue) {
        //获取逻辑表名
        String logicTableName = rangeShardingValue.getLogicTableName();
        //1.获取分片键名
        String shardingColumn = rangeShardingValue.getColumnName();
        //2.获取分片键值范围
        Range<Long> valueRange = rangeShardingValue.getValueRange();
        //3.根据分片键值范围，进行范围匹配
        if (valueRange.hasLowerBound()){//存在下限
            Long l = valueRange.lowerEndpoint();
        }
        if (valueRange.hasUpperBound()){//存在上限
            Long u = valueRange.upperEndpoint();
        }
        return collection;
    }
}

3) 定义mapper接口和xml

package com.itheima.shardingjdbc.mapper;

import com.itheima.shardingjdbc.pojo.TOrder;
import org.apache.ibatis.annotations.Mapper;

/**
 * @Entity com.itheima.shardingjdbc.pojo.TOrder
 */
@Mapper
public interface TOrderMapper {

    int deleteByPrimaryKey(Long id);

    int insert(TOrder record);

    int insertSelective(TOrder record);

    TOrder selectByPrimaryKey(Long id);

    int updateByPrimaryKeySelective(TOrder record);

    int updateByPrimaryKey(TOrder record);

}

定义与接口绑定的xml:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.shardingjdbc.mapper.TOrderMapper">

    <resultMap id="BaseResultMap" type="com.itheima.shardingjdbc.pojo.TOrder">
            <id property="orderId" column="order_id" jdbcType="BIGINT"/>
            <result property="price" column="price" jdbcType="DECIMAL"/>
            <result property="userId" column="user_id" jdbcType="BIGINT"/>
            <result property="status" column="status" jdbcType="VARCHAR"/>
    </resultMap>

    <sql id="Base_Column_List">
        order_id,price,user_id,
        status
    </sql>

    <select id="selectByPrimaryKey" parameterType="java.lang.Long" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List" />
        from t_order
        where  order_id = #{orderId,jdbcType=BIGINT} 
    </select>

    <delete id="deleteByPrimaryKey" parameterType="java.lang.Long">
        delete from t_order
        where  order_id = #{orderId,jdbcType=BIGINT} 
    </delete>
    <insert id="insert" parameterType="com.itheima.shardingjdbc.pojo.TOrder">
        insert into t_order
        ( order_id,price,user_id
        ,status)
        values (#{orderId,jdbcType=BIGINT},#{price,jdbcType=DECIMAL},#{userId,jdbcType=BIGINT}
        ,#{status,jdbcType=VARCHAR})
    </insert>
    <insert id="insertSelective" keyColumn="id" keyProperty="id" parameterType="com.itheima.shardingjdbc.pojo.TOrder" useGeneratedKeys="true">
        insert into t_order
        <trim prefix="(" suffix=")" suffixOverrides=",">
                <if test="orderId != null">orderId,</if>
                <if test="price != null">price,</if>
                <if test="userId != null">userId,</if>
                <if test="status != null">status,</if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
                <if test="orderId != null">order_id = #{orderId,jdbcType=BIGINT},</if>
                <if test="price != null">price = #{price,jdbcType=DECIMAL},</if>
                <if test="userId != null">user_id = #{userId,jdbcType=BIGINT},</if>
                <if test="status != null">status = #{status,jdbcType=VARCHAR},</if>
        </trim>
    </insert>
    <update id="updateByPrimaryKeySelective" parameterType="com.itheima.shardingjdbc.pojo.TOrder">
        update t_order
        <set>
                <if test="price != null">
                    price = #{price,jdbcType=DECIMAL},
                </if>
                <if test="userId != null">
                    user_id = #{userId,jdbcType=BIGINT},
                </if>
                <if test="status != null">
                    status = #{status,jdbcType=VARCHAR},
                </if>
        </set>
        where   order_id = #{orderId,jdbcType=BIGINT} 
    </update>
    <update id="updateByPrimaryKey" parameterType="com.itheima.shardingjdbc.pojo.TOrder">
        update t_order
        set 
            price =  #{price,jdbcType=DECIMAL},
            user_id =  #{userId,jdbcType=BIGINT},
            status =  #{status,jdbcType=VARCHAR}
        where   order_id = #{orderId,jdbcType=BIGINT} 
    </update>
</mapper>

注意：xml中使用的逻辑表t_order，而不是t_order1、t_order2

4) 测试

@SpringBootTest
public class TestAll {

    @Autowired
    private TOrderMapper tOrderMapper;
    @Test
   public void test1() {
        int orderId=0;
        Random random = new Random();
        for (int i = 0; i < 20; i++) {
            //保证随机生成奇数或者偶数
            orderId+=random.nextInt(2)+1;
            TOrder order = TOrder.builder().orderId(Long.valueOf(orderId))
                    .userId(Long.valueOf(i))
                    .status("1")
                    .price(new BigDecimal(300))
                    .build();
            tOrderMapper.insert(order);
        }
    }
}

6、standard标准分片模式实现水平分表

6.1 数据库准备

order_db_1
  ├── t_order_1
  └── t_order_2
order_db_2
  ├── t_order_1
  └── t_order_2  

SQL准备：

#继续构建order_db_2数据库
CREATE DATABASE `order_db_2` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
#建表
USE order_db_2;
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) CHARACTER
SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
 PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER
SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

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) CHARACTER
SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
 PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER
SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

6.2 sharding配置

第一步：定义application-test2.properties环境配置：

# 1.首先我们需要知道数据库的数据源 （从哪来）
#数据源名称，多数据源以逗号分隔
spring.shardingsphere.datasource.names=ds1,ds2

#数据库连接池类名称
spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
#数据库驱动类名称
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库url连接
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://192.168.204.136:3306/order_db_1?serverTimezone=Asia/Shanghai&useSSL=false
#数据库用户名
spring.shardingsphere.datasource.ds1.username=root
#数据库密码
spring.shardingsphere.datasource.ds1.password=1234

#数据源名称，多数据源以逗号分隔
#数据库连接池类名称
spring.shardingsphere.datasource.ds2.type=com.alibaba.druid.pool.DruidDataSource
#数据库驱动类名称
spring.shardingsphere.datasource.ds2.driver-class-name=com.mysql.cj.jdbc.Driver
#数据库url连接
spring.shardingsphere.datasource.ds2.url=jdbc:mysql://192.168.204.136:3306/order_db_2?serverTimezone=Asia/Shanghai&useSSL=false
#数据库用户名
spring.shardingsphere.datasource.ds2.username=root
#数据库密码
spring.shardingsphere.datasource.ds2.password=1234

# 3.配置分库策略
common.algorithm.db=com.itheima.sharding.alg.Comm4Db
#分片列名称
spring.shardingsphere.sharding.tables.t_order.database-strategy.standard.sharding-column=user_id
#精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
spring.shardingsphere.sharding.tables.t_order.database-strategy.standard.precise-algorithm-class-name=${common.algorithm.db}
#范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
spring.shardingsphere.sharding.tables.t_order.database-strategy.standard.range-algorithm-class-name=${common.algorithm.db}

# 4.配置分片策略
common.algorithm.tb=com.itheima.sharding.alg.Comm4Tb
#分片列名称
spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.sharding-column=order_id
#精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.precise-algorithm-class-name=${common.algorithm.tb}
#范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.range-algorithm-class-name=${common.algorithm.tb}

通过阅读官方API，我们发现基于标准模式实现分库分表，需要分别为库和表定义精准查询和范围查询实现：

PreciseShardingAlgorithm ：精准查询库或者表（sql使用使用了= 、in）
RangeShardingAlgorithm ：范围查询库或者表 （between and 、 > 、 <）
所以，使用sharding-jdbc时尽量让分片键去查询，且遵循使用规范；

6.3 定义标准分库策略

与分表策略基本相同 因为都是实现同样的接口

package com.itheima.sharding.alg;

import com.google.common.collect.Range;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingValue;

import java.util.Collection;

/**
 * 定义精准查询数据库的算法类 接口中的泛型与数据库的片键类型一致
 *      select * from t_order where user_id = ?
 */
public class Comm4Db implements PreciseShardingAlgorithm<Long>, RangeShardingAlgorithm<Long> {
    /**
     * 实现分库的算法
     * @param collection 一切配置中可用的数据源集合：ds1,ds2    从这里获得[ds$->{1..2}.t_order_$->{1..2}]
     * @param preciseShardingValue 数据库对应分片键的值 ---> user_id
     * @return 返回一个具体的数据源名称
     */
    @Override
    public String doSharding(Collection<String> collection, PreciseShardingValue<Long> preciseShardingValue) {

        //获取逻辑表名称
        String logicTableName = preciseShardingValue.getLogicTableName();

        //1.获取分片键名称-->即数据库中列的名称 user_id
        String columnName = preciseShardingValue.getColumnName();

        //2.获取分片键的值
        Long value = preciseShardingValue.getValue();

        //3.根据分片键的值，计算出对应的数据源名称
        //   3.1 先计算出分片键的值对应的模数
        Long mod = value % 2 + 1;
        //   3.2 根据模数，从数据源集合中获取对应的数据源名称
        String dataSourceName = collection.stream().filter(dsName -> dsName.endsWith(mod+"")).findFirst().get();

        return dataSourceName;
    }

    /**
     *
     * @param collection 配置文件中的数据源集合 ds1 ds2
     * @param rangeShardingValue 分片值 即 BETWEEN user_id BETWEEN 1 AND 10
     * @return
     */
    @Override
    public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<Long> rangeShardingValue) {
        //获取逻辑表名
        String logicTableName = rangeShardingValue.getLogicTableName();
        //1.获取分片键名
        String shardingColumn = rangeShardingValue.getColumnName();
        //2.获取分片键值范围
        Range<Long> valueRange = rangeShardingValue.getValueRange();
        //3.根据分片键值范围，进行范围匹配
        if (valueRange.hasLowerBound()){//存在下限
            Long l = valueRange.lowerEndpoint();
        }
        if (valueRange.hasUpperBound()){//存在上限
            Long u = valueRange.upperEndpoint();
        }
        return collection;
    }
}

在主配置文件中激活test2环境：

# 应用名称
spring.application.name=sharding_all
#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis.mapper-locations=classpath:mappers/*xml
#指定Mybatis的实体目录
mybatis.type-aliases-package=com.sharding.inline.pojo
## 数据库驱动：
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 激活换将
spring.profiles.active=test2

6.4测试

    /**
     * 测试水平分库分表
     */
    @Test
   public void test2() {
        int orderId=0;
        int userId=0;
        Random random = new Random();
        for (int i = 0; i < 40; i++) {
            //保证随机生成奇数或者偶数
            orderId+=random.nextInt(2)+1;
            userId+=random.nextInt(2)+1;
            TOrder order = TOrder.builder().orderId(Long.valueOf(orderId))
                    .userId(Long.valueOf(userId))
                    .status("1")
                    .price(new BigDecimal(300))
                    .build();
            tOrderMapper.insert(order);
        }
    }

整体来看，sharding-jdbc配置分库分表的核心步骤：

1.配置数据源
2.配置逻辑表对应的数据节点
3.配置库的分片策略
4.配置表的分片策略

7、sharding-jdbc广播表

7.1 广播表介绍

• 广播表属于数据库中数据量较小和变动较少，且存在高频联合查询的表，比如：数据字典表等属于此广播表。
• 可以将这类表在每个数据库都保存一份，所有更新操作都同时发送到所有分库执行。

课堂广播表接口如下：

order_db_1
  ├── t_order_1
  └── t_order_2
  └── t_dict
order_db_2
  ├── t_order_1
  └── t_order_2  
  └── t_dict  

相关SQL:

#在数据库 user_db、order_db_1、order_db_2中均要建表
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;

7.2 广播表配置

在test2环境配置中添加：

# 指定t_dict为公共表，多个公共表以逗号间隔
spring.shardingsphere.sharding.broadcast‐tables=t_dict

7.3 测试广播表

    @Autowired
    private TDictMapper tDictMapper;
    
	@Test
    public void commonTable(){
        TDict build = TDict.builder().dictId(1l).code("666").type("1").value("888")
                .build();
        tDictMapper.insert(build);
    }

8、基于inline模式实现垂直分库

8.1 数据库准备

order_db_1
  ├── t_order_1
  └── t_order_2
  └── t_dict
order_db_2
  ├── t_order_1
  └── t_order_2  
  └── t_dict  
user_db
  └── t_user

SQL准备

#创建数据库
CREATE DATABASE `user_db` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
#建表
USE user_db;
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user` (
 `user_id` BIGINT (20) NOT NULL COMMENT '用户id',
 `fullname` VARCHAR (255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户姓名',
 `user_type` CHAR (1) DEFAULT NULL COMMENT '用户类型',
 PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = INNODB CHARACTER
SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

8.2 配置

我们可以水平分库分表的配置文件基础上添加如下配置：

# 数据库连接池类名称
spring.shardingsphere.datasource.ds3.type=com.alibaba.druid.pool.DruidDataSource
# 数据库驱动类名
spring.shardingsphere.datasource.ds3.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据库 url 连接
spring.shardingsphere.datasource.ds3.url=jdbc:mysql://192.168.188.130:3306/user_db?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai
# 数据库用户名
spring.shardingsphere.datasource.ds3.username=root
# 数据库密码
spring.shardingsphere.datasource.ds3.password=root

# 配置用户表信息
# 由数据源名 + 表名组成，以小数点分隔。多个表以逗号分隔，支持 inline 表达式。
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds3.t_user
# 分片列名称 在库和表直接定位时，分片键可以不指定
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column=user_id
# 分片算法行表达式，需符合 groovy 语法
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression=t_user

测试：

    @Test
    public void test04(){
        TUser user = TUser.builder().userId(133l).userType("1")
                .fullname("laozhang").build();
        tUserMapper.insert(user);
    }

9、默认数据源模式

如果没有配置分片策略，则可指定默认访问的数据源，也就是说只需指定数据源，无需指定数据节点、库和表的分片策略也无需执行；

如果在进行相关操作时，发现逻辑表没有对应的数据节点、库表的分片配置，则走默认指定的数据源；

![外链图片转存

初始化sql：

-- 构建数据
create database default_db character set utf8;
use default_db;
-- 构建表
create table tb_log (
    id bigint primary key ,
    info varchar(30)
);

相关配置：

# 配置shardingjdbc数据源
# 数据源名称，多数据源以逗号分隔
spring.shardingsphere.datasource.names=ds1,ds2,ds3,ds4
# 配置数据源参数
# 数据库连接池类名称
spring.shardingsphere.datasource.ds4.type=com.alibaba.druid.pool.DruidDataSource
# 数据库驱动类名
spring.shardingsphere.datasource.ds4.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据库 url 连接
spring.shardingsphere.datasource.ds4.url=jdbc:mysql://192.168.200.130:3306/default_db?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai
# 数据库用户名
spring.shardingsphere.datasource.ds4.username=root
# 数据库密码
spring.shardingsphere.datasource.ds4.password=root

# 配置默认数据源（特点：对于不做分片处理的操作，都会直接访问默认数据源
# 未配置分片规则的表将通过默认数据源定位
spring.shardingsphere.sharding.default-data-source-name=ds4

测试：

	/**
     * 测试默认数据源
     *  对于没有做分片处理的操作，则会直接访问默认数据源处理
     */
    @Test
    public void test5(){
        TbLog log = TbLog.builder().id(1l).info("这是一个测试").build();
        tbLogMapper.insert(log);
    }

g (
id bigint primary key ,
info varchar(30)
);

相关配置：

~~~properties
# 配置shardingjdbc数据源
# 数据源名称，多数据源以逗号分隔
spring.shardingsphere.datasource.names=ds1,ds2,ds3,ds4
# 配置数据源参数
# 数据库连接池类名称
spring.shardingsphere.datasource.ds4.type=com.alibaba.druid.pool.DruidDataSource
# 数据库驱动类名
spring.shardingsphere.datasource.ds4.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据库 url 连接
spring.shardingsphere.datasource.ds4.url=jdbc:mysql://192.168.200.130:3306/default_db?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=Asia/Shanghai
# 数据库用户名
spring.shardingsphere.datasource.ds4.username=root
# 数据库密码
spring.shardingsphere.datasource.ds4.password=root

# 配置默认数据源（特点：对于不做分片处理的操作，都会直接访问默认数据源
# 未配置分片规则的表将通过默认数据源定位
spring.shardingsphere.sharding.default-data-source-name=ds4

测试：

	/**
     * 测试默认数据源
     *  对于没有做分片处理的操作，则会直接访问默认数据源处理
     */
    @Test
    public void test5(){
        TbLog log = TbLog.builder().id(1l).info("这是一个测试").build();
        tbLogMapper.insert(log);
    }