上亿数据解决方案，SpringBoot整合Sharding Jdbc+Mysql，雪花算法做分布式主键

最新推荐文章于 2023-12-22 14:18:17 发布
置顶 最新推荐文章于 2023-12-22 14:18:17 发布
阅读量1.2k 收藏 1
点赞数 2
文章标签： java SpringBoot Mybatis java 分库分表 sharding-jdb Sharding JDBC MySQL spring 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38926472/article/details/107130175
版权

SpringBoot整合 Sharding Jdbc

Sharding Jdbc介绍

就是一款数据库中间件,可以做分库分表、读写分离专用，属于Apache基金会的顶级项目

pom依赖

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <spring-boot.version>2.1.3.RELEASE</spring-boot.version>
    <spring.version>5.1.5.RELEASE</spring.version>
    <mybatisplus.version>3.0.7.1</mybatisplus.version>
    <mysql.version>5.1.38</mysql.version>
    <druid.version>1.1.13</druid.version>
    <shard-jdbc.version>3.1.0</shard-jdbc.version>
    <fastjson.version>1.2.47</fastjson.version>
    <pagehelper.version>1.2.5</pagehelper.version>
</properties>
<dependencies>
    <dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
    <version>5.2.3</version>
</dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.16.20</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>${spring-boot.version}</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
        <version>${spring-boot.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <version>${spring-boot.version}</version>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- 使用XA事务时，需要引入此模块 -->
    <!--<dependency>-->
        <!--<groupId>org.apache.shardingsphere</groupId>-->
        <!--<artifactId>shardingsphere-transaction-xa-core</artifactId>-->
        <!--<version>${shard-jdbc.version}</version>-->
    <!--</dependency>-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>${mybatisplus.version}</version>
        <exclusions>
            <exclusion>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-generator</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus</artifactId>
        <version>${mybatisplus.version}</version>
    </dependency>
    <dependency>
        <groupId>com.github.pagehelper</groupId>
        <artifactId>pagehelper-spring-boot-starter</artifactId>
        <version>${pagehelper.version}</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>${druid.version}</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>${fastjson.version}</version>
    </dependency>
    <dependency>
        <groupId>io.shardingsphere</groupId>
        <artifactId>sharding-jdbc-core</artifactId>
        <version>${shard-jdbc.version}</version>
    </dependency>
    <dependency>
        <groupId>io.shardingsphere</groupId>
        <artifactId>sharding-transaction-spring</artifactId>
        <version>3.1.0</version>
    </dependency>

整合spring的配置

package com.shard.jdbc.config;

import io.shardingsphere.api.config.rule.ShardingRuleConfiguration;
import io.shardingsphere.api.config.rule.TableRuleConfiguration;
import io.shardingsphere.api.config.strategy.StandardShardingStrategyConfiguration;
import io.shardingsphere.core.keygen.DefaultKeyGenerator;
import io.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
@Configuration
public class ShardingDataSourceConfig {
@Resource
private ShardJdbcCon shardJdbcCon;
/**
* Shard-JDBC 分库配置
*/
@Bean
public DataSource dataSource () throws Exception {
ShardingRuleConfiguration shardJdbcConfig = new ShardingRuleConfiguration();
shardJdbcConfig.getTableRuleConfigs().add(getTableRule01());
// shardJdbcConfig.getTableRuleConfigs().add(getTableRule02());
shardJdbcConfig.setDefaultDataSourceName(“ds_0”);
Properties prop = new Properties();
prop.setProperty(“sql.show”,“true”);//开启日志sql
prop.put(“executor.size”,“100”);//sharding 线程池
Map<String,DataSource> dataMap = new LinkedHashMap<>() ;
String prefix=“ds_”;
String data=“shard_”;
String url=“jdbc:mysql://localhost:3306/%s?useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false”;
for (int i = 0; i <DataSourceConstant.DATABASE_COUNT ; i++) {
String s=String.format(url,data+i);
dataMap.put(prefix+i,shardJdbcCon.dataOneSource(s));
}
return ShardingDataSourceFactory.createDataSource(dataMap, shardJdbcConfig, new HashMap<>(), prop);
}

/**
 * Shard-JDBC 分表配置
 */
private static TableRuleConfiguration getTableRule01() {
    TableRuleConfiguration result = new TableRuleConfiguration();
    result.setLogicTable("table_one");
    result.setActualDataNodes(DataSourceConstant.get());
    DefaultKeyGenerator defaultKeyGenerator=new DefaultKeyGenerator();
    result.setKeyGenerator(defaultKeyGenerator);
    result.setKeyGeneratorColumnName("id");
    result.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("phone", new DataSourceAlg()));
    result.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("phone", new TableOneAlg()));
    return result;
}

}

