使用Sharding-JDBC对数据进行分片处理详解
作者：1024程序猿~嗷~ 发布时间：2021-07-27 23:46:04
标签：Sharding,JDBC,数据,分片
前言
Sharding-JDBC是ShardingSphere的第一个产品，也是ShardingSphere的前身。
它定位为轻量级Java框架，在Java的JDBC层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。
适用于任何基于Java的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。
基于任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP等支持任意实现JDBC规范的数据库。
目前支持MySQL，Oracle，SQLServer和PostgreSQL。
Sharding-JDBC的使用需要我们对项目进行一些调整：结构如下
ShardingSphere文档地址
这里使用的是springBoot项目改造
一、加入依赖
<!-- 这里使用了druid连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.9</version>
</dependency>
<!-- sharding-jdbc 包 -->
<dependency>
<groupId>com.dangdang</groupId>
<artifactId>sharding-jdbc-core</artifactId>
<version>1.5.4</version>
</dependency>
<!-- 这里使用了雪花算法生成组建，这个算法的实现的自己写的代码，各位客关老爷可以修改为自己的id生成策略 -->
<dependency>
<groupId>org.kcsm.common</groupId>
<artifactId>kcsm-idgenerator</artifactId>
<version>3.0.1</version>
</dependency>
二、修改application.yml配置文件
#启动接口
server:
port: 30009
spring:
jpa:
database: mysql
show-sql: true
hibernate:
# 修改不自动更新表
ddl-auto: none
#数据源0定义，这里只是用了一个数据源，各位客官可以根据自己的需求定义多个数据源
database0:
databaseName: database0
url: jdbc:mysql://kcsm-pre.mysql.rds.aliyuncs.com:3306/dstest?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=Hongkong
username: root
password: kcsm@111
driverClassName: com.mysql.jdbc.Driver
三、数据源定义
package com.lzx.code.codedemo.config;
import com.alibaba.druid.pool.DruidDataSource;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
/**
* 描述:数据源0定义
*
* @Auther: lzx
* @Date: 2019/9/9 15:19
*/
@Data
@ConfigurationProperties(prefix = "database0")
@Component
public class Database0Config {
private String url;
private String username;
private String password;
private String driverClassName;
private String databaseName;
public DataSource createDataSource() {
DruidDataSource result = new DruidDataSource();
result.setDriverClassName(getDriverClassName());
result.setUrl(getUrl());
result.setUsername(getUsername());
result.setPassword(getPassword());
return result;
}
}
四、数据源分配算法实现
package com.lzx.code.codedemo.config;
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* 描述:数据源分配算法
*
* 这里我们只用了一个数据源，所以所有的都只返回了数据源0
*
* @Auther: lzx
* @Date: 2019/9/9 15:27
*/
@Component
public class DatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm {
@Autowired
private Database0Config database0Config;
/**
* = 条件时候返回的数据源
* @param collection
* @param shardingValue
* @return
*/
@Override
public String doEqualSharding(Collection collection, ShardingValue shardingValue) {
return database0Config.getDatabaseName();
}
/**
* IN 条件返回的数据源
* @param collection
* @param shardingValue
* @return
*/
@Override
public Collection<String> doInSharding(Collection collection, ShardingValue shardingValue) {
List<String> result = new ArrayList<String>();
result.add(database0Config.getDatabaseName());
return result;
}
/**
* BETWEEN 条件放回的数据源
* @param collection
* @param shardingValue
* @return
*/
@Override
public Collection<String> doBetweenSharding(Collection collection, ShardingValue shardingValue) {
List<String> result = new ArrayList<String>();
result.add(database0Config.getDatabaseName());
return result;
}
}
五、数据表分配算法
package com.lzx.code.codedemo.config;
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;
import com.google.common.collect.Range;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.LinkedHashSet;
/**
* 描述: 数据表分配算法的实现
*
* @Auther: lzx
* @Date: 2019/9/9 16:19
*/
@Component
public class TableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {
/**
* = 条件时候返回的数据源
* @param collection
* @param shardingValue
* @return
*/
@Override
public String doEqualSharding(Collection<String> collection, ShardingValue<Long> shardingValue) {
for (String eaach:collection) {
Long value = shardingValue.getValue();
value = value >> 22;
if(eaach.endsWith(value％10+"")){
return eaach;
}
}
throw new IllegalArgumentException();
}
/**
* IN 条件返回的数据源
* @param tableNames
* @param shardingValue
* @return
*/
@Override
public Collection<String> doInSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
Collection<String> result = new LinkedHashSet<>(tableNames.size());
for (Long value : shardingValue.getValues()) {
for (String tableName : tableNames) {
value = value >> 22;
if (tableName.endsWith(value ％ 10 + "")) {
result.add(tableName);
}
}
}
return result;
}
/**
* BETWEEN 条件放回的数据源
* @param tableNames
* @param shardingValue
* @return
*/
@Override
public Collection<String> doBetweenSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
Collection<String> result = new LinkedHashSet<>(tableNames.size());
Range<Long> range = shardingValue.getValueRange();
for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
for (String each : tableNames) {
Long value = i >> 22;
if (each.endsWith(i ％ 10 + "")) {
result.add(each);
}
}
}
return result;
}
}
六、数据源配置
package com.lzx.code.codedemo.config;
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 com.dangdang.ddframe.rdb.sharding.keygen.DefaultKeyGenerator;
import com.dangdang.ddframe.rdb.sharding.keygen.KeyGenerator;
import org.springframework.beans.factory.annotation.Autowired;
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;
/**
* 描述:数据源配置
*
* @Auther: lzx
* @Date: 2019/9/9 15:21
*/
@Configuration
public class DataSourceConfig {
@Autowired
private Database0Config database0Config;
@Autowired
private DatabaseShardingAlgorithm databaseShardingAlgorithm;
@Autowired
private TableShardingAlgorithm tableShardingAlgorithm;
@Bean
public DataSource getDataSource() throws SQLException {
return buildDataSource();
}
private DataSource buildDataSource() throws SQLException {
//分库设置
Map<String, DataSource> dataSourceMap = new HashMap<>(2);
//添加两个数据库database0和database1
dataSourceMap.put(database0Config.getDatabaseName(), database0Config.createDataSource());
//设置默认数据库
DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap, database0Config.getDatabaseName());
//分表设置，大致思想就是将查询虚拟表Goods根据一定规则映射到真实表中去
TableRule orderTableRule = TableRule.builder("user")
.actualTables(Arrays.asList("user_0", "user_1", "user_2", "user_3", "user_4", "user_5", "user_6", "user_7", "user_8", "user_9"))
.dataSourceRule(dataSourceRule)
.build();
//分库分表策略
ShardingRule shardingRule = ShardingRule.builder()
.dataSourceRule(dataSourceRule)
.tableRules(Arrays.asList(orderTableRule))
.databaseShardingStrategy(new DatabaseShardingStrategy("ID", databaseShardingAlgorithm))
.tableShardingStrategy(new TableShardingStrategy("ID", tableShardingAlgorithm)).build();
DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule);
return dataSource;
}
@Bean
public KeyGenerator keyGenerator() {
return new DefaultKeyGenerator();
}
}
七、开始测试
定义一个实体
package com.lzx.code.codedemo.entity;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.*;
import org.hibernate.annotations.GenericGenerator;
import javax.persistence.*;
/**
* 描述: 用户
*
* @Auther: lzx
* @Date: 2019/7/11 15:39
*/
@Entity(name = "USER")
@Getter
@Setter
@ToString
@JsonIgnoreProperties(ignoreUnknown = true)
@AllArgsConstructor
@NoArgsConstructor
public class User {
/**
* 主键
*/
@Id
@GeneratedValue(generator = "idUserConfig")
@GenericGenerator(name ="idUserConfig" ,strategy="org.kcsm.common.ids.SerialIdGeneratorSnowflakeId")
@Column(name = "ID", unique = true,nullable=false)
@JsonSerialize(using = ToStringSerializer.class)
private Long id;
/**
* 用户名
*/
@Column(name = "USER_NAME",length = 100)
private String userName;
/**
* 密码
*/
@Column(name = "PASSWORD",length = 100)
private String password;
}
定义实体DAO
package com.lzx.code.codedemo.dao;
import com.lzx.code.codedemo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.rest.core.annotation.RepositoryRestResource;
/**
* 描述: 用户dao接口
*
* @Auther: lzx
* @Date: 2019/7/11 15:52
*/
@RepositoryRestResource(path = "user")
public interface UserDao extends JpaRepository<User,Long>,JpaSpecificationExecutor<User> {
}
测试类，插入1000条user数据
package com.lzx.code.codedemo;
import com.lzx.code.codedemo.dao.RolesDao;
import com.lzx.code.codedemo.dao.UserDao;
import com.lzx.code.codedemo.entity.Roles;
import com.lzx.code.codedemo.entity.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class CodeDemoApplicationTests {
@Autowired
private UserDao userDao;
@Autowired
private RolesDao rolesDao;
@Test
public void contextLoads() {
User user = null;
Roles roles = null;
for(int i=0;i<1000;i++){
user = new User(
null,
"lzx"+i,
"123456"
);
roles = new Roles(
null,
"角色"+i
);
rolesDao.save(roles);
userDao.save(user);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
效果：数据被分片存储到0~9的数据表中
来源：https://blog.csdn.net/github_35976996/article/details/100690778
0
投稿猜你喜欢
- 废话不多说了，给大家贴关键代码了，具体代码如下所示：import java.io.File;import java.io.FileOutpu
请求SpringBoot接受前台参数的六种方式，首先因为从前台发送的请求没有界面的话只能是从地址栏发送并且只能是Get请求，为了测试其他的请- 概述本文介绍通过java程序向PDF文档添加图片，以及替换和删除PDF中已有的图片。另外，关于图片的操作还可参考设置PDF 图片背景、设置P
- 如果需要基于键对所需集合排序，就可以使用SortedList<TKey,TValue>类。这个类按照键给元素排序。这个集合中的值
- java对字符串进行utf-8编码我们在调用第三方 API 时，常常会被要求用到路径变量，而路径变量一般都是 utf-8 编码的，因此需要对
- 一、概述数据透视表（Pivot Table）是一种交互式的表，可以进行某些计算，如求和与计数等，可动态地改变透视表版面布置，也可以重新安排行
- Android屏蔽软键盘并且显示光标的实例详解如果是android4.0以下，那么editText.setInputType(InputTy
- springboot集成开发实现商场秒杀加入主要依赖<dependency> <groupId>org.spring
- 1：什么是Socket所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信
- 背景之前在网上发现这个问题public class GenericTest { //方法一 public static <T exte
- 1.背景在java语言中还没有引入枚举类型之前，表示枚举类型的常用模式是声明一组具有int常量。之前我们通常利用public final s
- Lambda 表达式Lambda 表达式是现代 C++ 中最重要的特性之一，而 Lambda 表达式，实际上就是提供了一个类似匿名函数的特性
- nacos升级spring cloud 2020.0无法使用bootstrap.yml之前用spring cloud整合nacos，需要一个
- 本文以Android签名JKS格式的证书为例：package com.test;import java.io.FileInputStream
- 注册中心呢 就是springcloud的一个核心组件 所有微服务的基石 微服务的核心思想就是分布式 所有的服务分开管理 但这些服务分开后该如
- 最近有个需求，我需要获取所有同一类型的定时任务的对象，并自动执行。我想的方案是：直接获取某个接口下面所有的实现类的对象集合，方便以后只需要
- maven项目中在pom.xml中依赖2个jar包，其他的spring的jar包省略：<dependency> &
- 本文实例为大家分享了JFinal使用ajaxfileupload实现图片上传预览的具体代码，供大家参考，具体内容如下1.前端jsp页面核心代
- 随着目前微信越来越火，所以研究微信的人也就越来越多，这不前一段时间，我们公司就让我做一个微信公众号中问卷调查发红包功能，经过一段时间的研究，
- 汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。下面是c#实现汉诺塔示例using System;using System
