文章目录

0. 前言
- 本文技术组件版本
- 基本介绍
2. 使用和配置：
3. 数据库分片配置
4. 数据路由
5. 数据库连接池
- - - 使用druid连接池
6. SQL执行引擎
7. 参考文档

0. 前言

Sharding-JDBC 是一款开源的分布式数据库中间件，主要目标是充分利用数据库的水平扩展能力，尽可能地避免改变已有的应用程序代码，简化分布式系统的开发难度。本文主要是使用sharding-jdbc 实现分库分表以及各种分库分表策略实战验证。

在学习本文之前建议先看下我之前写的两篇文章
《MySQL从入门到精通【进阶篇】MySQL分库分表详解》
《MySQL从入门到精通【进阶篇】MySQL的读写分离详解》

本文技术组件版本

> spring-boot 2.7.15
> jdk 1.8
> mybatis-plus-boot-starter 3.5.3.2 最新版
> mysql  8.0
> sharding-jdbc 4.0.1

基本介绍

分库分表是一种常见的数据库扩展策略，它通过将数据分散到多个数据库或表中，来提高系统的性能和可扩展性。然而，实现分库分表并不简单，它涉及到数据的路由、SQL的改写、结果的合并等一系列复杂的问题。其实我们也不需要自己造轮子，因为已经有一批优秀的开源组件满足了我们的基本需求。
最著名的组件MyCAT大家肯定若有耳闻。MyCAT 它提供了包括分库分表、读写分离、高可用等在内的一系列功能。MyCAT是基于Java开发的，可以透明地将多个MySQL数据库合并为一个逻辑数据库。而本章节我们要讲的是国内比较牛逼的ShardingSphere团队开发的Sharding-JDBC。后来加入了Apache 项目。

目前Sharding-JDBC是Apache ShardingSphere项目的一部分，它是一个在Java的JDBC层提供额外服务的轻量级框架，可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。使用Sharding-JDBC，我们可以轻松地实现MySQL的分库分表，而无需修改业务代码。

本文，我们将深入探讨如何使用Sharding-JDBC实现MySQL的分库分表。我们将从Sharding-JDBC的基本概念和原理开始，然后通过实际的示例和代码，详细介绍如何配置和使用Sharding-JDBC。无论你是菜鸟，还是有一定数据库经验的开发者，我相信你都能从这篇文章中也能get到一些有用的知识。

2. 使用和配置：

demo工程的目录结构如下
在这里插入图片描述

步骤1 引入依赖

在pom.xml中添加Sharding-JDBC的依赖。

