首页手记 ShardingJDBC底层资料解析：新手入门教程

ShardingJDBC底层资料解析：新手入门教程

标签：

源码数据库

概述

本文详细介绍了ShardingJDBC底层资料，包括其核心架构、内置SQL解析引擎、数据分片策略及路由与执行流程。通过解析和示例，阐述了ShardingJDBC如何实现数据库的分布式存储解决方案，以及其在实际应用中的配置与使用方法。文章还提供了常见问题及其解决方案，帮助开发者更好地理解和使用ShardingJDBC底层资料。

ShardingJDBC底层资料解析：新手入门教程

ShardingJDBC简介

ShardingJDBC的基本概念

ShardingJDBC是阿里巴巴开源的一个轻量级Java框架，主要用于实现数据库的分布式存储解决方案。它通过在应用层进行数据分片，将大规模的数据存储和访问任务分解为多个小规模的数据存储和访问任务。ShardingJDBC的主要目标是让分布式数据库对应用透明，使得应用程序在不修改代码的情况下，轻松地从单机数据库平滑迁移到分布式数据库。

ShardingJDBC的作用与应用场景

ShardingJDBC的作用和应用场景主要包括以下几个方面：

水平拆分：分片策略可以将数据水平拆分到多个数据库实例上，减少单个数据库实例的压力。
读写分离：通过设置不同的数据源来实现读写分离，提高系统的整体吞吐量。
事务支持：支持分布式事务，保证多个分片上的操作一致性。
SQL兼容性：支持标准SQL语法，兼容大多数主流数据库，并实现跨库的JOIN操作。
内置监控：提供内置的SQL解析、路由、执行等监控信息，方便定位问题。
简化开发：应用可以像使用单库一样进行操作，不需要关心底层数据库的分布式细节。

ShardingJDBC的核心架构

透明化API介绍

ShardingJDBC提供了透明化API，使得应用程序在不修改代码的情况下，方便地从单机数据库迁移到分布式数据库。以下是ShardingJDBC的核心API介绍：

ShardingDataSource：该类封装了数据源，并提供了数据库操作的API。
ShardingRule：定义了数据分片规则，包括表分片规则、库分片规则等。
ShardingStrategy：定义了具体的分片策略，可以是标准分片策略、复合分片策略等。

下面是一个简单的代码示例，展示如何使用ShardingJDBC的API：

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import com.zaxxer.hikari.HikariDataSource;
import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.rule.ShardingTableRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.strategy.config.HorizontalShardingStrategyConfiguration;

public class ShardingJDBCExample {

    public static void main(String[] args) throws SQLException {
        // 创建数据库连接
        HikariDataSource dataSource0 = createDataSource("jdbc:mysql://localhost:3306/db0");
        HikariDataSource dataSource1 = createDataSource("jdbc:mysql://localhost:3306/db1");

        // 创建分片规则配置
        ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
        ShardingTableRuleConfiguration tableRuleConfig = new ShardingTableRuleConfiguration();
        tableRuleConfig.setLogicTable("t_order");
        tableRuleConfig.setActualDataNodes("db${0..1}.t_order${0..1}");
        tableRuleConfig.setDatabaseShardingStrategyConfig(new HorizontalShardingStrategyConfiguration("user_id", "ds_inline"));
        tableRuleConfig.setTableShardingStrategyConfig(new HorizontalShardingStrategyConfiguration("order_id", "t_inline"));
        ruleConfig.getTables().add(tableRuleConfig);
        ruleConfig.getDatabaseStrategies().put("ds_inline", "inline: hint = database;");
        ruleConfig.getTableStrategies().put("t_inline", "inline: hint = table;");

        // 构建ShardingDataSource
        ShardingDataSource shardingDataSource = ShardingDataSourceFactory.createDataSource(createDataSourceMap(), ruleConfig, null);

        // 执行SQL查询
        try (Connection conn = shardingDataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM t_order")) {
            while (rs.next()) {
                System.out.println(rs.getString("user_id") + " - " + rs.getString("order_id"));
            }
        }
    }

