Sharding-JDBC 数据源分片：Java 配置实现基于原生 JDBC 的精确分片方案

本文介绍 Sharding-JDBC 数据源分片之使用 Java 配置实现基于原生 JDBC 的精确分片方案。

目录

  • 开发环境
  • 基础示例
  • 总结

开发环境

  • Oracle JDK 1.8.0_201
  • Apache Maven 3.6.0
  • IntelliJ IDEA (Version 2018.3.3)
  • MySQL 5.6.38

基础示例

  1. 创建 2 个数据库实例 ds_0 和 ds_1。

  2. 创建 Maven 工程，参考：IntelliJ IDEA 创建 Maven 工程。

  3. 在生成的 pom 文件中添加 Sharding-JDBC 和 MySQL 驱动依赖，使用阿里巴巴 Druid 数据库连接池。

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>shardingsphere-tutorial</artifactId>
        <groupId>tutorial.shardingsphere</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>shardingsphere-raw-jdbc</artifactId>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <dependencies>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.17</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>
  1. 创建一个领域类 Order（订单），包含 3 个属性：orderId（订单编号），userId（订单所属用户ID），details（订单详情）。
package tutorial.shardingsphere.jdbc.bean;

import java.io.Serializable;
import java.util.Objects;

public class Order implements Serializable {

    private static final long serialVersionUID = -3614937227437805644L;

    private Long orderId;

    private Long userId;

    private String details;

    public Order() {
    }

    public Order(Long userId, String details) {
        this.userId = userId;
        this.details = details;
    }

    public Long getOrderId() {
        return orderId;
    }

    public void setOrderId(Long orderId) {
        this.orderId = orderId;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof Order)) {
            return false;
        }
        Order order = (Order) o;
        return Objects.equals(orderId, order.orderId) &&
                Objects.equals(userId, order.userId) &&
                Objects.equals(details, order.details);
    }

    @Override
    public int hashCode() {
        return Objects.hash(orderId, userId, details);
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderId=" + orderId +
                ", userId=" + userId +
                ", details='" + details + '\'' +
                '}';
    }
}
  1. 定义通用数据访问接口（DAO：Data Access Object）。
package tutorial.shardingsphere.jdbc.dao;

import java.util.List;

public interface IBasicDao<T, P> {

    void createTableIfNotExists();

    void dropTable();

    void truncateTable();

    Long insert(T entity);

    List<T> select();

    void update(T entity);

    void delete(P key);
}
  1. 定义 Order（订单）数据访问接口，继承通用 DAO。
package tutorial.shardingsphere.jdbc.dao;

import tutorial.shardingsphere.jdbc.bean.Order;

public interface IOrderDao extends IBasicDao<Order, Long> {
}
  1. 定义 Order（订单）数据访问实现。
package tutorial.shardingsphere.jdbc.dao.impl;

import tutorial.shardingsphere.jdbc.bean.Order;
import tutorial.shardingsphere.jdbc.dao.IOrderDao;

import javax.sql.DataSource;
import java.sql.*;
import java.util.LinkedList;
import java.util.List;

public class OrderDaoImpl implements IOrderDao {

    private final DataSource dataSource;