配置分库分表的算法

package com.shard.jdbc.config;

import com.shard.jdbc.utils.HashUtil;
import io.shardingsphere.api.algorithm.sharding.PreciseShardingValue;
import io.shardingsphere.api.algorithm.sharding.standard.PreciseShardingAlgorithm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;

/**

  • 数据库映射计算
    */
    public class DataSourceAlg implements PreciseShardingAlgorithm {

    private static Logger LOG = LoggerFactory.getLogger(DataSourceAlg.class);
    @Override
    public String doSharding(Collection names, PreciseShardingValue value) {
    LOG.debug(“分库算法参数 {},{}”,names,value);
    int hash = HashUtil.getIndex(DataSourceConstant.DATABASE_COUNT,value.getValue());
    return “ds_” + hash;
    }
    }

package com.shard.jdbc.config;

import com.shard.jdbc.utils.HashUtil;
import io.shardingsphere.api.algorithm.sharding.PreciseShardingValue;
import io.shardingsphere.api.algorithm.sharding.standard.PreciseShardingAlgorithm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;

/**

  • 分表算法
    */
    public class TableOneAlg implements PreciseShardingAlgorithm {

    private static Logger LOG = LoggerFactory.getLogger(TableOneAlg.class);

    /**

    • 该表每个库分5张表
      */
      @Override
      public String doSharding(Collection names, PreciseShardingValue value) {
      LOG.debug(“分表算法参数 {},{}”,names,value);
      int hash = HashUtil.getIndex(DataSourceConstant.TABLE_COUNT,String.valueOf(value.getValue()));
      return “table_one_”+ hash;
      }
      }

生成数据库表配置

这里使用的flyway生成结合存储过程

package com.shard.jdbc.config;

import io.shardingsphere.shardingjdbc.jdbc.core.datasource.ShardingDataSource;
import lombok.extern.slf4j.Slf4j;
import org.flywaydb.core.api.configuration.ClassicConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.util.Map;

@Component
@Slf4j
public class FlywayInit {
@Resource
private ShardingDataSource dataSource;

@Bean
public void flyway2() {
    Map<String, DataSource> dataSourceMap = dataSource.getDataSourceMap();
    for (Map.Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
        ClassicConfiguration configuration = new ClassicConfiguration();
        configuration.setBaselineOnMigrate(true);
        configuration.setDataSource(entry.getValue());
        configuration.setCleanOnValidationError(true);
        org.flywaydb.core.Flyway flyway = new org.flywaydb.core.Flyway(configuration);
        flyway.migrate();
    }

}

}

//存储过程代码:

DELIMITER $$

DROP PROCEDURE IF EXISTS pro_TableCreate$$

CREATE PROCEDURE pro_TableCreate(
)
BEGIN
DECLARE i INT;
DECLARE table_name VARCHAR(20);
SET i = 0;

WHILE i<25 DO
#为了使表名成为xxx00这样的格式加的条件判断
IF i<10 THEN
SET table_name = CONCAT(‘table_one_’,i);
ELSE
SET table_name = CONCAT(‘table_one_’,i);
END IF;

SET @csql = CONCAT(
'CREATE TABLE ‘,table_name,’(
id bigint NOT NULL auto_increment COMMENT"主键ID",
phone varchar(20) comment"注释",
back_one varchar(50) comment"注释",
back_two varchar(50) comment"注释",
back_three varchar(50) comment"注释",

PRIMARY KEY(id)
)ENGINE=Innodb default charset=utf8;’
);

