07、Sharding-JDBC 实战；SpringBoot整合Sharding-JDBC通过混合分片策略(Complex)实现分表操作-6ren

07、Sharding-JDBC 实战；SpringBoot整合Sharding-JDBC通过混合分片策略(Complex)实现分表操作

转载作者：大佬之路更新时间：2024-01-07 12:56:23

1、SpringBoot基础配置

框架搭建：SpringBoot + HikariCP/Druid + Mybatis + Mysql+sharding-jdbc

1、POM依赖：

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

2、配置允许数据源覆盖
properties文件加入以下配置

# 允许数据源覆盖
spring.main.allow-bean-definition-overriding=true

3、数据源配置
数据源类型通常选择DruidDataSource或者HikariDataSource两者在配置上有所不同。

DruidDataSource

  <!-- 不能使用druid-spring-boot-starter，会导致：Property 'sqlSessionFactory' or 'sqlSessionTemplate' are required -->
   <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid</artifactId>
     <version>version</version>
   </dependency>

 com.alibaba.druid.pool.DruidDataSource
 DruidDataSource需要引入druid的Jar包，使用：url
  spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
  spring.shardingsphere.datasource.m1.url=

HikariDataSource

 com.zaxxer.hikari.HikariDataSource
 HikariDataSource要使用：jdbc-url
  spring.shardingsphere.datasource.m1.type=com.zaxxer.hikari.HikariDataSource
  spring.shardingsphere.datasource.m1.jdbc-url=

2、创建表

将用户(user)表，进行水平分表，分为：user_1,user_2 .... user_6

//创建数据表
CREATE TABLE user_1/user_2/..../user_6 (
    id BIGINT(20) NOT NULL COMMENT 'Id',
    name VARCHAR(20) NOT NULL COMMENT '名称',
    phone VARCHAR(20) NOT NULL COMMENT '电话',
    email VARCHAR(20) NOT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
)

3、完整properties配置

server.port=9090
server.servlet.context-path=/demo
spring.application.name=sharding-jdbc-simple-demo
# 允许数据源覆盖
spring.main.allow-bean-definition-overriding=true
# MyBatis配置
# 搜索指定包别名
mybatis.typeAliasesPackage=com.lhz.sharding.model.entity
# 配置mapper的扫描，找到所有的mapper.xml映射文件
mybatis.mapperLocations=classpath*:mybatis/**/*.xml
#数据库类型
mybatis.configuration.database-id=mysql
#自动驼峰转换
mybatis.configuration.map-underscore-to-camel-case=true
#pagehelper  分页插件
pagehelper.helper-dialect=mysql
pagehelper.reasonable=false
pagehelper.support-methods-arguments=true
pagehelper.params=count=countSql

#sharding-jdbc 水平分表规则配置，使用complex模式
# 数据源名称，多数据源逗号隔开
spring.shardingsphere.datasource.names=m1
spring.shardingsphere.datasource.m1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.m1.jdbc-url=jdbc:mysql://127.0.0.1:3307/shardingjdbc?useUnicode=true&useSSL=false&zeroDateTimeBehavior=convertToNull&characterEncoding=UTF-8&allowMultiQueries=true&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.m1.username=root
spring.shardingsphere.datasource.m1.password=lhzlx
# 水平分表：user_1/2/3..，多个表进行分表时，依次在tables标签后写逻辑
# user_1/2/3... 为数据库中的事实表
# user为xml编码中操作的逻辑表，sharding-jdbc会自动根据策略操作事实表
# 配置节点分布情况，表示有user_1到user_6共6张表
spring.shardingsphere.sharding.tables.user.actual-data-nodes=m1.user_$->{1..6}
# 指定user表的主键生成策略为SNOWFLAKE
spring.shardingsphere.sharding.tables.user.key-generator.column=id
spring.shardingsphere.sharding.tables.user.key-generator.type=SNOWFLAKE

# 指定user表的分片策略，分片策略包括分片键和分片算法
# 配置表的分片策略
spring.shardingsphere.sharding.tables.user.table-strategy.complex.sharding-columns=id
# 复合分片算法
spring.shardingsphere.sharding.tables.user.table-strategy.complex.algorithm-class-name=\
  com.lhz.sharding.algorithm.MyComplexKeysShardingAlgorithm
# 打开sql输出日志
spring.shardingsphere.props.sql.show=true