<?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.7.15</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.icepip</groupId>
	<artifactId>springBoot-icepip-sharding-jdbc</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springBoot-icepip-sharding-jdbc</name>
	<description>springBoot-icepip-sharding-jdbc</description>
	<properties>
		<java.version>1.8</java.version>
		<mysql.version>8.0.13</mysql.version>
		<sharding-sphere.version>4.0.1</sharding-sphere.version>
		<mybatis-plus-boot-starter.version>3.5.3.2</mybatis-plus-boot-starter.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.apache.shardingsphere</groupId>
			<artifactId>sharding-jdbc-spring-boot-starter</artifactId>
			<version>${sharding-sphere.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>${mybatis-plus-boot-starter.version}</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

步骤2 配置数据源和分片策略

在application.properties中配置数据源和分片规则。

server.port=8098

management.health.db.enabled=false

spring.shardingsphere.datasource.names=ds0,ds1,ds2
logging.level.root=trace # 专门搞成trace 我们可以看到 SQL 解析、路由计算、SQL 改写和 SQL 执行

spring.shardingsphere.datasource.ds0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds0.jdbc-url=jdbc:mysql://172.20.6.xx:3306/icepip_demo0?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&verifyServerCertificate=false&autoReconnct=true&autoReconnectForPools=true&allowMultiQueries=true
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=password

spring.shardingsphere.datasource.ds1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds1.jdbc-url=jdbc:mysql://172.20.6.xx:3306/icepip_demo1?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&verifyServerCertificate=false&autoReconnct=true&autoReconnectForPools=true&allowMultiQueries=true
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=password

spring.shardingsphere.datasource.ds2.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds2.jdbc-url=jdbc:mysql://172.20.6.xx:3306/icepip_demo2?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&characterSetResults=utf8&useSSL=false&verifyServerCertificate=false&autoReconnct=true&autoReconnectForPools=true&allowMultiQueries=true
spring.shardingsphere.datasource.ds2.username=root
spring.shardingsphere.datasource.ds2.password=password


# 设置分库策略为内联分片策略，分片列为user_id
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id

# 设置分库策略算法表达式，根据user_id的值取模3得到分库后缀，拼接到ds前面作为数据源名 因为我上面是3个库所以与3取模，实际根据分片库的数量配置
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds$->{
    
    user_id % 3}

# 设置t_order表的实际数据节点，实际数据节点由数据源名和表名组成
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{
    
    0..2}.t_order$->{
    
    0..1}

# 设置t_order表的内联分片策略，分片列为order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id

# 设置t_order表的主键生成器列为order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id

# 设置t_order表的主键生成器类型为雪花算法
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE

# 设置t_order表的内联分片策略算法表达式，根据order_id的值取模2得到分片后缀，拼接到t_order前面作为表名
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order$->{
    
    order_id % 2}

# 设置默认数据源名称为ds0
spring.shardingsphere.sharding.default-data-source-name=ds0

# 设置显示SQL语句
spring.shardingsphere.props.sql.show=true

# 允许覆盖Bean定义
spring.main.allow-bean-definition-overriding=true


# mybatis-plus
mybatis-plus.mapper-locations=classpath:/mapper/*.xml
mybatis-plus.configuration.jdbc-type-for-null='null'

步骤3 核心代码

在项目中使用JdbcTemplate或者JPA等方式进行数据库操作，Sharding-JDBC会自动进行分片。

MybatisPlusConfig 核心配置

package com.icepip.shardingjdbc.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.BlockAttackInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.actuate.jdbc.DataSourceHealthIndicator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;


/**
 * Mybatis-plus 全局拦截器
 * 可通过开关选择启用不同作用的全局拦截器 {@see MybatisPlusConfig}
 *
 * @author 冰点
 * @date 2022-06-23 2:13 PM
 */
@Configuration
@Slf4j
public class MybatisPlusConfig {
    
    

    @Value("${icepip.mybatis-plus-ext.db-key.enable:false}")
    private boolean dbKeyEnable;

    @Value("${icepip.datasource.dynamic.primary:ds0}")
    private String primaryCode;

    @Value("${icepip.mybatis-plus-ext.db-key:ds0}")
    private String dbKey;

    @Value("${icepip.mybatis-plus-ext.pagination-interceptor.enable:true}")
    private boolean paginationInterceptorEnable;

    @Value("${icepip.mybatis-plus-ext.optimistic-Locker.enable:true}")
    private boolean optimisticLockerEnable;

    @Value("${icepip.mybatis-plus-ext.sql-attack-interceptor.enable:false}")
    private boolean sqlAttackInterceptorEnable;

    @Value("${icepip.mybatis-plus-ext.tenant-interceptor.enable:true}")
    private boolean tenantEnable;

    @Bean
    public DataSourceHealthIndicator dataSourceHealthIndicator(DataSource dataSource) {
    
    
        return new DataSourceHealthIndicator(dataSource, "select 1");
    }

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
    
    
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        if (optimisticLockerEnable) {
    
    
            interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
            log.info("已开启乐观锁校验[当要更新一条记录的时候，希望这条记录没有被别人更新]，被@version字段修饰的字段为乐观锁字段，此必须要有默认值或初始值");
        }
        if (sqlAttackInterceptorEnable) {
    
    
            interceptor.addInnerInterceptor(new BlockAttackInnerInterceptor());
            log.info("已开启危险SQL拦截[由于开启了直接输入sql操作数据库，防止误操作]，危险SQL拦截判断规则详见@see BlockAttackInnerInterceptor");
        }
        if (tenantEnable) {
    
    
            // 已简化
            log.info("已开启多租户模式，默认项目id为租户id");
        }
        if (paginationInterceptorEnable) {
    
    
            PaginationInnerInterceptor innerInterceptor = new PaginationInnerInterceptor();
            innerInterceptor.setOptimizeJoin(false);
            interceptor.addInnerInterceptor(innerInterceptor);
            log.info("已开启自动分页插件，如果返回类型是 IPage 则入参的 IPage 不能为null,因为 返回的IPage == 入参的IPage，如果返回类型是 List 则入参的 IPage 可以为 null(为 null 则不分页),但需要你手动入参的IPage.setRecords(返回的 List)");
        }

        return interceptor;
    }


}