    public static HikariDataSource createDataSource(String jdbcUrl) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(jdbcUrl);
        dataSource.setUsername("username");
        dataSource.setPassword("password");
        return dataSource;
    }

    public static java.util.Map<String, HikariDataSource> createDataSourceMap() {
        java.util.Map<String, HikariDataSource> result = new java.util.HashMap<>();
        result.put("ds0", createDataSource("jdbc:mysql://localhost:3306/db0"));
        result.put("ds1", createDataSource("jdbc:mysql://localhost:3306/db1"));
        return result;
    }
}

内置SQL解析引擎

ShardingJDBC内置了一个SQL解析引擎，用于解析和生成分片路由的SQL语句。这个引擎支持标准SQL的解析，并且可以支持跨库的JOIN操作。内置的SQL解析引擎可以提供以下功能：

SQL解析：解析SQL语句，提取出表名、列名等信息。
路由生成：根据分片规则，生成针对每个分片库、表的SQL语句。
SQL执行：将生成的SQL语句执行到对应的数据源上。

内置的SQL解析引擎由ParseEngine类实现，主要逻辑如下：

import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
import com.dangdang.ddframe.rdb.sharding.parser.sql.parser.standard.StandardSQLParser;
import com.dangdang.ddframe.rdb.sharding.parser.sql.statement.dml.SelectStatement;
import com.dangdang.ddframe.rdb.sharding.parser.token.DefaultParseToken;
import com.dangdang.ddframe.rdb.sharding.route.SQLRouteResult;
import com.dangdang.ddframe.rdb.sharding.route.engine.ShardingRouteEngine;

public class ParseEngine {

    private ShardingRule shardingRule;

    public ParseEngine(ShardingRule shardingRule) {
        this.shardingRule = shardingRule;
    }

    public SQLRouteResult parseAndRoute(String sql) {
        StandardSQLParser parser = new StandardSQLParser(sql, new DefaultParseToken());
        SelectStatement statement = (SelectStatement) parser.parse();
        ShardingRouteEngine routeEngine = new ShardingRouteEngine(shardingRule);
        return routeEngine.route(statement);
    }
}

内置SQL解析引擎详解

内置SQL解析引擎的工作流程如下：

SQL解析：解析输入的SQL语句，提取出表名、列名等信息。
分片键提取：从SQL解析结果中提取分片键。
分片路由生成：根据分片键和分片策略，生成针对每个分片库、表的SQL语句。
SQL路由执行：将生成的SQL语句路由到对应的数据源上。

public SQLRouteResult route(String sql, ShardingRule shardingRule) {
    // 解析SQL
    StandardSQLParser parser = new StandardSQLParser(sql, new DefaultParseToken());
    SelectStatement statement = (SelectStatement) parser.parse();

    // 提取分片键
    ShardingKeyExtractor keyExtractor = new ShardingKeyExtractor();
    List<Object> shardingKeys = keyExtractor.extract(statement, shardingRule);

    // 生成SQL路由
    ShardingRouteEngine routeEngine = new ShardingRouteEngine(shardingRule);
    SQLRouteResult routeResult = routeEngine.route(statement, shardingKeys);

    return routeResult;
}

ShardingJDBC的数据分片策略

简单分片策略

简单分片策略是最基础的分片策略，通常用于水平分片的场景。简单分片策略可以按照表名、列名、时间等字段进行分片。

简单分片策略的定义主要包括以下几个部分：

分片函数：用于计算分片键的值。
分片键：指定需要进行分片的字段。
分片表：指定需要进行分片的表。

以下是一个简单的代码示例，展示如何定义简单分片策略：

import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.rule.ShardingTableRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;

public class SimpleShardingStrategyExample {

