ShardingSphere 分库分表原理与Spring Boot集成实践方案_Java

前言

随着业务规模的增长，单一数据库往往无法满足高性能、高并发的需求。shardingsphere 作为 apache 基金会顶级项目，提供了完整的分布式数据库解决方案，其中分库分表功能是最核心的能力之一。本文将深入探讨 shardingsphere 的分库分表原理，并提供 spring boot 集成实践方案。

理论基础

1. 分库分表概念

垂直分库：按照业务模块将数据分散到不同的数据库实例
水平分表：将单表数据按照某种规则分散到多个物理表中

2. shardingsphere 架构组成

sharding-jdbc：轻量级 java 框架，以 jar 包形式提供服务
sharding-proxy：数据库代理，提供透明化的数据库访问
sharding-sidecar：云原生数据库代理（开发中）

3. 核心组件

// 数据源配置
datasource datasource = new shardingspheredatasource();
// 分片规则配置
shardingruleconfiguration shardingruleconfig = new shardingruleconfiguration();
// 分片策略
standardshardingstrategyconfiguration strategyconfig = new standardshardingstrategyconfiguration();

4. 原理分析

sql 解析
sharding-jdbc 会对传入的 sql 语句进行解析，识别出其中的分片键（sharding key）以及相关的表名、字段等信息。这是实现分片路由的基础。

  public sqlstatement parse(string sql, boolean usecache);

分片路由
根据解析出的分片键和配置的分片规则，sharding-jdbc 会计算出 sql 应该路由到哪些实际的数据源和表。这个过程涉及到分片算法的应用，比如取模、范围分片等。

  public routecontext route(sqlstatement sqlstatement, shardingrule shardingrule);

sql 改写
在确定了目标数据源和表之后，sharding-jdbc 会将原始 sql 改写为目标数据库可以执行的 sql。例如，将逻辑表名替换为实际的物理表名。

  public sqlrewriteresult rewrite(routecontext routecontext);

结果归并
当查询涉及多个数据源或表时，sharding-jdbc 会将各个数据源返回的结果进行归并，最终返回给应用层一个统一的结果集。

  public mergedresult merge(list<queryresult> queryresults, sqlstatement sqlstatement);

事务管理
sharding-jdbc 还支持分布式事务管理，确保在多个数据源之间的操作具有一致性。

  public void begin();
  public void commit();
  public void rollback();

spring boot 集成方案

1. maven 依赖配置

<dependency>
    <groupid>org.apache.shardingsphere</groupid>
    <artifactid>shardingsphere-jdbc-core-spring-boot-starter</artifactid>
    <version>5.2.1</version>
    <exclusions>
        <exclusion>
            <groupid>org.yaml</groupid>
            <artifactid>snakeyaml</artifactid>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupid>org.yaml</groupid>
    <artifactid>snakeyaml</artifactid>
    <!-- springboot 2.x 使用 shardingsphere 推荐的版本 -->
    <version>1.33</version> 
</dependency>

2. 配置文件设置

spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
      ds0:
        driver-class-name: com.mysql.cj.jdbc.driver
        url: jdbc:mysql://localhost:3306/cce-demo
        username: root
        password: 12345678
        type: com.zaxxer.hikari.hikaridatasource
      ds1:
        driver-class-name: com.mysql.cj.jdbc.driver
        url: jdbc:mysql://localhost:3306/cce-demo-temp
        username: root
        password: 12345678
        type: com.zaxxer.hikari.hikaridatasource
    rules:
      sharding:
        tables:
          mp_user:
            actual-data-nodes: ds${0..1}.mp_user_${0..3}
            table-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: mp-user-inline
            database-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: database-inline
        sharding-algorithms:
          mp-user-inline:
            type: inline
            props:
              algorithm-expression: mp_user_${user_id % 4}
          database-inline:
            type: inline
            props:
              algorithm-expression: ds${user_id % 2}

3. 测试用例

/**
 * mpusertest
 * 所有操作都必须包含分表键，不然无法路由
 * @author senfel
 * @version 1.0
 * @date 2026/1/30 11:42
 */