OrderService

package com.icepip.shardingjdbc.service;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.icepip.shardingjdbc.model.OrderInfo;

import java.io.Serializable;

public interface OrderService extends IService<OrderInfo> {
    
    

    @Override
    boolean save(OrderInfo entity);

    @Override
    boolean removeById(Serializable id);

    @Override
    boolean updateById(OrderInfo entity);

    IPage<OrderInfo> page(Page<?> page, OrderInfo orderInfo);

}

OrderServiceImpl

package com.icepip.shardingjdbc.service;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.icepip.shardingjdbc.mapper.OrderMapper;
import com.icepip.shardingjdbc.model.OrderInfo;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;

@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, OrderInfo> implements OrderService {
    
    



    @Override
    public boolean save(OrderInfo entity) {
    
    
        return super.save(entity);
    }

    @Override
    public boolean removeById(Serializable id) {
    
    
        return super.removeById(id);
    }

    @Override
    public boolean updateById(OrderInfo entity) {
    
    
        return super.updateById(entity);
    }


    @Override
    public IPage<OrderInfo> page(Page<?> page, OrderInfo orderInfo) {
    
    
        Map<String, Object> map = new HashMap<>();
        map.put("userId", orderInfo.getUserId());
        map.put("orderId", orderInfo.getOrderId());
        map.put("orderName", orderInfo.getOrderName());
        map.put("orderStatus", orderInfo.getOrderStatus());
        page.addOrder(new OrderItem("order_id",false));
        return super.baseMapper.selectAllByCondition(page, map);
    }
}

OrderInfo

package com.icepip.shardingjdbc.model;


import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("t_order")
public class OrderInfo {
    
    

    @TableId(value = "order_id")
    private Long orderId;

    @TableField(value = "order_name")
    private String orderName;

    @TableField(value = "order_status")
    private Integer orderStatus;

    @TableField(value = "user_id")
    private Long userId;

}

OrderMapper

package com.icepip.shardingjdbc.mapper;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.icepip.shardingjdbc.base.BaseMapper;
import com.icepip.shardingjdbc.model.OrderInfo;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.Map;

@Mapper
public interface OrderMapper extends BaseMapper<OrderInfo> {
    
    

    IPage<OrderInfo> selectAllByCondition(Page<?> page, @Param("condition") Map<String, Object> condition);

    int deleteById(@Param("condition")Map<String, Object> condition);

}

OrderController

package com.icepip.shardingjdbc.controller;


import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.icepip.shardingjdbc.model.OrderInfo;
import com.icepip.shardingjdbc.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/order")
public class OrderController {
    
    

    @Autowired
    private OrderService orderService;

    @PostMapping("add")
    public boolean save(@RequestBody OrderInfo orderInfo) {
    
    
        return orderService.save(orderInfo);
    }

    @DeleteMapping("/{orderId}")
    public boolean deleteById(
            @PathVariable("orderId")
            Long id) {
    
    
        return orderService.removeById(id);
    }

    @PutMapping("/{orderId}")
    public boolean updateById(
            @PathVariable("orderId")
            Long orderId,
            @RequestBody OrderInfo orderInfo) {
    
    
        orderInfo.setOrderId(orderId);
        return orderService.updateById(orderInfo);
    }

    @GetMapping("/page")
    public IPage page(
            @RequestParam(name = "pageNum", required = false, defaultValue = "1")
                    Integer pageNum,
            @RequestParam(name = "pageSize", required = false, defaultValue = "10")
                    Integer pageSize,
            @RequestParam(name = "orderId", required = false)
            Long orderId,
            @RequestParam(name = "orderStatus", required = false)
            Integer orderStatus,
            @RequestParam(name = "orderName", required = false)
            String orderName) {
    
    
        Page<OrderInfo> page = new Page<>(pageNum,pageSize);
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setOrderId(orderId);
        orderInfo.setOrderName(orderName);
        orderInfo.setOrderStatus(orderStatus);
        return orderService.page(page, orderInfo);
    }
}

BaseMapper

package com.icepip.shardingjdbc.base;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;

import java.util.Map;

public interface BaseMapper<T> extends com.baomidou.mybatisplus.core.mapper.BaseMapper<T> {
    
    