PREPARE create_stmt FROM @csql;
EXECUTE create_stmt;
SET i = i+1;
END WHILE;

END$$
DELIMITER ;
call pro_TableCreate();

哈希一致性算法

主要用来做哈希路由使用。
package com.shard.jdbc.utils;

import org.springframework.util.CollectionUtils;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

public class HashUtil {
/**
* bkd一致性哈希算法
*
* @param str
* @return
*/
public static int bkdrhash(String str) {
final int seed = 131;

    int hash = 0;

    for (int i = 0; i < str.length(); i++) {
        hash = hash * seed + (int) str.charAt(i);
    }

    return hash & 0x7FFFFFFF;
}

/**
 * pjw一致性哈希算法
 *
 * @param str
 * @return
 */
public static int pjwHash(String str) {
    int BitsInUnignedInt = 32;
    int ThreeQuarters = 24;
    int OneEighth = 4;
    int HighBits = (int) (0xFFFFFFFF) << (BitsInUnignedInt - OneEighth);
    int hash = 0;
    int test = 0;

    for (int i = 0; i < str.length(); i++) {
        hash = (hash << OneEighth) + (int) str.charAt(i);
        if ((test = hash & HighBits) != 0) {
            hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
        }
    }

    return hash & 0x7FFFFFFF;
}

/**
 * rs一致性哈希算法
 *
 * @param value
 * @return
 */
public static int rsHash(String value) {
    int one = 378551;
    int two = 63689;
    int hash = 0;
    for (int i = 0; i < value.length(); i++) {
        hash = hash * two + value.charAt(i);
        two = two * one;
    }
    return (hash & 0x7FFFFFFF);
}

/**
 * 在分布式服务中，获取路由
 *
 * @param num
 * @param str
 * @return
 */
public static int getIndex1(Integer num, String str) {
    return pjwHash(str) % num;
}

public static int getIndex(Integer num, String str) {
    return rsHash(str) % num;
}

/**
 * 计算能均匀分布的数据库数量和表数量
 * 默认为10000个数,需要手动选择符合条件的数据库数量和表数量: 数据库数量*表数量=250
 * @param x
 * @param y
 * @return
 */
public static Map<String, String> cal(int x, int y) {
    Map<String, String> result = new TreeMap<>();
    for (int c = 1; c < x; c++) {
        for (int d = 1; d < y; d++) {
            Map<String, Integer> map =getCountMap(x,y);
            List<Integer> result4 = map.values().stream().filter(e -> e.equals(0))
                    .collect(Collectors.toList());
            if (CollectionUtils.isEmpty(result4)) {
                result.put(c + "" + d, c + "$" + d);
            }
        }
    }
    return result;
}

/**
 * 统计分布的总数量
 * @param a
 * @param b
 * @return
 */

public static Map<String,Integer> getCountMap(int a,int b){
Map<String, Integer> map = new HashMap<>();
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
String s = i + “” + j;
map.put(s, 0);
}
}
for (int i = 0; i < 10000; i++) {
int data = getIndex(a, String.valueOf(i));
int col = getIndex(b, String.valueOf(i));
String s = data + “” + col;
int count = map.get(s) + 1;
map.put(s, count);
}
// map.forEach((x, y) -> {
// System.out.println(“key=” + x + " value=" + y);
// });
return map;
}
}

配置分库数量和每个数据库的表数量

package com.shard.jdbc.config;

public class DataSourceConstant {
public static Integer DATABASE_COUNT=11;
public static Integer TABLE_COUNT=23;
public static String get(){
String s=“ds_KaTeX parse error: Expected '}', got 'EOF' at end of input: ….%s}.table_one_{0…%s}”;
String endD=String.valueOf(DATABASE_COUNT-1);
String table=String.valueOf(TABLE_COUNT-1);
System.out.println(String.format(s,endD,table));
return String.format(s,endD,table);
}
}

效果图展示

