ShardingSphere-jdbc 5.5.0 + spring boot 基础配置 - 实战篇

已于 2024-10-06 15:23:59 修改
阅读量1k 收藏 4
点赞数 2
文章标签： spring boot 后端 数据库
于 2024-08-20 16:53:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21903999/article/details/141361173
版权

ShardingSphere-jdbc 5.5.0 + spring boot 基础配置


在这里插入图片描述

环境准备

版本

spring boot 2.7.17
shardingsphere-jdbc 5.5.0
druid 1.2.23

数据库说明

本示例数据库为单机多库schema的架构，以一主一从作为集群演示，转为一主多从数据库集群时，可自定义修改配置。

集群

一主一从：
逻辑主库：ds_basic、ds0000、ds0001（ds_basic为数据简单、量少的元数据库）
逻辑从库：ds0000_slave、ds0001_slave

配置

配置文件

在这里插入图片描述

Maven依赖

         <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>shardingsphere-jdbc</artifactId>
            <version>5.5.0</version>
            <exclusions>
                <exclusion>
                    <groupId>org.apache.shardingsphere</groupId>
                    <artifactId>shardingsphere-test-util</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.yaml</groupId>
            <artifactId>snakeyaml</artifactId>
            <version>2.2</version>
        </dependency>

spring boot配置

application.yml

spring:
  application:
    name: demo
  main:
    allow-bean-definition-overriding: true
  datasource:
    driver-class-name: org.apache.shardingsphere.driver.ShardingSphereDriver
    url: jdbc:shardingsphere:classpath:sharding.yaml

shardingsphere-jdbc配置

自定义配置1：SM4加解密存储数据

shardingsphere 5.5.0移除了sm4算法，两种方式解决：
1、使用官方shardingpshere plugin，找到相关组件依赖引用即可，
2、自己添加sm4算法代码SPI实现。
本文使用方式2.

  1. 增加spi扩展
    在这里插入图片描述
    org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm增加以下代码：
     com.demo.core.encrypt.SM4EncryptAlgorithm
  1. SM4算法代码

package com.demo.core.encrypt;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.SneakyThrows;
import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithm;
import org.apache.shardingsphere.encrypt.spi.EncryptAlgorithmMetaData;
import org.apache.shardingsphere.infra.algorithm.core.context.AlgorithmSQLContext;
import org.apache.shardingsphere.infra.algorithm.core.exception.AlgorithmInitializationException;
import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.Security;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Optional;
import java.util.Properties;
import java.util.Set;

/**
* shardingsphere SM4 encrypt algorithm.
* @author Robin Wang
*/
@EqualsAndHashCode
public final class SM4EncryptAlgorithm implements EncryptAlgorithm {
   
   static {
       Security.addProvider(new BouncyCastleProvider());
   }

   @Getter
   private final EncryptAlgorithmMetaData metaData = new EncryptAlgorithmMetaData(true, true, false);

   private static final String SM4_KEY = "sm4-key";
   
   private static final String SM4_IV = "sm4-iv";
   
   private static final String SM4_MODE = "sm4-mode";
   
   private static final String SM4_PADDING = "sm4-padding";
   
   private static final int KEY_LENGTH = 16;
   
   private static final int IV_LENGTH = 16;
   
   private static final Set<String> MODES = new HashSet<>(Arrays.asList("ECB", "CBC"));
   
   private static final Set<String> PADDINGS = new HashSet<>(Arrays.asList("PKCS5Padding", "PKCS7Padding"));
   
   private byte[] sm4Key;
   
   private byte[] sm4Iv;
   
   private String sm4ModePadding;
   
   @Override
   public void init(final Properties props) {
       String sm4Mode = createSm4Mode(props);
       String sm4Padding = createSm4Padding(props);
       sm4ModePadding = "SM4/" + sm4Mode + "/" + sm4Padding;
       sm4Key = createSm4Key(props);
       sm4Iv = createSm4Iv(props, sm4Mode);
   }
   
   private String createSm4Mode(final Properties props) {
       ShardingSpherePreconditions.checkState(props.containsKey(SM4_MODE), () -> new AlgorithmInitializationException(this, "%s can not be null or empty", SM4_MODE));
       String result = String.valueOf(props.getProperty(SM4_MODE)).toUpperCase();
       ShardingSpherePreconditions.checkState(MODES.contains(result), () -> new AlgorithmInitializationException(this, "Mode must be either CBC or ECB"));
       return result;
   }
   