    IPage<T> selectAllByCondition(Page<?> page, @Param("condition")Map<String, Object> condition);

    int deleteById(@Param("condition")Map<String, Object> condition);

}

<?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.icepip.shardingjdbc.mapper.OrderMapper">

    <sql id="Base_Column_List">
        order_id, order_name, order_status, user_id
    </sql>

    <select id="selectAllByCondition" resultType="com.icepip.shardingjdbc.model.OrderInfo">
        select
        <include refid="Base_Column_List"/>
        from
        t_order
        <where>
            <if test="condition.userId != null">
                and user_id = #{condition.userId, jdbcType=BIGINT}
            </if>
            <if test="condition.orderId != null">
                and order_id = #{condition.orderId, jdbcType=BIGINT}
            </if>
            <if test="condition.orderName != null and condition.orderName != ''">
                and order_name like concat('%',#{condition.orderName,jdbcType=VARCHAR} ,'%')
            </if>
            <if test="condition.orderStatus != null">
                and order_status = #{condition.orderStatus, jdbcType=INTEGER}
            </if>
        </where>
    </select>

    <delete id="deleteById">
        delete from t_order where order_id = #{condition.orderId, jdbcType=BIGINT} and user_id = #{condition.userId, jdbcType=BIGINT}
    </delete>

</mapper>

3. 数据库分片配置

Sharding-JDBC 提供了强大的数据分片能力，可以根据业务规则将数据分散到多个数据库或表中，提高数据处理能力。

分片策略：如根据某字段的值进行取模分片等

分片算法：如内置的基于取模的分片算法、基于范围的分片算法等

Sharding-JDBC的数据分片功能使得对海量数据的管理和查询更加高效。通过将数据分散到多个数据库或表中，可以避免数据量过大导致的系统性能下降，提高系统的查询和处理速度。
例如，如果业务数据主要根据用户ID进行查询，那么可以选择用户ID作为分片键，然后根据用户ID的值进行取模操作，将数据均匀分散到不同的数据库或表中。

在我的demo工程中大家可以看到如下的配置

设置分库策略为内联分片策略，分片列为user_id.设置分库策略算法表达式，根据user_id的值取模3得到分库后缀，拼接到ds前面作为数据源名因为我上面是3个库所以与3取模，实际根据分片库的数量配置
我是三个库。
在这里插入图片描述

在这里插入图片描述

3.1 表的分片策略

Sharding-JDBC支持各种分片策略，比如单键分片、复合键分片等。开发者可以根据业务需求选择合适的分片策略。

在这里插入图片描述
这是对Apache ShardingSphere的配置进行解析：

spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds$->{0..2}.t_order$->{0..1}
设置数据分片的逻辑表和实际数据节点。逻辑表是t_order，实际数据节点是ds0.t_order0、ds0.t_order1、ds1.t_order0、ds1.t_order1、ds2.t_order0、ds2.t_order1，其中ds表示数据源。
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
设置分片策略的列，这里order_id列作为分片依据。
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id 和 spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
设置主键生成策略，这里使用的是雪花算法（Snowflake）生成order_id字段的主键。
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order$->{order_id % 2}
设置分片策略的算法表达式，这里通过order_id的值取模2的结果作为分片后缀，拼接到t_order前面作为表名。

3.2 分片算法

其实Sharding-JDBC内置了多种分片算法，比如基于取模的分片算法、基于范围的分片算法、基于哈希的分片算法等。取模分片算法是一种简单而常用的分片算法，适用于数据量大并且分布比较均匀的场景；范围分片算法适用于数据在分片键上的分布不均匀的场景，可以通过指定分片键的范围来进行分片；哈希分片算法则适用于数据量特别大的场景，通过对分片键进行哈希运算，可以将数据均匀地分散到各个数据库或表中。
ShardingSphere提供了多种内置的分片策略，

标准分片策略（StandardShardingStrategy）：适用于分片键的值具有明确的分片逻辑，例如：偶数分到一个分片，奇数分到另一个分片。
复合分片策略（ComplexShardingStrategy）：适用于多个分片键之间存在复杂关系的场景。
Hint分片策略（HintShardingStrategy）：适用于分片键的值无法从SQL中直接获取，需要应用通过Hint API提供。
类型分片策略（ClassBasedShardingStrategy）：适用于分片键的值需要通过自定义算法进行分片。
范围分片策略（RangeShardingStrategy）：适用于分片键的值具有范围关系的场景。

对我们上面的需求也可以使用范围分片策略。我们定义了一个名为range_order_id的范围分片算法，它将order_id字段的值除以1024，然后将结果用于确定分片。

sharding.jdbc.config.sharding.tables.t_order.table-strategy.range.sharding-column=order_id
sharding.jdbc.config.sharding.tables.t_order.table-strategy.range.sharding-algorithm-name=range_order_id
sharding.jdbc.config.sharding.sharding-algorithms.range_order_id.type=RANGE
sharding.jdbc.config.sharding.sharding-algorithms.range_order_id.props.algorithm-expression=ds${order_id / 1024}

3.3. 自定义分片算法

3.3.1. 自定义算法类实现

假设我们想根据订单的创建时间进行分片。我们可以选择按照年份进行分片，即每年的数据存储在一个分片中。这样，我们可以创建一个自定义的分片算法，其实也可以用表达式处理。

package com.icepip.shardingjdbc.config;

import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;

import java.util.Calendar;
import java.util.Collection;
import java.util.Date;

/**
 *  自定义分片策略
 * @author 冰点
 * @version 1.0.0
 * @date 2023/9/5 14:52
 */

public class OrderTableShardingAlgorithm implements PreciseShardingAlgorithm<Date> {
    
    

    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Date> shardingValue) {
    
    
        Date orderCreateTime = shardingValue.getValue();
        int year = getYear(orderCreateTime);

        for (String each : availableTargetNames) {
    
    
            if (each.endsWith(year + "")) {
    
    
                return each;
            }
        }

        throw new IllegalArgumentException();
    }

    private int getYear(Date date) {
    
    
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }
}