    public static void main(String[] args) {
        ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
        ShardingTableRuleConfiguration tableRuleConfig = new ShardingTableRuleConfiguration();
        tableRuleConfig.setLogicTable("t_order");
        tableRuleConfig.setActualDataNodes("db${0..1}.t_order${0..1}");
        tableRuleConfig.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "db_inline"));
        tableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("order_id", "t_inline"));
        ruleConfig.getTables().add(tableRuleConfig);
        ruleConfig.getDatabaseStrategies().put("db_inline", "inline: hint = database;");
        ruleConfig.getTableStrategies().put("t_inline", "inline: hint = table;");
    }
}

复杂分片策略

复杂分片策略是指不仅仅根据单一字段进行分片，而是根据多个字段组合进行分片。复杂分片策略可以提供更加灵活的分片方式，适用于更复杂的业务场景。

复杂分片策略的定义主要包括以下几个部分：

分片函数：用于计算分片键的值。
分片键：指定需要进行分片的字段组合。
分片表：指定需要进行分片的表。

以下是一个复杂的代码示例，展示如何定义复杂分片策略：

import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.rule.ShardingTableRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.strategy.sharding.ComplexShardingStrategyConfiguration;

public class ComplexShardingStrategyExample {

    public static void main(String[] args) {
        ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
        ShardingTableRuleConfiguration tableRuleConfig = new ShardingTableRuleConfiguration();
        tableRuleConfig.setLogicTable("t_order");
        tableRuleConfig.setActualDataNodes("db${0..1}.t_order${0..1}");
        tableRuleConfig.setDatabaseShardingStrategyConfig(new ComplexShardingStrategyConfiguration("user_id", "db_inline"));
        tableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("order_id", "t_inline"));
        ruleConfig.getTables().add(tableRuleConfig);
        ruleConfig.getDatabaseStrategies().put("db_inline", "inline: hint = database;");
        ruleConfig.getTableStrategies().put("t_inline", "inline: hint = table;");
    }
}

ShardingJDBC的路由与执行流程

路由过程详解

在ShardingJDBC中，路由过程可以分为以下几个步骤：

SQL解析：解析输入的SQL语句，提取出表名、列名等信息。
分片键提取：从SQL解析结果中提取分片键。
分片路由生成：根据分片键和分片策略，生成针对每个分片库、表的SQL语句。
SQL路由执行：将生成的SQL语句路由到对应的数据源上。

路由过程的伪代码如下：

public SQLRouteResult route(String sql, ShardingRule shardingRule) {
    // 解析SQL
    StandardSQLParser parser = new StandardSQLParser(sql, new DefaultParseToken());
    SelectStatement statement = (SelectStatement) parser.parse();

    // 提取分片键
    ShardingKeyExtractor keyExtractor = new ShardingKeyExtractor();
    List<Object> shardingKeys = keyExtractor.extract(statement, shardingRule);

    // 生成SQL路由
    ShardingRouteEngine routeEngine = new ShardingRouteEngine(shardingRule);
    SQLRouteResult routeResult = routeEngine.route(statement, shardingKeys);

    return routeResult;
}

执行过程解析

在ShardingJDBC中，执行过程可以分为以下几个步骤：

路由解析：解析SQL语句，生成针对每个分片库、表的SQL语句。
SQL执行：将生成的SQL语句执行到对应的数据源上。
结果合并：将从多个数据源返回的结果合并成一个结果集。

执行过程的伪代码如下：

public ResultSet execute(String sql, ShardingRule shardingRule) throws SQLException {
    // 路由解析
    SQLRouteResult routeResult = route(sql, shardingRule);

    // SQL执行
    List<ResultSet> resultSets = new ArrayList<>();
    for (SQLExecutionUnit executionUnit : routeResult.getExecutionUnits()) {
        Connection connection = executionUnit.getDataNode().getConnection();
        Statement stmt = connection.createStatement();
        ResultSet rs = stmt.executeQuery(executionUnit.getSql());
        resultSets.add(rs);
    }

    // 结果合并
    ResultSet mergedResultSet = new MergingResultSet(resultSets);

    return mergedResultSet;
}

ShardingJDBC的配置与使用示例

如何配置ShardingJDBC

配置ShardingJDBC主要涉及以下几个步骤：