   private byte[] createSm4Key(final Properties props) {
       ShardingSpherePreconditions.checkState(props.containsKey(SM4_KEY), () -> new AlgorithmInitializationException(this, "%s can not be null", SM4_KEY));
       byte[] result = ByteUtils.fromHexString(String.valueOf(props.getProperty(SM4_KEY)));
       ShardingSpherePreconditions.checkState(KEY_LENGTH == result.length,
               () -> new AlgorithmInitializationException(this, "Key length must be " + KEY_LENGTH + " bytes long"));
       return result;
   }
   
   private byte[] createSm4Iv(final Properties props, final String sm4Mode) {
       if (!"CBC".equalsIgnoreCase(sm4Mode)) {
           return null;
       }
       ShardingSpherePreconditions.checkState(props.containsKey(SM4_IV), () -> new AlgorithmInitializationException(this, "%s can not be null", SM4_IV));
       String sm4IvValue = String.valueOf(props.getProperty(SM4_IV));
       byte[] result = ByteUtils.fromHexString(sm4IvValue);
       ShardingSpherePreconditions.checkState(IV_LENGTH == result.length, () -> new AlgorithmInitializationException(this, "Iv length must be " + IV_LENGTH + " bytes long"));
       return result;
   }
   
   private String createSm4Padding(final Properties props) {
       ShardingSpherePreconditions.checkState(props.containsKey(SM4_PADDING), () -> new AlgorithmInitializationException(this, "%s can not be null", SM4_PADDING));
       String result = String.valueOf(props.getProperty(SM4_PADDING)).toUpperCase().replace("PADDING", "Padding");
       ShardingSpherePreconditions.checkState(PADDINGS.contains(result), () -> new AlgorithmInitializationException(this, "Padding must be either PKCS5Padding or PKCS7Padding"));
       return result;
   }
   
   @Override
   public String encrypt(Object plainValue, AlgorithmSQLContext algorithmSQLContext) {
       return null == plainValue ? null : ByteUtils.toHexString(encrypt(String.valueOf(plainValue).getBytes(StandardCharsets.UTF_8)));
   }
   
   private byte[] encrypt(final byte[] plainValue) {
       return handle(plainValue, Cipher.ENCRYPT_MODE);
   }
   
   @Override
   public Object decrypt(Object cipherValue, AlgorithmSQLContext algorithmSQLContext) {
       return null == cipherValue ? null : new String(decrypt(ByteUtils.fromHexString((String) cipherValue)), StandardCharsets.UTF_8);
   }
   
   private byte[] decrypt(final byte[] cipherValue) {
       return handle(cipherValue, Cipher.DECRYPT_MODE);
   }
   
   @SneakyThrows(GeneralSecurityException.class)
   private byte[] handle(final byte[] input, final int mode) {
       Cipher cipher = Cipher.getInstance(sm4ModePadding, BouncyCastleProvider.PROVIDER_NAME);
       SecretKeySpec secretKeySpec = new SecretKeySpec(sm4Key, "SM4");
       Optional<byte[]> sm4Iv = Optional.ofNullable(this.sm4Iv);
       if (sm4Iv.isPresent()) {
           cipher.init(mode, secretKeySpec, new IvParameterSpec(sm4Iv.get()));
       } else {
           cipher.init(mode, secretKeySpec);
       }
       return cipher.doFinal(input);
   }
   
   @Override
   public String getType() {
       return "SM4";
   }
}
  1. sm4算法yaml配置
  encryptors:
    sm4_encryptor:
      type: SM4
      props:
        sm4-key: 86C63180C2806ED1F43A859DE501215C
        sm4-mode: ECB
        sm4-padding: PKCS5Padding

完整的基础配置

sharding.yaml
配置包括：单机模式服务、数据源（加解密）、规则配置：【数据分片、读写分离、数据加密、单表】
待新增补充：混合规则等

mode:
  type: Standalone
  repository:
    type: JDBC