sharding:
  tables:
    t_order:
      actual-data-nodes: ds${
    
    0..1}.t_order_${
    
    0..9}
      table-strategy:
        standard:
          sharding-column: create_time
          precise-algorithm-class-name: com.yourpackage.OrderTableShardingAlgorithm

t_order是逻辑表名，ds${0..1}.t_order_${0..9}表示实际的数据节点，create_time是分片列，com.yourpackage.OrderTableShardingAlgorithm是你自定义的分片算法类。

3.3.2. 自定义表达式实现

如果我们不使用自定义算法类也是可以实现的。需要配置表达式去解析。这种方式需要数据库支持在SQL中直接使用Java的日期时间函数，否则可能会出现错误。如果数据库不支持，那么还是需要写自定义的分片策略。

我们首先获取订单的创建时间，然后提取出年份。然后，我们遍历所有的可用的目标表名，如果表名的后缀与年份匹配，那么我们就选择这个表作为目标表。

 
sharding.jdbc.config.sharding.tables.t_order.actual-data-nodes=ds${0..1}.t_order_${2018..2023}
sharding.jdbc.config.sharding.tables.t_order.table-strategy.standard.sharding-column=create_time
sharding.jdbc.config.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name=orderTableShardingAlgorithm
sharding.jdbc.config.sharding.sharding-algorithms.orderTableShardingAlgorithm.type=INLINE
sharding.jdbc.config.sharding.sharding-algorithms.orderTableShardingAlgorithm.props.algorithm-expression=t_order_${create_time.toInstant().atZone(ZoneId.systemDefault()).toLocalDate().getYear()}

在这里插入图片描述

sharding.jdbc.config.sharding.tables.t_order.table-strategy.standard.sharding-algorithm-name定义了分片算法的名称。
sharding.jdbc.config.sharding.sharding-algorithms.orderTableShardingAlgorithm.type定义了分片算法的类型，sharding.jdbc.config.sharding.sharding-algorithms.orderTableShardingAlgorithm.props.algorithm-expression定义了分片的表达式。
当你插入一个新的订单时，ShardingSphere会根据订单的创建时间来选择一个分片进行存储。

4. 数据路由

Sharding-JDBC 在处理业务请求时，能够根据分片规则自动路由到对应的数据库或表，无需开发者关注底层数据存储细节。
数据路由的过程主要分为四个步骤：SQL 解析、路由计算、SQL 改写和 SQL 执行。

