springboot分库分表如何查询 spring 分库分表框架

Sharding-Jdbc介绍

Sharding-Jdbc在3.0后改名为ShardingSphere它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。

Sharding-Sphere定位为关系型数据库中间件，旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。它通过关注不变，进而抓住事物本质。关系型数据库当今依然占有巨大市场，是各个公司核心业务的基石，未来也难于撼动，我们目前阶段更加关注在原有基础上的增量，而非颠覆。

应用场景:

数据库读写分离

数据库分表分库

相关资料:

Sharding-Jdbc官方网址: http://shardingsphere.io/index_zh.html

改名新闻:

 

Sharding-Jdbc与MyCat区别

MyCat是一个基于第三方应用中间件数据库代理框架，客户端所有的jdbc请求都必须要先交给MyCat，再有MyCat转发到具体的真实服务器中。

Sharding-Jdbc是一个Jar形式，在本地应用层重写Jdbc原生的方法，实现数据库分片形式。

MyCat属于服务器端数据库中间件，而Sharding-Jdbc是一个本地数据库中间件框架。

从设计理念上看确实有一定的相似性。主要流程都是SQL 解析 -> SQL 路由 -> SQL 改写 -> SQL 执行 -> 结果归并。但架构设计上是不同的。Mycat 是基于 Proxy，它复写了 MySQL 协议，将 Mycat Server 伪装成一个 MySQL 数据库，而 Sharding-JDBC 是基于 JDBC 的扩展，是以 jar 包的形式提供轻量级服务的。

这也就是之前在微服务中学习的SpringCloud Ribbon与Nginx实现负载均衡区别。

 

Sharding-Jdbc实现读写分离

Sharding-Jdbc实现读写分离原理，非常容易。只需要在项目中集成主和从的数据源,Sharding-Jdbc自动根据DML和DQL 语句类型连接主或者从数据源。

注意： Sharding-Jdbc只是实现连接主或者从数据源，不会实现主从复制功能，需要自己配置数据库自带主从复制方式。

查看MasterSlaveDataSource即可查看该类getDataSource方法获取当前数据源名称

DML：数据查询语言DQL基本结构是由SELECT子句，FROM子句，WHERE 子句组成的查询块： SELECT <字段名表> FROM <表或视图名> WHERE <查询条件>

DQL：数据操纵语言DML主要有三种形式： 1) 插入：INSERT 2) 更新：UPDATE 3) 删除：DELETE

 

 

Sharding-Jdbc分表分库

LogicTable

数据分片的逻辑表，对于水平拆分的数据库(表)，同一类表的总称。

订单信息表拆分为2张表,分别是t_order_0、t_order_1，他们的逻辑表名为t_order。

ActualTable

在分片的数据库中真实存在的物理表。即上个示例中的t_order_0、t_order_1。

DataNode

数据分片的最小单元。由数据源名称和数据表组成，例：test_msg0.t_order_0。配置时默认各个分片数据库的表结构均相同，直接配置逻辑表和真实表对应关系即可。

ShardingColumn

分片字段。用于将数据库(表)水平拆分的关键字段。SQL中如果无分片字段，将执行全路由，性能较差。Sharding-JDBC支持多分片字段。

ShardingAlgorithm

分片算法。Sharding-JDBC通过分片算法将数据分片，支持通过等号、BETWEEN和IN分片。分片算法目前需要业务方开发者自行实现，可实现的灵活度非常高。未来Sharding-JDBC也将会实现常用分片算法，如range，hash和tag等。

 

 

SpringBoot整合Sharding-Jdbc分为两种方式

一种为原生配置方式，自己需要实现接口。

1.分库算法类需要实现SingleKeyDatabaseShardingAlgorithm<T>接口

2.分表算法类需要实现SingleKeyTableShardingAlgorithm<T>接口

第二种通过配置文件形式配置。

案例比如：t_order 拆分程t_order_0 t_order _1

Sharding-Jdbc日志分析与原理图