databaseName: demo_db
dataSources:
  ds_basic:
    dataSourceClassName: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/demo_basic?characterEncoding=utf-8&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: Ph9ep971fm14nYaZsLl9LY+MCqX9uJSozYRNgP2VVSj/hbmokn5OC6kpiAA1I0okA9GiDHEo7qHUvRQYYUNZvQ==
    initialSize: 1
    minIdle: 1
    maxActive: 64
    maxWait: 20000
    validationQuery: SELECT 1 FROM DUAL
    validationQueryTimeout: 30000
    minEvictableIdleTimeMillis: 300000
    maxEvictableIdleTimeMillis: 600000
    timeBetweenEvictionRunsMillis: 300000
    testOnBorrow: true
    testWhileIdle: true
    filters: config, stat, wall
    connectProperties:
      connectTimeout: 5000
      socketTimeout: '20000'
      config.decrypt: 'true'
      config.decrypt.key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALZRYgsnvVKPqZTfMOWmmj6OuupFRSk7+Vtqv70cG3y6T3bm+DcQU3zOC993ozbHpmqeODtuLzURhIuXDMyTKW8CAwEAAQ==


  ds0000:
    dataSourceClassName: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/demo_0000?characterEncoding=utf-8&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: Ph9ep971fm14nYaZsLl9LY+MCqX9uJSozYRNgP2VVSj/hbmokn5OC6kpiAA1I0okA9GiDHEo7qHUvRQYYUNZvQ==
    initialSize: 1
    minIdle: 1
    maxActive: 64
    maxWait: 20000
    validationQuery: SELECT 1 FROM DUAL
    validationQueryTimeout: 30000
    minEvictableIdleTimeMillis: 300000
    maxEvictableIdleTimeMillis: 600000
    timeBetweenEvictionRunsMillis: 300000
    testOnBorrow: true
    testWhileIdle: true
    filters: config, stat, wall
    connectProperties:
      connectTimeout: 5000
      socketTimeout: '20000'
      config.decrypt: 'true'
      config.decrypt.key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALZRYgsnvVKPqZTfMOWmmj6OuupFRSk7+Vtqv70cG3y6T3bm+DcQU3zOC993ozbHpmqeODtuLzURhIuXDMyTKW8CAwEAAQ==


  ds0001:
    dataSourceClassName: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/demo_0001?characterEncoding=utf-8&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: Ph9ep971fm14nYaZsLl9LY+MCqX9uJSozYRNgP2VVSj/hbmokn5OC6kpiAA1I0okA9GiDHEo7qHUvRQYYUNZvQ==
    initialSize: 1
    minIdle: 1
    maxActive: 64
    maxWait: 20000
    validationQuery: SELECT 1 FROM DUAL
    validationQueryTimeout: 30000
    minEvictableIdleTimeMillis: 300000
    maxEvictableIdleTimeMillis: 600000
    timeBetweenEvictionRunsMillis: 300000
    testOnBorrow: true
    testWhileIdle: true
    filters: config, stat, wall
    connectProperties:
      connectTimeout: 5000
      socketTimeout: '20000'
      config.decrypt: 'true'
      config.decrypt.key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALZRYgsnvVKPqZTfMOWmmj6OuupFRSk7+Vtqv70cG3y6T3bm+DcQU3zOC993ozbHpmqeODtuLzURhIuXDMyTKW8CAwEAAQ==

  ds0000_slave:
    dataSourceClassName: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.1.88:3306/demo_0000?characterEncoding=utf-8&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: Ph9ep971fm14nYaZsLl9LY+MCqX9uJSozYRNgP2VVSj/hbmokn5OC6kpiAA1I0okA9GiDHEo7qHUvRQYYUNZvQ==
    initialSize: 1
    minIdle: 1
    maxActive: 64
    maxWait: 20000
    validationQuery: SELECT 1 FROM DUAL
    validationQueryTimeout: 30000
    minEvictableIdleTimeMillis: 300000
    maxEvictableIdleTimeMillis: 600000
    timeBetweenEvictionRunsMillis: 300000
    testOnBorrow: true
    testWhileIdle: true
    filters: config, stat, wall
    connectProperties:
      connectTimeout: 5000
      socketTimeout: '20000'
      config.decrypt: 'true'
      config.decrypt.key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALZRYgsnvVKPqZTfMOWmmj6OuupFRSk7+Vtqv70cG3y6T3bm+DcQU3zOC993ozbHpmqeODtuLzURhIuXDMyTKW8CAwEAAQ==
  
  ds0001_slave:
    dataSourceClassName: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.1.88:3306/demo_0001?characterEncoding=utf-8&allowPublicKeyRetrieval=true&useSSL=false
    username: root
    password: Ph9ep971fm14nYaZsLl9LY+MCqX9uJSozYRNgP2VVSj/hbmokn5OC6kpiAA1I0okA9GiDHEo7qHUvRQYYUNZvQ==
    initialSize: 1
    minIdle: 1
    maxActive: 64
    maxWait: 20000
    validationQuery: SELECT 1 FROM DUAL
    validationQueryTimeout: 30000
    minEvictableIdleTimeMillis: 300000
    maxEvictableIdleTimeMillis: 600000
    timeBetweenEvictionRunsMillis: 300000
    testOnBorrow: true
    testWhileIdle: true
    filters: config, stat, wall
    connectProperties:
      connectTimeout: 5000
      socketTimeout: '20000'
      config.decrypt: 'true'
      config.decrypt.key: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALZRYgsnvVKPqZTfMOWmmj6OuupFRSk7+Vtqv70cG3y6T3bm+DcQU3zOC993ozbHpmqeODtuLzURhIuXDMyTKW8CAwEAAQ==