4、分片算法

混合分片策略，支持多个分片健操作，并且集成了精确匹配与范围匹配查询，具体处理逻辑如下代码

MyComplexKeysShardingAlgorithm：

import com.google.common.collect.Range;
import org.apache.shardingsphere.api.sharding.complex.ComplexKeysShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.complex.ComplexKeysShardingValue;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
 * @Description:
 **/
public class MyComplexKeysShardingAlgorithm implements ComplexKeysShardingAlgorithm<Long> {
   
     
    /**
     * @param tbNames                  数据库中所有的事实表
     * @param complexKeysShardingValue 分片相关信息
     * @return
     */
    @Override
    public Collection<String> doSharding(Collection<String> tbNames, ComplexKeysShardingValue<Long> complexKeysShardingValue) {
   
     

        String logicTableName = complexKeysShardingValue.getLogicTableName();

        // 获取范围查询匹配的值
        Range<Long> range = this.getRangeValue(complexKeysShardingValue, "id");
        if (range != null) {
   
     
            // between and 的起始值，需要处理只有最大值或者只有最小值的情况
            boolean hasLowerBound = range.hasLowerBound();
            boolean hasUpperBound = range.hasUpperBound();

            // 只有最小值，比如：id > x
            if (hasLowerBound && !hasUpperBound) {
   
     
                // 直接返回所有表名称
                return tbNames;
            }

            // 只有最大值，比如：id < x
            if (!hasLowerBound && hasUpperBound) {
   
     
                long upper = range.upperEndpoint();
                if (upper < tbNames.size()) {
   
     
                    // 如果最大值小于表的总数，则返回需要的表名
                    return matchMinAndMax(1, upper, logicTableName, tbNames);
                } else {
   
     
                    // 如果最大值大于表的总数，则返回所有
                    return tbNames;
                }
            }

            // 区间值情况
            long lower = range.lowerEndpoint();
            long upper = range.upperEndpoint();

            // 拼接事实表名称
            return matchMinAndMax(lower, upper, logicTableName, tbNames);
        }

        // 得到每个分片健对应的值，如果有多个则取多个实现相应逻辑即可
        Collection<Long> ids = this.getShardingValue(complexKeysShardingValue, "id");

        // 先按原有方式处理，注意 IN的情况，是不是返回多个对象
        List<String> tableNameList = new ArrayList<>();
        for (Long id : ids) {
   
     
            long tableNum = id % tbNames.size();
            // 事实表后缀
            String suffix = String.valueOf(tableNum == 0 ? tableNum + 6 : tableNum);
            String tableName = logicTableName + "_" + suffix;
            if (tbNames.contains(tableName)) {
   
     
                // 添加满足要求的表名称
                tableNameList.add(tableName);
            }

            // 如果满足要求的表已经覆盖了所有表，此处处理是为了方式查询区间过大，而分表不多，导致的过度遍历
            if (tableNameList.size() == tbNames.size()) {
   
     
                return tableNameList;
            }
        }
        return tableNameList;
    }

    private Collection<Long> getShardingValue(ComplexKeysShardingValue<Long> shardingValues, final String column) {
   
     
        Collection<Long> valueSet = new ArrayList<>();
        // 匹配分片字段
        Map<String, Collection<Long>> columnNameAndShardingValuesMap = shardingValues.getColumnNameAndShardingValuesMap();
        if (columnNameAndShardingValuesMap.containsKey(column)) {
   
     
            valueSet.addAll(columnNameAndShardingValuesMap.get(column));
        }
        return valueSet;
    }

    private Range<Long> getRangeValue(ComplexKeysShardingValue<Long> shardingValues, final String column) {
   
     
        // 匹配分片字段
        Map<String, Range<Long>> columnNameAndRangeValuesMap = shardingValues.getColumnNameAndRangeValuesMap();
        if (columnNameAndRangeValuesMap.containsKey(column)) {
   
     
            return columnNameAndRangeValuesMap.get(column);
        }
        return null;
    }