    public OrderDaoImpl(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    @Override
    public void createTableIfNotExists() {
        String sql = "CREATE TABLE IF NOT EXISTS t_order "
                + "(order_id BIGINT NOT NULL AUTO_INCREMENT, user_id BIGINT NOT NULL, details VARCHAR(100), PRIMARY KEY (order_id))";
        try (Connection connection = dataSource.getConnection();
             Statement statement = connection.createStatement()) {
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void dropTable() {
        String sql = "DROP TABLE t_order";
        try (Connection connection = dataSource.getConnection();
             Statement statement = connection.createStatement()) {
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void truncateTable() {
        String sql = "TRUNCATE TABLE t_order";
        try (Connection connection = dataSource.getConnection();
             Statement statement = connection.createStatement()) {
            statement.executeUpdate(sql);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Long insert(Order order) {
        String sql = "INSERT INTO t_order (user_id, details) VALUES (?, ?)";
        try (Connection connection = dataSource.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            preparedStatement.setLong(1, order.getUserId());
            preparedStatement.setString(2, order.getDetails());
            preparedStatement.executeUpdate();
            try (ResultSet resultSet = preparedStatement.getGeneratedKeys()) {
                if (resultSet.next()) {
                    order.setOrderId(resultSet.getLong(1));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return order.getOrderId();
    }

    @Override
    public List<Order> select() {
        String sql = "SELECT * FROM t_order";
        return listOrders(sql);
    }

    protected List<Order> listOrders(String sql) {
        List<Order> result = new LinkedList<>();
        try (Connection connection = dataSource.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql);
             ResultSet resultSet = preparedStatement.executeQuery()) {
            while (resultSet.next()) {
                Order order = new Order();
                order.setOrderId(resultSet.getLong(1));
                order.setUserId(resultSet.getLong(2));
                order.setDetails(resultSet.getString(3));
                result.add(order);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public void update(Order order) {
        String sql = "UPDATE t_order SET user_id=?, details=? WHERE order_id=?";
        try (Connection connection = dataSource.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setLong(1, order.getUserId());
            preparedStatement.setString(2, order.getDetails());
            preparedStatement.setLong(3, order.getOrderId());
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void delete(Long id) {
        String sql = "DELETE FROM t_order WHERE order_id=?";
        try (Connection connection = dataSource.getConnection();
             PreparedStatement preparedStatement = connection.prepareStatement(sql)) {
            preparedStatement.setLong(1, id);
            preparedStatement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
  1. 定义数据源工具类。
package tutorial.shardingsphere.jdbc.util;

import com.alibaba.druid.pool.DruidDataSource;

import javax.sql.DataSource;

public class DataSourceUtils {

    /**
     * 创建数据源对象
     */
    public static DataSource createDataSource(final String dataSourceName) {
        DruidDataSource dataSource = new DruidDataSource();
        String jdbcUrl =
                String.format(
                        "jdbc:mysql://localhost:3306/%s?useSSL=false&useUnicode=true&characterEncoding=UTF-8",
                        dataSourceName);
        dataSource.setUrl(jdbcUrl);
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        // 数据源其它配置（略）
        return dataSource;
    }
}
  1. 定义获取数据源的工厂类。
package tutorial.shardingsphere.jdbc.util;

import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.InlineShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class DataSourceFactory {

    /**
     * 配置数据源映射
     */
    private static Map<String, DataSource> createDataSourceMap() {
        Map<String, DataSource> result = new HashMap<>();
        result.put("ds_0", DataSourceUtils.createDataSource("ds_0"));
        result.put("ds_1", DataSourceUtils.createDataSource("ds_1"));
        return result;
    }

    public static DataSource getDataSource() throws SQLException {
        // 配置数据源映射
        Map<String, DataSource> dataSourceMap = createDataSourceMap();
        // 配置表规则
        TableRuleConfiguration tableRuleConfiguration = new TableRuleConfiguration("t_order");
        tableRuleConfiguration.setKeyGeneratorConfig(new KeyGeneratorConfiguration("SNOWFLAKE", "order_id"));
        // 配置分片规则
        ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();
        shardingRuleConfiguration.getTableRuleConfigs().add(tableRuleConfiguration);
        // 配置默认分库策略
        shardingRuleConfiguration.setDefaultDatabaseShardingStrategyConfig(
                new InlineShardingStrategyConfiguration("user_id", "ds_${user_id % 2}")
        );
        // 获取数据源对象
        return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfiguration, new Properties());
    }
}
  1. 编写单元测试。
package tutorial.shardingsphere.jdbc;

import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import tutorial.shardingsphere.jdbc.bean.Order;
import tutorial.shardingsphere.jdbc.dao.IOrderDao;
import tutorial.shardingsphere.jdbc.dao.impl.OrderDaoImpl;
import tutorial.shardingsphere.jdbc.util.DataSourceFactory;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class JdbcConfigPreciseShardingDatabaseTest {

    private static IOrderDao orderDao;

    @BeforeClass
    public static void init() throws SQLException {
        DataSource dataSource = DataSourceFactory.getDataSource();
        orderDao = new OrderDaoImpl(dataSource);
    }

    @Test
    public void test() {
        orderDao.createTableIfNotExists();
        orderDao.truncateTable();
        Assert.assertEquals(0, orderDao.select().size());
        Order order1 = new Order(1L, "Order 1");
        Order order2 = new Order(2L, "Order 2");
        order1.setOrderId(orderDao.insert(order1));
        order2.setOrderId(orderDao.insert(order2));
        List<Order> orders = orderDao.select();
        List<Order> expected = Arrays.asList(order1, order2);
        Assert.assertEquals(expected, orders);
        order1.setUserId(2L);
        order1.setDetails("Order 1 changed user id!");
        orderDao.update(order1);
        order2.setUserId(1L);
        order2.setDetails("Order 2 changed user id!");
        orderDao.update(order2);
        orderDao.delete(0L);
        orders = orderDao.select();
        Assert.assertEquals(expected, orders);
        orderDao.delete(order1.getOrderId());
        orders = orderDao.select();
        Assert.assertEquals(Collections.singletonList(order2), orders);
        orderDao.delete(order2.getOrderId());
        orders = orderDao.select();
        Assert.assertEquals(0, orders.size());
        orderDao.dropTable();
    }
}

测试执行结果略。

总结

本示例实现了基于 t_order 表 user_id 字段的精确数据分片，user_id 为单数时存储在 ds_1 中，为双数时存储在 ds_0 中。

使用 Sharding-JDBC 实现基于原生 JDBC 的单表分库关键步骤：

  1. 配置数据源映射 Map<String, DataSource>；
  2. 配置数据分片规则 ShardingRuleConfiguration；
  3. 在数据分片规则中添加表规则配置 TableRuleConfiguration；
  4. 在数据分片规则中设置默认数据库分片策略 setDefaultDatabaseShardingStrategyConfig；
  5. 调用 ShardingDataSourceFactory.createDataSource 创建分片后数据源对象。

过程中使用的关键类：

  • ShardingDataSourceFactory：数据分片的数据源创建工厂。
  • ShardingRuleConfiguration：分片规则配置对象。
  • TableRuleConfiguration：表分片规则配置对象。
  • ShardingStrategyConfiguration：分片策略配置对象。

Sharding-JDBC 提供了几个 ShardingStrategyConfiguration 的实现类处理不同的分片场景：

  • StandardShardingStrategyConfiguration：用于单分片键的标准分片场景。
  • ComplexShardingStrategyConfiguration：用于多分片键的复合分片场景。
  • InlineShardingStrategyConfiguration：用于配置行表达式分片策略。
  • HintShardingStrategyConfiguration：用于配置Hint方式分片策略。
  • NoneShardingStrategyConfiguration：用于配置不分片的策略。

更多详细配置参考：Sharding-JDBC 官方 Java 配置

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 217,277评论 6赞 503
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,689评论 3赞 393
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 163,624评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,356评论 1赞 293
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,402评论 6赞 392
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,292评论 1赞 301
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,135评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,992评论 0赞 275
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,429评论 1赞 314
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,636评论 3赞 334
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,785评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,492评论 5赞 345
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,092评论 3赞 328
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,723评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,858评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,891评论 2赞 370
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,713评论 2赞 354