rules:
# 数据分片
- !SHARDING
  tables:
    t_claim_case_mdtrt:
      actualDataNodes: ds$->{['0000','0001']}.t_claim_case_mdtrt_000$->{0..9}
      tableStrategy:
        standard:
          shardingColumn: transaction_no
          shardingAlgorithmName: t_claim_case_mdtrt_inline
      keyGenerateStrategy:
        column: id
        keyGeneratorName: snowflake
    t_claim_case_info:
      actualDataNodes: ds$->{['0000','0001']}.t_claim_case_info_000$->{0..9}
      tableStrategy:
        standard:
          shardingColumn: transaction_no
          shardingAlgorithmName: t_claim_case_info_inline
      keyGenerateStrategy:
        column: id
        keyGeneratorName: snowflake
   
  defaultShardingColumn: transaction_no
  bindingTables:
    - t_claim_case_mdtrt, t_claim_case_info
  defaultDatabaseStrategy:
    standard:
      shardingColumn: transaction_no
      shardingAlgorithmName: database_inline
  defaultTableStrategy:
    none:
  shardingAlgorithms:
    database_inline:
      type: INLINE
      props:
        algorithm-expression: ds$->{transaction_no[-8..-5]}
    t_claim_case_mdtrt_inline:
      type: INLINE
      props:
        algorithm-expression: t_claim_case_mdtrt_$->{transaction_no[-4..-1]}
    t_claim_case_info_inline:
      type: INLINE
      props:
        algorithm-expression: t_claim_case_info_$->{transaction_no[-4..-1]}
  keyGenerators:
    snowflake:
      type: SNOWFLAKE

#数据加密
- !ENCRYPT
  tables:
    t_claim_case_info:
      columns:
        appl_mobile:
          cipher:
            name: appl_mobile
            encryptorName: sm4_encryptor
        opsnId_no:
          cipher:
            name: opsnId_no
            encryptorName: sm4_encryptor
        rpter_id_no:
          cipher:
            name: rpter_id_no
            encryptorName: sm4_encryptor
        rpter_mobile:
          cipher:
            name: rpter_mobile
            encryptorName: sm4_encryptor
  encryptors:
    sm4_encryptor:
      type: SM4
      props:
        sm4-key: 86C63180C2806ED1F43A859DE501215C
        sm4-mode: ECB
        sm4-padding: PKCS5Padding
# 单表
- !SINGLE
  tables:
    - ds_basic.*

# 读写分离
- !READWRITE_SPLITTING
  dataSources:
    ds0000:
      writeDataSourceName: ds0000
      readDataSourceNames:
        - ds0000_slave
      transactionalReadQueryStrategy: PRIMARY
      loadBalancerName: random
    ds0001:
      writeDataSourceName: ds0001
      readDataSourceNames:
        - ds0001_slave
      transactionalReadQueryStrategy: PRIMARY
      loadBalancerName: random
  loadBalancers:
    random:
      type: RANDOM