在这里插入图片描述这里我使用了11个数据库，23张表，HashUtils方法可以计算250张表如果要均匀分配需要几个库并且每个库几张表。

在这里插入图片描述

完整的项目链接下载地址

csdn下载:https://download.csdn.net/download/qq_38926472/12635187
github地址:https://github.com/yanhua0/shard-jdbc

夏天的风乀
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Sharding-Jdbc 分布式主键（雪花算法）
weixin_39195030的博客
05-24 2234
实现动机 传统数据库软件开发中，主键自动生成技术是基本需求。而各个数据库对于该需求也提供了相应的支持，比如Mysql的自增键，Oracle的自增序列等。数据分片后，不同数据节点生成全局唯一主键是非常棘手的问题。同一逻辑表内的不同实际表之间的自增键由于无法互相感知而生成重复主键。虽然可以通过约束主键自增长初始值和步长的方式来避免碰撞，但需引入额外的运维规则，使解决方案缺乏完整性和可扩展性。 目前有许多第三方解决方案可以完美解决这个问题，如UUID等依靠特定算法自生成不重复键，或者通过引入主键生成服务等。但也正
Sharding-JDBC笔记02-Snowflake雪花算法实战
hecr_mingong的博客
03-27 2414
1.坑 分布式部署就需要分配不同的workId, 如果workId相同，可能会导致⽣成的id相同 分布式情况下，需要保证各个系统时间⼀致，如果服务器的时钟回拨，就会导致⽣成的 id 重复 2.解决方法 application.properties文件中配置wordId #配置workId spring.shardingsphere.sharding.tables.product_order.key-generator.props.work.id=1 雪花算法配置： 方法一：实体类配置雪花算法 @Dat
使用shardingJDBC中的雪花算法生成id
qq_36042938的博客
11-02 878
使用sharding-jdbc中的使用IP后几位来做workId，但在某些情况下会出现生成重复ID的情况。分布式部署就需要分配不同的workId, 如果workId相同，可能会导致⽣成的id相同。分布式情况下，需要保证各个系统时间⼀致，如果服务器的时钟回拨，就会导致⽣成的 id 重复。方式二：使用Sharding-Jdbc配置文件，注释DO类里面的id分配策略。生成的 id 中包含有时间戳，所以生成的 id按照时间递增。部署了多台服务器，需要保证系统时间⼀样，机器编号不⼀样。
sharding jdbc 的雪花算法中的属性worker.id和max.vibration.offset
zhutao_java的专栏
07-13 4950
雪花算法生成的id总共64位8个字节，结构如下: 符号位 时间位 工作机器标识位 序列位 1位(固定位0) 41位 10位 12位 worker.id sharding jdbc 4.1.1使用雪花算法生成分布式id时，会使用到属性work.id表示机器标识位，取值范围[0,1024)，配置示例如下： sharding: tables: user: actual-data-nodes: ds$-..
【mk】sharding - Jdbc 分布式全局ID（雪花算法） Springboot 、 自定义分片策略
qiu7213的博客
09-02 2560
UUID SNOWFLAKE 雪花算法 UUID uuid是生成32位长的字符串，一般作为ID ，不建议使用 字符串作为主键 SNOWFLAKE 雪花算法 配置 1. 首先指定数据库中的哪个字段为主键 spring.shardingsphere.sharding.tables.shard.key-generator.column=id 2. 指定主键的生成策略 spring.shardingsphere.sharding.tables.shard.key-generato.
Spring Boot中整合Sharding-JDBC
05-03
在Spring Boot应用中整合Sharding-JDBC，是为了实现数据库的分片和分布式处理，从而提高系统的数据处理能力和可扩展性。Sharding-JDBC是Apache ShardingSphere项目的一部分，它作为一个轻量级的Java框架，无需额外...
Sharding-JDBC使用案例-分库分表
03-23
4. **事务管理**：虽然Sharding-JDBC不支持分布式事务，但它提供了本地事务和X-A协议的补偿型事务两种解决方案，以满足不同场景的需求。 5. **兼容性**：Sharding-JDBC兼容各种主流的关系型数据库，如MySQL、Oracle...
mysql千万级数据脚本测试shardingjdbc-course.zip
11-30
本案例涉及的是一个针对MySQL数据库的千万级数据脚本测试，使用了ShardingJDBC这一分布式数据管理框架。接下来，我们将深入探讨相关知识点。 首先，MySQL是一个广泛使用的开源关系型数据库管理系统，其在处理大量...
sharding-jdbc-demo:基于sharding-jdbc实现的各种分库分表、读写分离、柔性事务、分布式主键、分布式治理等示例，持续更新中。。
05-18
作者简介: Adam Lu(刘亚壮)，高级软件架构师，Java编程专家，开源分布式消息引擎Mysum发起者、首席架构师及开发者，Android开源消息组件Android-MQ独立...sharding-jdbc的各种实现示例，持续更新中。。。 项目结构简述
mysql分库分表sharding-jdbc-sharding-jdbc-demo.zip
11-07
Sharding-JDBC是阿里巴巴开源的一款轻量级Java框架，它可以在不修改现有业务代码的情况下，实现数据的分布式处理。这个"mysql分库分表sharding-jdbc-sharding-jdbc-demo.zip"压缩包提供的就是一个使用Sharding-JDBC...
shardingsphere源码解析
qq_36851469的博客
06-22 1521
分库分表源码分析
Spring-boot使用Jdbc连接Mysql数据库
qq_37133859的博客
07-09 384
1.导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> &lt..
使用flyway和shardingsphere报错了
m350058411的博客
09-26 1672
使用mybatis-plus加sharding-jdbc报错了 line 1:96 no viable alternative at input ‘UNION’ line 1:96 mismatched input ‘UNION’ expecting {TRUNCATE, POSITION, VIEW, AS, ANY, OFFSET, BEGIN, COMMIT, ROLLBACK, SAVEPOINT, BOOLEAN, DATE, TIME, TIMESTAMP, YEAR, QUARTER, MON
ShardingSphere--Spring boot启动时在ShardingDataSource加载数据库表元数据卡死(慢)的问题
热门推荐
qq_41056506的博客
08-19 1万+
记一次在使用ShardingSphere出现的问题。 先说下项目的环境：Spring Boot 2.2.9，ShardingSphere 4.1.1。 接下来看下问题现象，不报错就是卡死在加载表元数据那布，项目直接起不来，一直在处理表元数据的加载。 ![image.png](https://img-blog.csdnimg.cn/img_convert/d0b790579c7e248bc5ac023b9940c793.png#clientId=ua3f7899f-817c-4&from=paste&
【踩坑】ShardingJdbc实现自动生成主键时，根据雪花算法生成的主键值存放在别的字段上了
最新发布
MS_SONG的博客
12-22 594
ShardingJdbc实现自动生成主键时，根据雪花算法生成的主键值存放在别的字段上了
SpringBoot项目连接MySQL数据库
m0_67401660的博客
08-25 3833
本篇基于MySQL数据库 8.0.29版本进行说明，需要提前安装MySQL数据库。
MySQL第十二讲：ShardingJDBC详解
Jet_qi的博客
09-19 712
互联网业务兴起之后，海量用户加上海量数据的特点，单个数据库服务器已经难以满足业务需要，必须考虑数据库集群的方式来提升性能。高性能数据库集群的`第一种方式是“读写分离”`，`第二种方式是“数据库分片”`。
ruoyi-vue分离版3.8.3整合shardingsphere分库分表5.2.1
rocker2000的博客
11-15 3445
ruoyi-vue分离版3.8.3整合shardingsphere分库分表5.2.1
数据库分库分表（二）shardingjdbc配置文件
w_t_y_y的博客
12-07 6792
一、
Apache ShardingSphere：分布式数据库中间件解决方案
"Apache ShardingSphere 是一套开源的分布式数据库中间件解决方案，包含了Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）三款产品，提供了数据分片、分布式事务和数据库治理功能，适用于各种应用场景。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夏天的风乀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值