1. Sharding-JDBC中的路由结果是通过分片字段和分片方法来确定的,如果查询条件中有 id 字段的情况还好，查询将会落到某个具体的分片
2. 如果查询没有分片的字段，会向所有的db或者是表都会查询一遍，让后封装结果级给客户端。

Sharding-Jdbc和MyCat查询原理大致相同

 

代码实现：

库表结构：

创建两个数据库db_0和db_1

db_0 创建3个表t_order，t_order_0, t_order_1

CREATE TABLE `t_order` (   `order_id` bigint(20) NOT NULL,   `user_id` bigint(20) NOT NULL,   PRIMARY KEY (`order_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; CREATE TABLE `t_order_0` (   `order_id` bigint(20) NOT NULL,   `user_id` bigint(20) NOT NULL,   PRIMARY KEY (`order_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin; CREATE TABLE `t_order_1` (   `order_id` bigint(20) NOT NULL,   `user_id` bigint(20) NOT NULL,   PRIMARY KEY (`order_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

db_1 创建一个表即可t_order

CREATE TABLE `t_order` (   `order_id` bigint(20) NOT NULL,   `user_id` bigint(20) NOT NULL,   PRIMARY KEY (`order_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

pom.xml文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">     <modelVersion>4.0.0</modelVersion>     <parent>         <groupId>org.springframework.boot</groupId>         <artifactId>spring-boot-starter-parent</artifactId>         <version>2.3.2.RELEASE</version>         <relativePath/> <!-- lookup parent from repository -->     </parent>     <groupId>com.gdbc</groupId>     <artifactId>sharding-jdbc</artifactId>     <version>0.0.1-SNAPSHOT</version>     <name>sharding-jdbc</name>     <description>MultipleSources</description>     <properties>         <java.version>1.8</java.version>     </properties>     <dependencies>         <dependency>             <groupId>mysql</groupId>             <artifactId>mysql-connector-java</artifactId>             <version>5.1.44</version>         </dependency>         <dependency>             <groupId>org.mybatis.spring.boot</groupId>             <artifactId>mybatis-spring-boot-starter</artifactId>             <version>1.3.2</version>         </dependency>         <dependency>             <groupId>org.projectlombok</groupId>             <artifactId>lombok</artifactId>         </dependency>         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-web</artifactId>         </dependency>         <dependency>             <groupId>com.dangdang</groupId>             <artifactId>sharding-jdbc-core</artifactId>             <version>1.5.4</version>         </dependency>         <dependency>             <groupId>com.dangdang</groupId>             <artifactId>sharding-jdbc-self-id-generator</artifactId>             <version>1.4.2</version>         </dependency>         <dependency>             <groupId>com.alibaba</groupId>             <artifactId>druid</artifactId>             <version>1.1.3</version>         </dependency>     </dependencies>     <build>         <plugins>             <plugin>                 <groupId>org.springframework.boot</groupId>                 <artifactId>spring-boot-maven-plugin</artifactId>             </plugin>         </plugins>     </build> </project>

 

application.yml 文件

server: port: 8900 spring: application: name: mutiple-sources jdbc: db0: className: com.mysql.jdbc.Driver url: jdbc:mysql://localhost:3306/%s?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&serverTimezone=UTC username: root password: root mybatis: mapper-locations: classpath:mapper/*.xml type-aliases-package: com.xwkj.sharding.entity

Config目录下的文件：

分库的算法：DatabaseShardingAlgorithm.java

package com.xwkj.sharding.config; import java.util.Collection; import com.dangdang.ddframe.rdb.sharding.api.ShardingValue; import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm; public class DatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> { @Override public String doEqualSharding(Collection<String> databases, ShardingValue<Long> shardingValue) { for (String databaseName : databases) { System.out.println("databaseName:" + databaseName + ",----" + shardingValue.getValue()); if (databaseName.endsWith(shardingValue.getValue() % 2 + "")) { return databaseName; } } throw new IllegalArgumentException(); } @Override public Collection<String> doInSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) { return null; } @Override public Collection<String> doBetweenSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) { return null; } }

分表算法：TableShardingAlgorithm.java

package com.xwkj.sharding.config; import java.util.Collection; import com.dangdang.ddframe.rdb.sharding.api.ShardingValue; import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm; // 表分片算法 public class TableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> { // sql 中关键字 匹配符为 =的时候，表的路由函数 @Override public String doEqualSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) { for (String tableName : availableTargetNames) { if (tableName.endsWith(shardingValue.getValue() % 2 + "")) { return tableName; } } throw new IllegalArgumentException(); } @Override public Collection<String> doInSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) { return null; } @Override public Collection<String> doBetweenSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) { return null; } }

数据源的相关配置DataSourceConfig.java

package com.xwkj.sharding.config; import com.alibaba.druid.pool.DruidDataSource; import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory; import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule; import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule; import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule; import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy; import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.sql.DataSource; import java.sql.SQLException; import java.util.Arrays; import java.util.HashMap; import java.util.Map; /** * 数据源的相关配置， */ @Configuration public class DataSourceConfig { @Value("${spring.jdbc.db0.className}") private String className; @Value("${spring.jdbc.db0.url}") private String url; @Value("${spring.jdbc.db0.username}") private String username; @Value("${spring.jdbc.db0.password}") private String password; @Bean public DataSource getDataSource() { try { return buildDataSource(); } catch (SQLException e) { e.printStackTrace(); } return null; } // 分表配置 /*private DataSource buildDataSource() throws SQLException { // 1.设置分库映射 Map<String, DataSource> dataSourceMap = new HashMap<>(2); dataSourceMap.put("db_0", createDataSource("db_0")); //dataSourceMap.put("ds_1", createDataSource("ds_1")); // 设置默认db为ds_0，也就是为那些没有配置分库分表策略的指定的默认库 // 如果只有一个库，也就是不需要分库的话，map里只放一个映射就行了，只有一个库时不需要指定默认库， // 但2个及以上时必须指定默认库，否则那些没有配置策略的表将无法操作数据 DataSourceRule rule = new DataSourceRule(dataSourceMap, "db_0"); // 2.设置分表映射，将t_order_0和t_order_1两个实际的表映射到t_order逻辑表 TableRule orderTableRule = TableRule.builder("t_order").actualTables(Arrays.asList("t_order_0", "t_order_1")) .dataSourceRule(rule).build(); // 3.具体的分库分表策略 ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(rule) .tableRules(Arrays.asList(orderTableRule)) .tableShardingStrategy(new TableShardingStrategy("user_id", new TableShardingAlgorithm())) .build(); // 创建数据源 DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule); return dataSource; }*/ // 分库配置 private DataSource buildDataSource() throws SQLException { // 1.设置分库映射 Map<String, DataSource> dataSourceMap = new HashMap<>(2); dataSourceMap.put("db_0", createDataSource("db_0")); dataSourceMap.put("db_1", createDataSource("db_1")); // 设置默认db为ds_0，也就是为那些没有配置分库分表策略的指定的默认库 // 如果只有一个库，也就是不需要分库的话，map里只放一个映射就行了，只有一个库时不需要指定默认库， // 但2个及以上时必须指定默认库，否则那些没有配置策略的表将无法操作数据 DataSourceRule rule = new DataSourceRule(dataSourceMap, "db_0"); TableRule orderTableRule = TableRule.builder("t_order").dataSourceRule(rule).build(); // 3.具体的分库分表策略 ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(rule) .tableRules(Arrays.asList(orderTableRule)) .databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new DatabaseShardingAlgorithm())) .build(); // 创建数据源 DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule); return dataSource; } private DataSource createDataSource(String dataSourceName) { // 使用druid连接数据库 DruidDataSource druidDataSource = new DruidDataSource(); druidDataSource.setDriverClassName(className); druidDataSource.setUrl(String.format(url, dataSourceName)); druidDataSource.setUsername(username); druidDataSource.setPassword(password); return druidDataSource; } }

操作数据库的crud相关代码：

OrderController.java

package com.xwkj.sharding.controller; import com.xwkj.sharding.entity.OrderEntity; import com.xwkj.sharding.service.OrderService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.ArrayList; import java.util.List; @RestController public class OrderController { @Autowired private OrderService orderService; // 使用in条件查询 @RequestMapping("/inOrder") public List<OrderEntity> findExpiredOrderState(){ List<String> ids = new ArrayList<>(); ids.add("2"); ids.add("3"); ids.add("4"); ids.add("5"); return orderService.findExpiredOrderState(ids); } // 查询所有的订单信息 @RequestMapping("/getOrderAll") public List<OrderEntity> getOrderAll() { return orderService.findAll(); } @RequestMapping("/inserOrder") public String inserOrder(OrderEntity orderEntity) { for (int i = 0; i < 10; i++) { OrderEntity order = new OrderEntity(); order.setOrderId((long) i); order.setUserId((long) i); orderService.save(order); } return "success"; } }

OrderEntity.java

package com.xwkj.sharding.entity; import lombok.Data; @Data public class OrderEntity { private Long orderId; private Long userId; }

OrderMapper.java

package com.xwkj.sharding.mapper; import com.xwkj.sharding.entity.OrderEntity; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; import java.util.List; @Mapper public interface OrderMapper { public List<OrderEntity> findExpiredOrderState(@Param("bpIds") List<String> bpIds); List<OrderEntity> findAll(); void save(OrderEntity order); }

OrderService.java

package com.xwkj.sharding.service; import com.xwkj.sharding.entity.OrderEntity; import com.xwkj.sharding.mapper.OrderMapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; @Service public class OrderService { @Autowired private OrderMapper orderMapper; public List<OrderEntity> findExpiredOrderState(List<String> bpIds){ return orderMapper.findExpiredOrderState(bpIds); } public List<OrderEntity> findAll() { return orderMapper.findAll(); } public void save(OrderEntity order) { orderMapper.save(order); } }

 

OrderMapper.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.xwkj.sharding.mapper.OrderMapper"> <select id="findAll" resultType="com.xwkj.sharding.entity.OrderEntity"> select order_id as orderId, user_id as userId from t_order </select> <select id="findExpiredOrderState" resultType="com.xwkj.sharding.entity.OrderEntity"> select order_id as orderId, user_id as userId from t_order where 1=1 <if test="bpIds != null"> <if test="bpIds.size > 0"> AND (order_id not in <foreach item="item" index="index" collection="bpIds" open="(" separator="," close=")"> #{item} </foreach> ) </if> </if> </select> <insert id="save"> INSERT INTO t_order( order_id, user_id ) VALUES ( #{orderId}, #{userId} ) </insert> </mapper>

 

项目启动类：ShardingJdbcApplication.java

package com.xwkj.sharding; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class ShardingJdbcApplication { public static void main(String[] args) { SpringApplication.run(ShardingJdbcApplication.class, args); } }

项目启动，进行分库分表功能验证：

首先验证分表数据情况：

分表只是在同个数据库里面进行分表，我们将插入10条数据，数据将按照我们的分表规则进行数据的分表，单数的将在db_0数据库中的t_order_1，双数的将分配在db_1数据库t_order_0

访问：http://localhost:8900/inserOrder

查看数据库表数据：

结果是我们的预期

然后验证分库数据情况：

分库数据将在不同的数据库里面进行存储，数据将存储在db_0,以及db_1上的t_order表中，双数数据将存放在db_0上的t_order表中，基数将存放在db_1上的t_order表中

项目代码中对数据源DataSourceConfig内的代码进行切换同样访问：http://localhost:8900/inserOrder

结果按照预期实现。

项目代码：[e-mail]:chenxiaohong/sharding-jdbc.git