SQL 解析：Sharding-JDBC 首先对 SQL 语句进行解析，得到抽象语法树（AST），并提取出路由条件。
路由计算：通过使用分片键和分片算法，结合解析出的路由条件，计算出 SQL 语句需要访问的目标数据库和表。
SQL 改写：根据路由结果，对原始 SQL 语句进行改写，将全局表和分片表替换为真实的物理表。
SQL 执行：最后，将改写后的 SQL 语句发送到目标数据库执行。

这四个步骤完全由 Sharding-JDBC 自动完成，开发者只需配置好分片规则，即可做到数据的水平切分和分布式访问，大大简化了开发工作。

我们可以通过日志看到SQL改写。我故意加了一些order by 排序想看下
sharding-jdbc改写后的结果，发现它是在每个库和每个表都执行了此sql 然后在内存中在做排序。

在这里插入图片描述

具体的执行过程

首先，Sharding-JDBC会解析SQL，提取出表名、列名、条件、排序字段等关键信息。

Sharding-JDBC会进行SQL路由。根据分片策略，它会计算出SQL语句需要执行的具体的数据库和数据表。

然后，Sharding-JDBC会对原始的SQL语句进行改写。这一步中，它会将逻辑表名替换为实际的物理表名，并根据分片键将查询条件拆分为多个子查询。同时，它还会在每个子查询中添加相应的排序和分页条件。

并行查询：改写后的SQL语句会被并行发送到对应的数据库执行。每个数据库会返回一个结果集。

结果合并：在内存中，Sharding-JDBC会将来自不同数据库的结果集进行合并。首先，它会按照排序字段对所有结果进行排序。然后，它会根据分页条件，取出需要的部分数据返回给客户端。

例如，原始的SQL

SELECT * FROM t_order ORDER BY order_id DESC LIMIT 10 OFFSET 20

如果t_order表按照order_id字段分片，存储在两个数据库的t_order_0和t_order_1两个表中，那么改写后的SQL可能会是：

SELECT * FROM t_order_0 ORDER BY order_id DESC LIMIT 30
SELECT * FROM t_order_1 ORDER BY order_id DESC LIMIT 30

这两条SQL会并行在各自的数据库中执行，然后Sharding-JDBC会将两个结果集合并，按照order_id进行排序，取出第21到30条记录返回给客户端。

大家有没有思考过在上述分库分表的例子中，我们的原始查询是希望取出排序后的第21到30条记录，也就是希望取出10条记录，但在改写后的SQL中我们却对每个子查询使用了LIMIT 30，这是为什么呢？

这是因为在分库分表的情况下，数据是分散在不同的数据库和表中的。当我们需要对数据进行排序并取出一部分数据时，我们不能保证每个子查询都能贡献出足够的数据。

比如在我们的例子中，我们希望取出排序后的第21到30条记录。如果我们直接对每个子查询使用LIMIT 10 OFFSET 20，那么有可能某个子查询返回的数据不足10条（比如只返回了5条），这样合并后的结果集就不足10条了。为了避免这种情况，我们需要让每个子查询返回更多的数据，比如返回前30条数据，这样即使某个子查询的数据不足，我们也有可能从其他子查询中获取到足够的数据。

我只是做了一个示例，这只是一种简化的做法，实际上Sharding-JDBC在处理这种情况时会更加复杂和智能。

通常复杂查询Sharding-jdbc的处理方式

1. 分页查询

如上面我们举的例子。在分库分表的环境中，处理分页查询和排序查询会相对比较复杂。因为数据分散在不同的库和表中，我们不能直接使用LIMIT和OFFSET关键词进行分页。Sharding-JDBC更新的方法是对每个子查询使用改写后的LIMIT和OFFSET值，然后在内存中对所有的结果进行合并和排序。

2. 聚合查询

类似的，对于COUNT()、SUM()、AVG()等聚合函数，Sharding-JDBC也会对每个子查询进行聚合操作，然后在内存中对所有的结果进行二次聚合。比如，对于COUNT()函数，Sharding-JDBC会将各个子查询的结果加起来；对于AVG()函数，Sharding-JDBC会将所有子查询的SUM()结果相加，然后除以所有子查询的COUNT()结果相加得到的数。

3. 子查询和关联查询

如果SQL中涉及到子查询或者关联查询，比如JOIN、IN等，相对来说也是很复杂的。但是Sharding-JDBC也能正确地处理。它会将包含子查询或关联查询的复杂SQL，逐步拆解成单表查询，然后逐一进行执行，最后在内存中对所有的结果进行合并。我们举一个简单的实力理解一下。
假设我们在一个电商系统中有两张分表，users(用户表)和orders(订单表)，并且它们根据用户ID(user_id)进行了分片。