    private List<String> matchMinAndMax(long lower, long upper, String logicTableName, Collection<String> tbNames) {
   
     
        List<String> tableNameList = new ArrayList<>();
        for (long index = lower; index <= upper; index++) {
   
     
            long tableNum = index % tbNames.size();
            // 事实表后缀
            String suffix = String.valueOf(tableNum == 0 ? tableNum + 6 : tableNum);
            String tableName = logicTableName + "_" + suffix;
            if (tbNames.contains(tableName)) {
   
     
                // 添加满足要求的表名称
                tableNameList.add(tableName);
            }

            // 如果满足要求的表已经覆盖了所有表，此处处理是为了方式查询区间过大，而分表不多，导致的过度遍历
            if (tableNameList.size() == tbNames.size()) {
   
     
                return tableNameList;
            }
        }
        return tableNameList;
    }
}

范围查询示例：

精确查询示例：

5、实体类

User ：

@Data
public class User implements Serializable {
   
     
    private Long id;

    private String name;

    private String phone;

    private String email;
}

6、Mapper类

ComplexMapper ：

@Mapper
public interface ComplexMapper {
   
     
    /**
     * 根据ID查询
     *
     * @param id
     * @return
     */
    User selectById(@Param("id") Long id);

    List<User> selectByIn(@Param("ids") List<Long> ids);

    /**
     * 根据ID删除
     *
     * @param id
     * @return
     */
    int deleteById(@Param("id") Long id);

    /**
     * 根据ID更新
     *
     * @param id
     * @return
     */
    int updateById(@Param("id") Long id);
    /**
     * 新增数据
     *
     * @param min
     * @param max
     * @return
     */
    List<User> listByRange(@Param("min") Long min, @Param("max") Long max);

    int insert(User user);

    int insertBatch(List<User> list);
}