props:
  sql-show: true
  max-connections-size-per-query: 5

其他

雪花算法自定义worker.id

集群模式下，不同机器需要配置不同的workerId，适合使用ShardingSphere Proxy集群模式，需要使用第三方配置中心（zookeeper)。
但这会变更架构，且本项目CICD时只有一个war部署weblogic server集群的方式。
因此特沿用ShardingSphere JDBC单机模式，并且启动服务时添加处理自定义随机数的workerId以适应集群机器部署。

1.改造雪花算法代码


package com.demo.core.config;

import cn.hutool.core.util.RandomUtil;
import lombok.Generated;
import lombok.Setter;
import lombok.SneakyThrows;
import org.apache.shardingsphere.infra.algorithm.core.context.AlgorithmSQLContext;
import org.apache.shardingsphere.infra.algorithm.core.exception.AlgorithmExecuteException;
import org.apache.shardingsphere.infra.algorithm.core.exception.AlgorithmInitializationException;
import org.apache.shardingsphere.infra.algorithm.keygen.core.KeyGenerateAlgorithm;
import org.apache.shardingsphere.infra.algorithm.keygen.snowflake.SnowflakeKeyGenerateAlgorithm;
import org.apache.shardingsphere.infra.algorithm.keygen.snowflake.TimeService;
import org.apache.shardingsphere.infra.exception.core.ShardingSpherePreconditions;
import org.apache.shardingsphere.infra.instance.InstanceContext;
import org.apache.shardingsphere.infra.instance.InstanceContextAware;
import org.apache.shardingsphere.infra.instance.workerid.WorkerIdGenerator;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Collection;
import java.util.LinkedList;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;

import static org.apache.shardingsphere.infra.instance.workerid.WorkerIdGenerator.WORKER_ID_KEY;

/**
 * ShardingSphere JDBC 随机workerId雪花算法
 *
 * @date 2024/10/06 13:00
 **/
public class RandomWorkerIdSnowflakeKeyGenerateAlgorithm implements KeyGenerateAlgorithm, InstanceContextAware {
    public static final long EPOCH;

    private static final String MAX_VIBRATION_OFFSET_KEY = "max-vibration-offset";

    private static final String MAX_TOLERATE_TIME_DIFFERENCE_MILLIS_KEY = "max-tolerate-time-difference-milliseconds";

    private static final long SEQUENCE_BITS = 12L;

    private static final long WORKER_ID_BITS = 10L;

    private static final long SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1L;

    private static final long WORKER_ID_LEFT_SHIFT_BITS = SEQUENCE_BITS;

    private static final long TIMESTAMP_LEFT_SHIFT_BITS = WORKER_ID_LEFT_SHIFT_BITS + WORKER_ID_BITS;

    private static final int DEFAULT_VIBRATION_VALUE = 1;

    private static final int MAX_TOLERATE_TIME_DIFFERENCE_MILLIS = 10;

    private static final int DEFAULT_WORKER_ID = 0;

    @Setter
    private static TimeService timeService = new TimeService();

    private final AtomicReference<InstanceContext> instanceContext = new AtomicReference<>();

    private final AtomicInteger sequenceOffset = new AtomicInteger(-1);

    private final AtomicLong sequence = new AtomicLong();

    private final AtomicLong lastMillis = new AtomicLong();

    private Properties props;

    private int maxVibrationOffset;

    private int maxTolerateTimeDifferenceMillis;

    private static final String randomWorkerId = RandomUtil.randomNumbers(3);

    static {
        EPOCH = LocalDateTime.of(2016, 11, 1, 0, 0, 0).toInstant(ZoneId.systemDefault().getRules().getOffset(Instant.now())).toEpochMilli();
    }

    @Override
    public void init(final Properties props) {
        props.setProperty(WorkerIdGenerator.WORKER_ID_KEY, randomWorkerId);
        this.props = props;
        maxVibrationOffset = getMaxVibrationOffset(props);
        maxTolerateTimeDifferenceMillis = getMaxTolerateTimeDifferenceMillis(props);
    }

