分库分表——sharding-sphere

sharding-sphere

简介

Sharding-Sphere是一套开源的分布式数据库中间件解决方案组成的生态圈,它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar这3款相互独立的产品组成。他们均提供标准化的数据分片、读写分离、柔性事务和数据治理功能,可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。

官网

http://shardingjdbc.io/

Github

https://github.com/sharding-sphere

三大核心模块分别是Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar。

Sharding-JDBC

定位为轻量级Java框架,在Java的JDBC层提供的额外服务。 它使用客户端直连数据库,以jar包形式提供服务,无需额外部署和依赖,可理解为增强版的JDBC驱动,完全兼容JDBC和各种ORM框架。

分库分表——sharding-sphere_第1张图片

image

Sharding-Proxy

定位为透明化的数据库代理端,提供封装了数据库二进制协议的服务端版本,用于完成对异构语言的支持。 目前先提供MySQL版本,它可以使用任何兼容MySQL协议的访问客户端(如:MySQL Command Client, MySQL Workbench等)操作数据,对DBA更加友好。

分库分表——sharding-sphere_第2张图片

image

Sharding-Sidecar

定位为Kubernetes或Mesos的云原生数据库代理,以DaemonSet的形式代理所有对数据库的访问。 通过无中心、零侵入的方案提供与数据库交互的的啮合层,即Database Mesh,又可称数据网格。

分库分表——sharding-sphere_第3张图片

image

sharding-sphere-example

在Github上分别有三个项目,分别是sharding-sphere、sharding-sphere-doc和sharding-sphere-example。从字面就可以看出每个项目是做什么的。

既然是要入门,那就clone下sharding-sphere-example这个项目。

1、克隆项目

在命令行执行git clone https://github.com/sharding-sphere/sharding-sphere-example.git

完成后,就可以看到sharding-sphere-example项目,导入intellij idea中。

2、编译项目

进入项目根目录下,编译项目。

我这边下载的项目sharding-sphere.version是3.0.0.M2-SNAPSHOT,编译的时候一直报该版本找不到,无法下载,去中央仓库也没有找到。

分库分表——sharding-sphere_第4张图片

image

想着可能要本地编译打包,所以就换成了3.0.0.M1版本,编译通过。

分库分表——sharding-sphere_第5张图片

image

3、配置数据源

因为是本机测试,所以在本地配置mysql数据库。

分库分表——sharding-sphere_第6张图片

image

4、编写数据分片代码

sharding-sphere-example项目中有基于不同场景包括spring-boot、jpa、mybatis的具体分库分表的实例代码。

本文主要结合sharding-sphere官方文档给出的数据分片代码讲解如何实现分库分表的。