StandardMapper.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.lhz.sharding.mapper.ComplexMapper">

    <select id="selectById" parameterType="java.lang.Long"
            resultType="com.lhz.sharding.model.entity.User">
        select a.*
        from user a
        where a.id ={id}
    </select>

    <select id="selectByIn" parameterType="java.lang.Long"
            resultType="com.lhz.sharding.model.entity.User">
        select a.*
        from user a
        where a.id IN
        <foreach collection="ids" item="id" open="(" close=")" separator=",">
           {id}
        </foreach>
    </select>

    <select id="listByRange"
            resultType="com.lhz.sharding.model.entity.User">
        select a.*
        from user a
        <!--where a.id >{min}-->
        <!--where a.id <{max}-->
        where a.id >={min} and a.id <={max}
        <!-- where a.id between{min} and{max}-->
    </select>

    <update id="updateById" parameterType="java.lang.Long">
        update
            user
        set name ='测试名称'
        where id ={id}
    </update>

    <delete id="deleteById" parameterType="java.lang.Long">
        delete
        from user
        where id ={id}
    </delete>

    <insert id="insert" parameterType="com.lhz.sharding.model.entity.User">
        insert into user(id, name, phone, email)
        values (#{id},{name},{phone},{email})
    </insert>

    <insert id="insertBatch" parameterType="com.lhz.sharding.model.entity.User">
        insert into user(id, name, phone, email)
        values
        <foreach collection="list" item="item" separator=",">
            (#{item.id},{item.name},{item.phone},{item.email})
        </foreach>
    </insert>
</mapper>

7、Service类

ComplexService：

@Service
public class ComplexService {
   
     
    @Resource
    private ComplexMapper complexMapper;
    /**
     * 根据ID查询
     *
     * @param id
     * @return
     */
    public User selectById(Long id) {
   
     

        // in匹配查询
        List<Long> ids = new ArrayList<>();
        ids.add(1L);
        ids.add(3L);
        ids.add(5L);
        List<User> list = complexMapper.selectByIn(ids);

        return complexMapper.selectById(id);
    }

    /**
     * 范围查询
     *
     * @param min
     * @param max
     * @return
     */
    public List<User> listByRange(Long min, Long max) {
   
     
        return complexMapper.listByRange(min, max);
    }

    /**
     * 根据ID删除
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "根据ID删除", notes = "根据ID删除")
    @ApiOperationSupport(order = 15)
    @GetMapping("/deleteById")
    public int deleteById(Long id) {
   
     
        return complexMapper.deleteById(id);
    }

    /**
     * 根据ID更新
     *
     * @param id
     * @return
     */
    @ApiOperation(value = "根据ID更新", notes = "根据ID更新")
    @ApiOperationSupport(order = 20)
    @GetMapping("/updateById")
    public int updateById(Long id) {
   
     
        return complexMapper.updateById(id);
    }

    /**
     * 新增数据
     *
     * @return
     */
    @ApiOperation(value = "新增数据", notes = "新增数据")
    @ApiOperationSupport(order = 25)
    @GetMapping("/insert")
    public int insert() {
   
     
        // 模拟数据
        List<User> list = new ArrayList<>();
        for (long a = 311; a <= 320; a++) {
   
     
            User user = new User();
            user.setId(a);
            user.setName("测试名称-" + a);
            user.setPhone("176-" + a);
            user.setEmail("123@com-" + a);

            list.add(user);
        }

        // 批量新增
        complexMapper.insertBatch(list);

        // 单个新增
        User user = new User();
        user.setId(399L);
        user.setName("测试名称-" + 999);
        user.setPhone("176-" + 999);
        user.setEmail("123@com-" + 999);
        return complexMapper.insert(user);
    }
}

8、Controller类

ComplexController :

@RestController
@RequestMapping("standard")
public class ComplexController {
   
     

    @Resource
    private ComplexService complexService;

    /**
     * 根据ID查询
     *
     * @param id
     * @return
     */
    @GetMapping("/selectById")
    public User selectById(Long id) {
   
     
        return complexService.selectById(id);
    }
    /**
     * 范围查询
     *
     * @param min
     * @param max
     * @return
     */
    @GetMapping("/listByRange")
    public List<User> listByRange(Long min, Long max) {
   
     
        return complexService.listByRange(min, max);
    }

    /**
     * 根据ID删除
     *
     * @param id
     * @return
     */
    @GetMapping("/deleteById")
    public int deleteById(Long id) {
   
     
        return complexService.deleteById(id);
    }

    /**
     * 根据ID更新
     *
     * @param id
     * @return
     */
    @GetMapping("/updateById")
    public int updateById(Long id) {
   
     
        return complexService.updateById(id);
    }

    /**
     * 新增数据
     *
     * @return
     */
    @GetMapping("/insert")
    public int insert() {
   
     
        return complexService.insert();
    }
}

9、测试

1、删除、更新、精确查询：

2、范围查询：

2.1、只有最大值情况：

当sql中的查询只有最大值，即<=时，比如：

select * from user where id <{max}

这种情况则hasUpperBound=true、hasLowerBound=false，并且需要处理最大值小于表数量以及最大值大于表数量的情况

2.2、只有最小值情况：

当sql中的查询只有最大值，即<=时，比如：

select * from user where id >{min}

这种情况则hasUpperBound=false、hasLowerBound=true，那么直接返回所有表即可

2.3、最大与最小值都存在情况：
当sql中的查询既有最大值又有最小值，比如：

select * from user where a.id >={min} and a.id <={max}
或者
select * from user where a.id between{min} and{max}

这种情况需要遍历最小值到最大值的区间，并且匹配满足要求的表名称，需要注意的是，如果遍历过程中满足要求的表已经覆盖了所有表，那么就直接返回所有表，不再继续遍历，这是为了方式查询区间过大，而分表不多，导致的过度遍历。

执行结果：

3、新增数据：

文章推荐： 04、Sharding-JDBC 实战；Sharding-JDBC实现读写分离

文章推荐： 02、Sharding-JDBC 实战；SpringBoot整合实现分库分表

文章推荐： 03、Sharding-JDBC 实战；Sharding-JDBC分片原理

03、Sharding-JDBC 实战；Sharding-JDBC分片原理
1、SQL解析当Sharding-JDBC接受到一条SQL语句时，会陆续执行 SQL解析 => 查询优化 => SQL路由 => SQL改写 => SQL执行 =>结
04、Sharding-JDBC 实战；Sharding-JDBC实现读写分离
1、读写分离简介对于同一时刻有大量并发读操作和较少写操作类型的应用系统来说，将数据库拆分为主库和从库，主库负责处理事务性的增删改操作，从库负责处理查询操作，能够有效的避免由数据更新导致的行锁，使得
10、Sharding-JDBC 实战 - Sharding-JDBC 核心之归并引擎
将从各个数据节点获取的多数据结果集，组合成为一个结果集并正确的返回至请求客户端，称为结果归并。也是Sharding 执行过程 SQL解析 => 执行器优化 => SQL路由 => S
11、Sharding-JDBC 实战 - Sharding-JDBC 核心之执行引擎
ShardingSphere采用一套自动化的执行引擎，负责将路由和改写完成之后的真实SQL安全且高效发送到底层数据源执行。它不是简单地将SQL通过JDBC直接发送至数据源执行；也并非直接将执行请求放
09、Sharding-JDBC 实战 - Sharding-JDBC 核心之解析引擎
Sharding-jdbc 官方文档讲的不是很全面和清楚，学习的时候特意再记录补充下官方文档地址：http://shardingsphere.apache.org/index_zh.html 一
07、Sharding-JDBC 实战：update报错：Can not update sharding key
1.详细报错信息： Caused by: org.apache.ibatis.exceptions.PersistenceException: ## Error updating database.
Question on sharding using planetscale (keeping data within a country using sharding)(关于使用planetscale进行分片的问题（使用分片将数据保存在一个国家内）)
I'm building a niche social media DB on planetscale that spans users living in multiple countries
Tensorflow - Keras : Consider either turning off auto-sharding or switching the auto_shard_policy to DATA to shard this dataset
在 keras/tensorflow 中训练模型时: 代码片段: strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
sharding-jdbc兼容MybatisPlus的动态数据源
背景：之前的项目做读写分离的时候用的 MybatisPlus的动态数据做的，很多地方使用的@DS直接指定的读库或者写库实现的业务；随着表数据量越来越大，现在打算把比较大的表进行水平拆分，准备使用
Sharding JDBC案例实战
基础分库以下实例基于shardingsphere 4.1.0 + SpringBoot 2.2.5.RELEASE版本依赖导入： UTF-8 UTF-8 2.2.5.RE
sharding - 我如何了解有关网站分片用户数据的更多信息？
我有兴趣在多个服务器上分割我的网站用户数据。例如，用户将从同一位置登录。但登录脚本需要弄清楚用户数据驻留在哪个服务器上。因此，登录脚本将在主注册表中查询该用户名，并且可能会返回该用户名位于服务器 B
聊聊分布式数据库的 Sharding，你了解吗？
最近我们团队的D-SMART在做蚂蚁的OCEANBASE的适配，因此又把OB的资料拿出来，重新做研究。要想让D-SMART纳管OCEANBASE，不像一些传统的监控软件那么简单，只要把一些关键指标接
sharding-jdbc5.0.0分表实践
本文基于shardingsphere-jdbc-core-spring-boot-starter 5.0.0，请注意不同版本的sharding-jdbc配置可能有不一样的地方，本文不一定适用于其它版本
sharding - 如何在 ArangoDB 中设置集群和分片？
我想在 arangoDB 中使用分片。我已经制作了协调器，如文档 2.8.5 中提到的 DBServers。但是仍然有人仍然可以详细解释它，以及我如何能够在分片前后检查查询的性能。最佳答案可以测试
sharding - 每个 kinesis 分片有多个消费者
我读到每个 kinesis 流可以有多个消费者应用程序。 http://docs.aws.amazon.com/kinesis/latest/dev/developing-consumers-with
php - 设置或规避 MySql Sharding
我正在使用一个预先存在的 bash 文件为开源数据服务器(Zotero)设置一系列数据库，但我遇到了一个我不熟悉的 mysql 结构: MASTER="mysql -h localhost -P 33
Elasticsearch: "shard allocation"是什么意思？
我们遇到了一个生产事件，Elasticsearch 集群健康检查返回了 red 状态。健康检查报告显示 marvel-2019.06.20 有 2 个 unassigned_shards，这似乎是根本
算法题: Minimum Shard Movement
我在分布式系统中遇到分片移动问题。【问题】最初每个分区负责任意数量的分片。 (这个数字可以是任意的，因为系统支持将分片从一个分区移动到另一个分区) 然后一个新的分区来了，系统需要重新分片。目标是使
Sharding-Jdbc 自定义复合分片的实现(分库分表)
Sharding-JDBC中的分片策略有两个维度，分别是：数据源分片策略（DatabaseShardingStrategy）表分片策略（TableShardingStrategy）
mysql sharding(碎片)介绍
1、Sharding 的应用场景一般都那些？当数据库中的数据量越来越大时，不论是读还是写，压力都会变得越来越大。试想，如果一张表中的数据量达到了千万甚至上亿级别的时候，不管是建索引，优化缓存等，

大佬之路

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城