    private int getMaxVibrationOffset(final Properties props) {
        int result = Integer.parseInt(props.getOrDefault(MAX_VIBRATION_OFFSET_KEY, DEFAULT_VIBRATION_VALUE).toString());
        ShardingSpherePreconditions.checkState(result >= 0 && result <= SEQUENCE_MASK, () -> new AlgorithmInitializationException(this, "Illegal max vibration offset."));
        return result;
    }

    private int getMaxTolerateTimeDifferenceMillis(final Properties props) {
        int result = Integer.parseInt(props.getOrDefault(MAX_TOLERATE_TIME_DIFFERENCE_MILLIS_KEY, MAX_TOLERATE_TIME_DIFFERENCE_MILLIS).toString());
        ShardingSpherePreconditions.checkState(result >= 0, () -> new AlgorithmInitializationException(this, "Illegal max tolerate time difference milliseconds."));
        return result;
    }

    @Override
    public void setInstanceContext(final InstanceContext instanceContext) {
        this.instanceContext.set(instanceContext);
        if (null != instanceContext) {
            instanceContext.generateWorkerId(props);
        }
    }

    @Override
    public Collection<Long> generateKeys(final AlgorithmSQLContext context, final int keyGenerateCount) {
        Collection<Long> result = new LinkedList<>();
        for (int index = 0; index < keyGenerateCount; index++) {
            result.add(generateKey());
        }
        return result;
    }

    private synchronized Long generateKey() {
        long currentMillis = timeService.getCurrentMillis();
        if (waitTolerateTimeDifferenceIfNeed(currentMillis)) {
            currentMillis = timeService.getCurrentMillis();
        }
        if (lastMillis.get() == currentMillis) {
            sequence.set(sequence.incrementAndGet() & SEQUENCE_MASK);
            if (0L == sequence.get()) {
                currentMillis = waitUntilNextTime(currentMillis);
            }
        } else {
            vibrateSequenceOffset();
            sequence.set(sequenceOffset.get());
        }
        lastMillis.set(currentMillis);
        return ((currentMillis - EPOCH) << TIMESTAMP_LEFT_SHIFT_BITS) | ((long) getWorkerId() << WORKER_ID_LEFT_SHIFT_BITS) | sequence.get();
    }

    @SneakyThrows(InterruptedException.class)
    private boolean waitTolerateTimeDifferenceIfNeed(final long currentMillis) {
        if (lastMillis.get() <= currentMillis) {
            return false;
        }
        long timeDifferenceMillis = lastMillis.get() - currentMillis;
        ShardingSpherePreconditions.checkState(timeDifferenceMillis < maxTolerateTimeDifferenceMillis,
                () -> new AlgorithmExecuteException(this, "Clock is moving backwards, last time is %d milliseconds, current time is %d milliseconds.", lastMillis.get(), currentMillis));
        Thread.sleep(timeDifferenceMillis);
        return true;
    }

    private long waitUntilNextTime(final long lastTime) {
        long result = timeService.getCurrentMillis();
        while (result <= lastTime) {
            result = timeService.getCurrentMillis();
        }
        return result;
    }

    private void vibrateSequenceOffset() {
        if (!sequenceOffset.compareAndSet(maxVibrationOffset, 0)) {
            sequenceOffset.incrementAndGet();
        }
    }

    private int getWorkerId() {
        return null == instanceContext.get() ? DEFAULT_WORKER_ID : instanceContext.get().getWorkerId();
    }

    @Override
    public String getType() {
        return "RANDOM_WORKER_ID_SNOWFLAKE";
    }

    @Override
    public boolean isDefault() {
        return true;
    }



}

2.添加SPI
在这里插入图片描述
添加以下代码路径：

com.demo.core.config.RandomWorkerIdSnowflakeKeyGenerateAlgorithm

3.修改雪花算法配置
在这里插入图片描述