定义数据源：创建多个数据源，并指定数据库连接信息。
定义分片规则：创建分片规则配置类，并定义分片策略。
创建ShardingDataSource：通过ShardingDataSourceFactory创建ShardingDataSource实例。

以下是一个简单的配置示例：

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;

import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.rule.ShardingTableRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.strategy.config.HorizontalShardingStrategyConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;
import com.zaxxer.hikari.HikariDataSource;

public class ShardingJDBCConfigurationExample {

    public static void main(String[] args) throws SQLException {
        // 创建数据源
        HikariDataSource dataSource0 = createDataSource("jdbc:mysql://localhost:3306/db0");
        HikariDataSource dataSource1 = createDataSource("jdbc:mysql://localhost:3306/db1");

        // 定义分片规则
        ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
        ShardingTableRuleConfiguration tableRuleConfig = new ShardingTableRuleConfiguration();
        tableRuleConfig.setLogicTable("t_order");
        tableRuleConfig.setActualDataNodes("db${0..1}.t_order${0..1}");
        tableRuleConfig.setDatabaseShardingStrategyConfig(new HorizontalShardingStrategyConfiguration("user_id", "ds_inline"));
        tableRuleConfig.setTableShardingStrategyConfig(new HorizontalShardingStrategyConfiguration("order_id", "t_inline"));
        ruleConfig.getTables().add(tableRuleConfig);
        ruleConfig.getDatabaseStrategies().put("ds_inline", "inline: hint = database;");
        ruleConfig.getTableStrategies().put("t_inline", "inline: hint = table;");

        // 创建ShardingDataSource
        ShardingDataSource shardingDataSource = ShardingDataSourceFactory.createDataSource(createDataSourceMap(), ruleConfig, null);

        // 执行SQL查询
        try (Connection conn = shardingDataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM t_order")) {
            while (rs.next()) {
                System.out.println(rs.getString("user_id") + " - " + rs.getString("order_id"));
            }
        }
    }

    public static HikariDataSource createDataSource(String jdbcUrl) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(jdbcUrl);
        dataSource.setUsername("username");
        dataSource.setPassword("password");
        return dataSource;
    }

    public static Map<String, HikariDataSource> createDataSourceMap() {
        Map<String, HikariDataSource> result = new HashMap<>();
        result.put("ds0", createDataSource("jdbc:mysql://localhost:3306/db0"));
        result.put("ds1", createDataSource("jdbc:mysql://localhost:3306/db1"));
        return result;
    }
}

实战演示：简单分片场景

以下是一个简单的分片场景，假设有一个订单表t_order，需要按照user_id进行分片，将其水平拆分到两个数据库实例上。

数据库配置

假设我们有两个数据库实例db0和db1，每个数据库实例中有两个订单表t_order0和t_order1，表结构如下：

CREATE TABLE db0.t_order0 (
    order_id BIGINT PRIMARY KEY,
    user_id BIGINT,
    order_time TIMESTAMP
);

CREATE TABLE db0.t_order1 (
    order_id BIGINT PRIMARY KEY,
    user_id BIGINT,
    order_time TIMESTAMP
);

CREATE TABLE db1.t_order0 (
    order_id BIGINT PRIMARY KEY,
    user_id BIGINT,
    order_time TIMESTAMP
);

CREATE TABLE db1.t_order1 (
    order_id BIGINT PRIMARY KEY,
    user_id BIGINT,
    order_time TIMESTAMP
);

分片规则配置

定义分片规则，将t_order表水平拆分到两个数据库实例上，每个数据库实例中有两个订单表。

import com.dangdang.ddframe.rdb.sharding.api.config.ShardingRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.rule.ShardingTableRuleConfiguration;
import com.dangdang.ddframe.rdb.sharding.api.config.strategy.sharding.StandardShardingStrategyConfiguration;

public class ShardingRuleConfigExample {