测试类ShardingDataSource(自建测试类,来源http://shardingsphere.io/document/current/cn/manual/sharding-jdbc/usage/sharding/)

 


package practice;

import io.shardingsphere.core.api.ShardingDataSourceFactory;

import io.shardingsphere.core.api.config.ShardingRuleConfiguration;

import io.shardingsphere.core.api.config.TableRuleConfiguration;

import io.shardingsphere.core.api.config.strategy.InlineShardingStrategyConfiguration;

import io.shardingsphere.example.jdbc.fixture.DataRepository;

import org.apache.commons.dbcp.BasicDataSource;

import javax.sql.DataSource;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.Map;

import java.util.Properties;

import java.util.concurrent.ConcurrentHashMap;

public class ShardingDataSource {

public static void main(String[] args)throws SQLException {

ShardingDataSource shardingDataSource =new ShardingDataSource();

DataSource dataSource = shardingDataSource.sharding();

new DataRepository(dataSource).demo();

}

public DataSource sharding()throws SQLException {

// 配置真实数据源

       Map dataSourceMap =new HashMap<>();

// 配置第一个数据源

       BasicDataSource dataSource1 =new BasicDataSource();

dataSource1.setDriverClassName("com.mysql.jdbc.Driver");

dataSource1.setUrl("jdbc:mysql://127.0.0.1:3306/ds0");

dataSource1.setUsername("root");

dataSource1.setPassword("root");

dataSourceMap.put("ds0", dataSource1);

// 配置第二个数据源

       BasicDataSource dataSource2 =new BasicDataSource();

dataSource2.setDriverClassName("com.mysql.jdbc.Driver");

dataSource2.setUrl("jdbc:mysql://127.0.0.1:3306/ds1");

dataSource2.setUsername("root");

dataSource2.setPassword("root");

dataSourceMap.put("ds1", dataSource2);

// 配置Order表规则

       TableRuleConfiguration orderTableRuleConfig =new TableRuleConfiguration();

orderTableRuleConfig.setLogicTable("t_order");

orderTableRuleConfig.setActualDataNodes("ds${0..1}.t_order${0..1}");

// 配置分库 + 分表策略

       orderTableRuleConfig.setDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("user_id","ds${user_id % 2}"));

orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id","t_order${order_id % 2}"));

orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_item_id","t_order_item${order_item_id % 2}"));

// 配置分片规则

       ShardingRuleConfiguration shardingRuleConfig =new ShardingRuleConfiguration();

shardingRuleConfig.getTableRuleConfigs().add(orderTableRuleConfig);

// 配置order_item表规则...

       TableRuleConfiguration orderItemTableRuleConfig =new TableRuleConfiguration();

orderItemTableRuleConfig.setLogicTable("t_order_item");

orderItemTableRuleConfig.setActualDataNodes("ds${0..1}.t_order_item${0..1}");

shardingRuleConfig.getTableRuleConfigs().add(orderItemTableRuleConfig);

// 获取数据源对象

       return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig,new ConcurrentHashMap(),new Properties());

}

}

注意

1、代码中类似"ds{0..1}.t_order{0..1}"成为行表达式,形如"{ expression }或->{ expression }"。该表达式可用于配置数据节点和配置分片算法。

${begin..end}表示范围区间,即表示从begin到end个

${[unit1, unit2, unit_x]}表示枚举值

2、orderTableRuleConfig.setActualDataNodes("ds{0..1}.t_order{0..1}");

这里表示的是使用行表达式配置数据节点即数据库分别是ds0、ds1,表分别是t_order0、t_order1。

该表达的等价组合是:ds0.t_order0, ds0.t_order1, ds1.t_order0, ds1.t_order1。

3、orderTableRuleConfig.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id", "t_order${order_id % 2}"));

这里表示的是使用行表达式配置分片算法。该行表示针对t_order表中的元素按照order_id模2将不同的元素放进不同的表中。

比如order_id=5,5%2=1,则放入t_order1中

order_id=6, 6%2=0, 则放入t_order0中

4、除此以外还要一些类似"逻辑表"这样的概念,可以到官方文档自行查询。

工具类DataRespository(该类来源sharding-sphere-example项目)

 


/*

* Copyright 2016-2018 shardingsphere.io.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*

*/

package io.shardingsphere.example.jdbc.fixture;

import io.shardingsphere.core.api.HintManager;

import javax.sql.DataSource;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class DataRepository {

private final DataSourcedataSource;

public DataRepository(final DataSource dataSource) {

this.dataSource = dataSource;

}

public void demo()throws SQLException {

createTable();

insertData();

System.out.println("1.Query with EQUAL--------------");

queryWithEqual();

System.out.println("2.Query with IN--------------");

queryWithIn();

System.out.println("3.Query with Hint--------------");

queryWithHint();

System.out.println("4.Drop tables--------------");

dropTable();

System.out.println("5.All done-----------");

}

private void createTable()throws SQLException {

execute("CREATE TABLE IF NOT EXISTS t_order (order_id BIGINT NOT NULL AUTO_INCREMENT, user_id INT NOT NULL, status VARCHAR(50), PRIMARY KEY (order_id))");

execute("CREATE TABLE IF NOT EXISTS t_order_item (order_item_id BIGINT NOT NULL AUTO_INCREMENT, order_id BIGINT NOT NULL, user_id INT NOT NULL, PRIMARY KEY (order_item_id))");

}

private void insertData()throws SQLException {

for (int i =1; i <10; i++) {

long orderId = insertAndGetGeneratedKey("INSERT INTO t_order (user_id, status) VALUES (10, 'INIT')");

execute(String.format("INSERT INTO t_order_item (order_id, user_id) VALUES (%d, 10)", orderId));

orderId = insertAndGetGeneratedKey("INSERT INTO t_order (user_id, status) VALUES (11, 'INIT')");

execute(String.format("INSERT INTO t_order_item (order_id, user_id) VALUES (%d, 11)", orderId));

}

}

private long insertAndGetGeneratedKey(final String sql)throws SQLException {

long result = -1;

try (

Connection connection =dataSource.getConnection();

Statement statement = connection.createStatement()) {

statement.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS);

try (ResultSet resultSet = statement.getGeneratedKeys()) {

if (resultSet.next()) {

result = resultSet.getLong(1);

}

}

}

return result;

}