@springboottest
@testmethodorder(methodorderer.orderannotation.class)
public class mpusertest {
    @resource
    private mpusermapper mpusermapper;
    private static final string testopenid = "test_openid_" + system.currenttimemillis();
    private static final long testuseridnumber = generatenumericuserid();
    /**
     * 生成数字格式的用户id
     * @author senfel
     * @date 2026/1/30 16:59
     * @return java.lang.long
     */
    private static long generatenumericuserid() {
        // 使用时间戳和随机数生成数字id
        long timestamp = system.currenttimemillis();
        long random = (long) (math.random() * 1000000l);
        return timestamp + random;
    }
    /**
     * test
     * @author senfel
     * @date 2026/1/30 16:59
     * @return void
     */
    @test
    @order(1)
    public void test() {
        //插入
        mpuser user = mpuser.builder()
                .openid(testopenid)
                .deleted(false)
                .userid(testuseridnumber)
                .build();
        int result = mpusermapper.insert(user);
        system.err.println("userid: " + user.getuserid());
        asserttrue(result > 0, "插入用户应该成功");
        //查询
        lambdaquerywrapper<mpuser> querywrapper = new lambdaquerywrapper<>();
        querywrapper.eq(mpuser::getuserid, user.getuserid());
        list<mpuser> userlist = mpusermapper.selectlist(querywrapper);
        assertnotnull(userlist, "根据userid查询结果不应该为null");
        //修改
        lambdaupdatewrapper<mpuser> updatewrapper = new lambdaupdatewrapper<>();
        updatewrapper.eq(mpuser::getuserid, user.getuserid())
                .set(mpuser::getuserid, testuseridnumber);
        result = mpusermapper.update(null, updatewrapper);
        asserttrue(result > 0, "根据userid更新用户应该成功");
        //删除
        result = mpusermapper.delete(updatewrapper);
        asserttrue(result > 0, "根据userid删除用户应该成功");
    }
}

4. 测试效果

userid: 1769764291467
creating a new sqlsession
sqlsession [org.apache.ibatis.session.defaults.defaultsqlsession@2d91f007] was not registered for synchronization because synchronization is not active
jdbc connection [org.apache.shardingsphere.driver.jdbc.core.connection.shardingsphereconnection@3dd09249] will not be managed by spring
==>  preparing: select id,openid,deleted,user_id from mp_user where (user_id = ?) 
==> parameters: 1769764291467(long)
<==    columns: id, openid, deleted, user_id
<==        row: 8388609, test_openid_1769763436874, 0, 1769764291467
<==      total: 1
closing non transactional sqlsession [org.apache.ibatis.session.defaults.defaultsqlsession@2d91f007]
creating a new sqlsession
sqlsession [org.apache.ibatis.session.defaults.defaultsqlsession@12888eb5] was not registered for synchronization because synchronization is not active
jdbc connection [org.apache.shardingsphere.driver.jdbc.core.connection.shardingsphereconnection@205339e0] will not be managed by spring
==>  preparing: update mp_user set user_id=? where (user_id = ?) 
==> parameters: 1769764291467(long), 1769764291467(long)
<==    updates: 1
closing non transactional sqlsession [org.apache.ibatis.session.defaults.defaultsqlsession@12888eb5]
creating a new sqlsession
sqlsession [org.apache.ibatis.session.defaults.defaultsqlsession@76f3f810] was not registered for synchronization because synchronization is not active
jdbc connection [org.apache.shardingsphere.driver.jdbc.core.connection.shardingsphereconnection@7d7efdf5] will not be managed by spring
==>  preparing: delete from mp_user where (user_id = ?) 
==> parameters: 1769764291467(long)
<==    updates: 1
closing non transactional sqlsession [org.apache.ibatis.session.defaults.defaultsqlsession@76f3f810]

实际应用场景

1. 电商订单系统

@entity
@table(name = "order")
public class order {
    @id
    private long orderid;
    private long userid;
    private bigdecimal amount;
    private localdatetime createtime;
    // getter/setter...
}
// 查询示例
@repository
public interface orderrepository extends jparepository<order, long> {
    list<order> findbyuserid(long userid);
    @query("select o from order o where o.userid = :userid and o.createtime between :starttime and :endtime")
    list<order> findordersbyuseridandtimerange(@param("userid") long userid, 
                                              @param("starttime") localdatetime starttime, 
                                              @param("endtime") localdatetime endtime);
}

2. 日志分表策略

# 按月份分表配置
spring:
  shardingsphere:
    rules:
      sharding:
        tables:
          system_log:
            actual-data-nodes: ds0.system_log_${202301..202312}
            table-strategy:
              standard:
                sharding-column: create_time
                sharding-algorithm-name: log-month-sharding

性能优化建议

1. 连接池配置

spring:
  shardingsphere:
    props:
      sql-show: true
      max-connections-size-per-query: 10
      acceptor-size: 16

2. 查询优化

合理设计分片键，避免跨分片查询
使用绑定表减少笛卡尔积
合理设置分片数量，避免过多分片影响性能

总结

shardingsphere 提供了完善的分库分表解决方案，通过合理的配置和使用，可以有效解决单体数据库的性能瓶颈问题。在实际应用中需要注意：
1.分片键选择：选择合适的分片键是成功的关键
2.数据迁移：制定完善的数据迁移方案
3.监控告警：建立完善的监控体系
4.版本升级：关注新版本特性，及时升级
通过本文的介绍和实践方案，我们可以快速掌握 shardingsphere 的核心功能，并在 spring boot 项目中成功集成分库分表能力。

到此这篇关于shardingsphere 分库分表原理与spring boot集成实践方案的文章就介绍到这了,更多相关springboot shardingsphere 分库分表内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

ShardingSphere 分库分表原理与Spring Boot集成实践方案

2026年02月02日 • Java •我要评论

前言