    public static ShardingRuleConfiguration createRuleConfig() {
        ShardingRuleConfiguration ruleConfig = new ShardingRuleConfiguration();
        ShardingTableRuleConfiguration tableRuleConfig = new ShardingTableRuleConfiguration();
        tableRuleConfig.setLogicTable("t_order");
        tableRuleConfig.setActualDataNodes("db${0..1}.t_order${0..1}");
        tableRuleConfig.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("user_id", "db_inline"));
        tableRuleConfig.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("order_id", "t_inline"));
        ruleConfig.getTables().add(tableRuleConfig);
        ruleConfig.getDatabaseStrategies().put("db_inline", "inline: hint = database;");
        ruleConfig.getTableStrategies().put("t_inline", "inline: hint = table;");
        return ruleConfig;
    }
}

数据源配置

定义数据源，创建两个数据库实例的数据源。

import com.zaxxer.hikari.HikariDataSource;

public class DataSourceConfigExample {

    public static Map<String, HikariDataSource> createDataSourceMap() {
        Map<String, HikariDataSource> result = new HashMap<>();
        result.put("ds0", createDataSource("jdbc:mysql://localhost:3306/db0"));
        result.put("ds1", createDataSource("jdbc:mysql://localhost:3306/db1"));
        return result;
    }

    public static HikariDataSource createDataSource(String jdbcUrl) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(jdbcUrl);
        dataSource.setUsername("username");
        dataSource.setPassword("password");
        return dataSource;
    }
}

创建ShardingDataSource

通过ShardingDataSourceFactory创建ShardingDataSource实例。

import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;

public class ShardingDataSourceExample {

    public static ShardingDataSource createShardingDataSource(Map<String, HikariDataSource> dataSourceMap, ShardingRuleConfiguration ruleConfig) {
        return ShardingDataSourceFactory.createDataSource(dataSourceMap, ruleConfig, null);
    }
}

执行SQL查询

执行SQL查询，并打印结果。

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;

public class ShardingJDBCDemo {

    public static void main(String[] args) throws Exception {
        // 创建数据源
        Map<String, HikariDataSource> dataSourceMap = DataSourceConfigExample.createDataSourceMap();

        // 创建分片规则配置
        ShardingRuleConfiguration ruleConfig = ShardingRuleConfigExample.createRuleConfig();

        // 创建ShardingDataSource
        ShardingDataSource shardingDataSource = ShardingDataSourceExample.createShardingDataSource(dataSourceMap, ruleConfig);

        // 执行SQL查询
        try (Connection conn = shardingDataSource.getConnection();
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM t_order")) {
            while (rs.next()) {
                System.out.println(rs.getString("user_id") + " - " + rs.getString("order_id"));
            }
        }
    }
}

ShardingJDBC常见问题与解决方案

常见问题汇总

分片策略配置错误：分片策略配置错误会导致数据无法正确分片，需要仔细检查分片键和分片函数的定义。
SQL语句无法解析：某些复杂的SQL语句可能无法被ShardingJDBC的内置SQL解析引擎解析，需要提供自定义的SQL解析引擎。
性能问题：分片后可能会导致查询性能下降，需要合理设计分片策略，尽量减少跨分片的查询操作。
事务支持问题：跨分片的事务支持比较复杂，需要确保事务的一致性。

解决方案与技巧分享

检查分片策略配置：确保分片策略配置正确，特别是分片键和分片函数的定义。
优化查询语句：尽量避免跨分片的查询操作，可以通过索引优化查询性能。
使用自定义SQL解析引擎：如果内置SQL解析引擎无法解析某些复杂的SQL语句，可以提供自定义的SQL解析引擎。
合理设计分片策略：合理设计分片策略，确保数据的均匀分布，减少热点数据。
使用ShardingJDBC内置监控：使用ShardingJDBC内置的监控信息，方便定位问题和优化性能。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

呼唤远方

手记
篇

粉丝

82

获赞与收藏

367

关注作者，订阅最新文章

阅读免费教程

Scrapy 入门教程

27个小节 10493 251

ThinkPHP 入门教程

28个小节 12372 123

PyCharm 编辑器教程

37个小节 26313 404

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空