private void queryWithEqual()throws SQLException {

String sql ="SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=?";

try (

Connection connection =dataSource.getConnection();

PreparedStatement preparedStatement = connection.prepareStatement(sql)) {

preparedStatement.setInt(1,10);

printQuery(preparedStatement);

}

}

private void queryWithIn()throws SQLException {

String sql ="SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id IN (?, ?)";

try (

Connection connection =dataSource.getConnection();

PreparedStatement preparedStatement = connection.prepareStatement(sql)) {

preparedStatement.setInt(1,10);

preparedStatement.setInt(2,11);

printQuery(preparedStatement);

}

}

private void queryWithHint()throws SQLException {

String sql ="SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id";

try (

HintManager hintManager = HintManager.getInstance();

Connection connection =dataSource.getConnection();

PreparedStatement preparedStatement = connection.prepareStatement(sql)) {

hintManager.addDatabaseShardingValue("t_order","user_id",11);

printQuery(preparedStatement);

}

}

private void printQuery(final PreparedStatement preparedStatement)throws SQLException {

try (ResultSet resultSet = preparedStatement.executeQuery()) {

while (resultSet.next()) {

System.out.print("order_item_id:" + resultSet.getLong(1) +", ");

System.out.print("order_id:" + resultSet.getLong(2) +", ");

System.out.print("user_id:" + resultSet.getInt(3));

System.out.println();

}

}

}

private void dropTable()throws SQLException {

execute("DROP TABLE t_order_item");

execute("DROP TABLE t_order");

}

private void execute(final String sql)throws SQLException {

try (

Connection connection =dataSource.getConnection();

Statement statement = connection.createStatement()) {

statement.execute(sql);

}

}

}

注意

1、createTable

该方法会根据配置的数据节点表达式创建分表。这里分别创建t_order和t_order_item两张逻辑表。

2、insertData

该方法同样根据配置的数据分片表达书创建数据

3、queryWithEqual等方法

这些方法是不同的查询场景,有精确查询也有范围查询

4、queryWithHint

该方法比较特殊。

通过解析SQL语句提取分片键列与值并进行分片是Sharding-Sphere对SQL零侵入的实现方式。若SQL语句中没有分片条件,则无法进行分片,需要全路由。

好比queryWithHint这个方法中的"String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id";"就没有包含路由信息,即where

条件语句中没有order_id和user_id的信息。

所以该方法中通过强制指定路由信息进行路由。"hintManager.addDatabaseShardingValue("t_order", "user_id", 11);"这里执行user_id为11的条件,通过这个条件也可以推测出是只会路由到ds1库中(11%2=1)。

5、dropTable

该方法用于清理现场,将所有表和表数据清除。

5、执行结果

执行完代码,控制台打印

 


1.Query with EQUAL--------------

2.Query with IN--------------

3.Query with Hint--------------

4.Drop tables--------------

5.All done-----------

执行代码前,只有两个数据库ds0,ds1,执行代码后得到结果如下图所示

image

小结

sharding-sphere是一天非常强大的分布式数据库中间件解决方法。

有简单易懂的行表达式用于配置数据节点和数据分片算法。

有自己的诸多大杀器,比如强制路由等。

官方文档齐全,实例代码项目case较全,能够在较短时间完成分库分表。

本篇通过一个简单的demo代码,大致了解了sharding-sphere(主要是sharding-jdbc)的基本玩法,后续有时间可以学习下底层的设计和实现原理。


 

你可能感兴趣的:(分库分表——sharding-sphere)