例如，下面是一个包含子查询的SQL语句。我们的需求是查询希望找到所有订单总金额大于1000的用户。 Sharding-JDBC会按以下方式处理：

原始SQL

SELECT * FROM users WHERE user_id IN (SELECT user_id FROM orders WHERE total_amount > 1000);

Sharding-JDBC会解析这个SQL，找到主查询和子查询，然后分别进行路由。因为orders表按照user_id进行了分片，所以子查询可能要在多个表中进行。主查询中的users表也是根据user_id分片的，因此路由结果可能会涉及多个表。

对于主查询和子查询，Sharding-JDBC会逐一改写并执行。对于子查询，Sharding-JDBC会在每个orders表中执行该查询，找到所有订单总金额大于1000的用户。
得到的user_id将用于主查询。在每个改写过的users表中执行主查询，找出对应的用户记录。

结果合并 Sharding-JDBC会将来自不同表的查询结果进行合并，组成一个统一的结果集返回。

所以我们再开发过程尽量避免子查询和join 查询。

4. 跨库事务

在分库分表的环境中，实现横跨多个数据库的事务是一件挑战性的工作。通常的做法是借助某种分布式事务协议，如XA或者TCC。Sharding-JDBC通过整合开源分布式事务框架Seata，提供了对XA事务的支持。这个我们后续再专门来讲一下，如何集成实现。

5. 数据库连接池

Sharding-JDBC 支持多种流行的数据库连接池，如 HikariCP、Druid 等。可以对每个物理数据库设置独立的连接池。
如果你想使用Druid作为连接池，你可以按照以下方式进行配置：
我的示例里面使用的是hikari连接池 ,此处不做详解，下面是使用Druid 的示例。

使用druid连接池

spring.shardingsphere.datasource.names=ds0,ds1

spring.shardingsphere.datasource.ds0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds0.url=jdbc:mysql://localhost:3306/ds0
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=123456

spring.shardingsphere.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds1.url=jdbc:mysql://localhost:3306/ds1
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=123456

在项目中使用了Spring Boot的starter for Druid（spring-boot-starter-data-druid），也可以额外配置Druid的一些属性，例如初始连接数、最小空闲连接数、最大活动连接数等。这些配置可以通过spring.shardingsphere.datasource.ds0.druid.*进行。

6. SQL执行引擎

Sharding-JDBC 对 SQL 语句进行解析、改写和执行，能够支持绝大部分的 SQL 语法，包括对联表查询、子查询、分页查询等复杂 SQL 的支持。这个我们已经在数据路由中已经详细讲解，此处就不做详解，大家只需要知道Sharding-jdbc的组成核心部分有SQL执行引擎，以及他的主要作用。

7. 参考文档

本文参考了以下文档

Sharding-JDBC GitHub：https://github.com/apache/shardingsphere
Sharding-JDBC官方文档包括了Sharding-JDBC的安装、配置和使用方法，以及一些高级话题，比如分片策略、SQL支持等。
Sharding-JDBC API文档对于开发者来说是一个非常有用的参考资源。
Sharding-JDBC示例项目：https://github.com/apache/shardingsphere-example

在这里插入图片描述

MySQL从入门到精通【实践篇】之使用Sharding-JDBC 分库分表详解

文章目录

0. 前言

本文技术组件版本

基本介绍

2. 使用和配置：

步骤1 引入依赖

步骤2 配置数据源和分片策略

步骤3 核心代码

MybatisPlusConfig 核心配置

OrderService

OrderServiceImpl

OrderInfo

OrderMapper

OrderController

BaseMapper

3. 数据库分片配置

在我的demo工程中大家可以看到如下的配置

3.1 表的分片策略

3.2 分片算法

3.3. 自定义分片算法

3.3.1. 自定义算法类实现

3.3.2. 自定义表达式实现

4. 数据路由

具体的执行过程

通常复杂查询Sharding-jdbc的处理方式

1. 分页查询

2. 聚合查询

3. 子查询和关联查询

4. 跨库事务

5. 数据库连接池

使用druid连接池

6. SQL执行引擎

7. 参考文档

猜你喜欢