王发财233
关注
ShardingSphere 5.x 系列【24】集成 Nacos 配置中心
记录知识、锤炼自我
04-25 566
在之前的所有案例中，都是在classpath目录读取ShardingSphere的配置文件，获取数据源和分片规则，在部署到生产环境时，需要使用外部配置，比如接入远程配置中心。 在ShardingSphere 5.3.0之前的版本，提供了Spring Boot Starter，配置都是在application.yml文件中，所以只需要使用spring.config.import集成配置中心即可。
基于springboot的ShardingSphere5.0.0的分库分表的解决方案之强制分片的实现解决方案(三十九)
笨鸟不会飞
11-21 704
在基于springboot的ShardingSphere5.X的分库分表的解决方案之强制分片的实现解决方案(十九)中我们讲解了基于5.0.0-alpha版的强制分片的解决方案，那么在本章我们将为大家讲解5.0.0版本强制分片的解决方案的实现，看下和旧版的有什么区别 1、执行数据库脚本 我们直接在sharding-db0和sharding-db1上分别执行以下的sql脚本 drop table if exists t_hit0; /*===================================.
SpringBoot3+ShardingJDBC5.5.0 读写分离配置
qq_22855851的博客
05-03 2339
这里我是用一个读库一个写库处理，数据库连接自己填，打印SQL可以开启可以看到读和写走到了不同的库，至于数据分片就不多赘述，我自己也没验证，不过估计在配置文件加入分片规则就可以做到，还有rules的下的配置一定要写SINGLE这个 不然它会报找不到表的错误，还有这个配置目前只有shardingjdbc 5.4.1和5.5.0可以用，其他版本并不通用 请不要混用。那么接下来就是重点了，然后是sharding.yaml的相关配置，因为官方的文档比较碎片化，最后进行校验和处理得出的完整文档。首先导入相关jar包。
shardingsphere-jdbc之Mybatis Interval 分片算法
Lance
02-26 1384
介绍 基于shardingsphere-jdbc 5.1.0 进行单库分表. 时间范围分片算法 类型：INTERVAL 属性名称 数据类型 说明 默认值 datetime-pattern String 分片键的时间戳格式，必须遵循 Java DateTimeFormatter 的格式。例如：yyyy-MM-dd HH:mm:ss - datetime-lower String 时间分片下界值，格式与 datetime-pattern 定义的时间
2024 ShardingSphere-JDBC 保姆级分库分表，读一句就入门！
qq_52462620的博客
08-17 1374
2024 ShardingSphere-JDBC 保姆级分库分表，读一句就入门！ Apache ShardingSphere 是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库
Apache ShardingSphere Proxy5.5.0实现MySQL分库分表与读写分离
流水悠然，任山川引路。
07-25 1655
感谢你的关注，欢迎你评论交流。
Shardingsphere-Proxy 5.5.0部署
m0_63164811的博客
06-19 1309
Shardingsphere-Proxy 5.5.0部署
使用ShardingSphere5.0进行数据库水平拆分过程以及所踩的坑
dhaibo1986的专栏
09-23 1502
在学习过ShardingSphere-JDBC相关的操作之后，现在使用其对数据库进行水平拆分。 1.环境准备 1.版本信息 mysql的版本： [root@m161p114 sql]$ mysql -uroot -pmysql; mysql: [Warning] Using a password on the command line interface can be insecure. Welcome to the MySQL monitor. Commands end with ; or \g. Yo
Shardingsphere-Proxy 5.5.0数据迁移
m0_63164811的博客
06-24 1253
Shardingsphere-Proxy 5.5.0数据迁移
【经验总结】ShardingSphere5.2.1 + Springboot 分库分表 快速开始
Xcong_Zhu的博客
08-08 1638
Apache ShardingSphere （本文后续简称“SS”）是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。它站在数据库的上层视角，关注它们之间的协作多于数据库自身。ShardingSphere-JDBC 定位为。
shardingsphere-jdbc之JPA分库
Lance
02-20 943
介绍 基于shardingsphere-jdbc进行数据库分库。水平分片又称为横向拆分。 相对于垂直分片，它不再将数据根据业务逻辑分类，而是通过某个字段（或某几个字段），根据某种规则将数据分散至多个库或表中，每个分片仅包含数据的一部分。 例如：根据主键分片，偶数主键的记录放入 0 库（或表），奇数主键的记录放入 1 库（或表） 1. maven项目依赖 <dependencies> <dependency> <groupId>org.ap
升级SpringBoot集成sharding-jdbc报shardingsphere.shardingjdbc.jdbc.unsupported.AbstractUnsupportedOperatio
DN金猿的博客
06-07 270
该异常的意思是功能不支持的意思，就是`sharding-jdbc`没有完全实现Datasouce接口规范导致功能不足。刚开始以为是mysql驱动版本低不支持，于是升级了mysql驱动版本，启动还是报这个错。也可能是阿里DruidDataSource数据池版本低，于是又升级了Druid数据池的版本，依旧是报这个错。后来又升级了shardingjdbc的版本，虽然不报这个错了，但是报了个没有配置sqlSessionFactory的错误。
Shardingsphere 4.1.1 版本坑
wangzhe969的博客
09-12 1672
SELECT COUNT(*) FROM ( SELECT XXX FROM XXX r LEFT JOIN YYY d ON r.id = d.resource_position_id AND d.tenant_code = '10001' WHERE 1 = 1 AND r.custom_id = ? AND r.is_deleted = 'N' AND r.tenant_code = '10001' GROUP BY r.id ...
SpringBoot入门实战：SpringBoot整合Apache ShardingSphere
AI天才研究院
11-10 173
1.背景介绍 Apache ShardingSphere是一个开源的分布式数据库中间件项目，其定位于企业级的高性能解决方案中，充分考虑了横向扩展性、高可用性、最终一致性等指标。它通过无中心、无共享、水平扩展的架构，极大的扩大了商用SaaS业务的容量，逐渐成为最热门的开源分布式数据库中间件之一。作为国内最受欢迎的开源分布式数据库中间件之一，Spring
springboot3.x集成shardingsphere-5.5.0 + nacos远程配置之实战篇
最新发布
dragonzard的专栏
08-29 293
gitee代码仓库：shardingsphere-5.5.0-example: springboot3.x + shardingsphere-5.5.0 + nacos-2.3.0 + mybatis-plus运行环境：jdk17/jdk21 + mysql8.0github代码仓库：GitHub - DRAGON-Yeah/shardingsphere-5.5.0-example: springboot3.x + shardingsphere-5.5.0 + nacos-2.3.0 + mybatis-p
Shardingjdbc 和 Sharding-sphere
weixin_35688029的博客
02-12 1476
Spring Boot版 Sharding JDBC 读写分离示列  https://github.com/yinjihuan/spring-cloud/tree/master/fangjia-sjdbc-read-write-springboot   sharding-sphere   https://www.jianshu.com/p/952108f777a3 https://www...
ShardingSphere-JDBC5.0正式版读写分离配置示例
MrXionGe的博客
12-14 3312
前言 2020年10月，第一次使用shardingsphere-jdbc5版本实现读写分离。只不过当时只是5.0.0-alpha版本，还不算是满血版。 2021年11月，发布了5.0.0正式版，带来相当多的新特性，比如我们很需要的“支持解析MySQL UNION/UNION ALL语句”。 更多特性参考release note：https://github.com/apache/shardingsphere/releases 目前生产环境已升级5.0.0，且稳定运行。 升级过程中发现部分API存在变动，所以
shardingsphere-jdbc（1）：实现数据库主从同步、读写分离
weixin_46075209的博客
05-27 1199
本文主要介绍mysql分库环境搭建、数据库主从同步、shardingsphere-jdbc实现数据读写分离
vmware-vim-all-5.5.0.iso
05-12
vmware-vim-all-5.5.0.iso 是VMware vCenter Server 5.5的ISO文件。VMware vCenter Server是一个基于服务器的应用程序，它允许用户集中管理和监控虚拟化环境中的虚拟机和物理主机，提供高可用性、负载均衡和数据保护等功能。它与VMware的其他产品（如VMware ESXi和VMware vSphere）集成，并且可以扩展到包括多个主机和多个虚拟机。使用 vmware-vim-all-5.5.0.iso 文件，用户可以轻松部署和安装vCenter Server 5.5。该文件包括了所有必需的文件和组件，用户只需将其载入到虚拟机或物理服务器上进行安装即可。安装完成后，用户可以通过Web客户端或vSphere客户端进行远程管理和监控。vmware-vim-all-5.5.0.iso 是一个高度可靠的工具，可为用户简化虚拟环境的管理和监控，提高工作效率和系统性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值