spring boot项目整合 sharding jdbc 实现按日期(String)水平分表

于 2024-10-08 15:30:58 发布
阅读量660 收藏 5
点赞数 4
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xia66zz/article/details/142760496
版权

基于原有项目 对check_log  push_log 和 receives表根据日期字段(字段类型为varchar) 按日分表。

以check_log 为例，以下是check_date格式，注意他是varchar

正因为他是varchar 类型 ，所有需要用到精准分片和范围分片，配置文件如下。

配置文件

spring.shardingsphere.enabled=true
spring.shardingsphere.props.sql.show=true
spring.main.allow-bean-definition-overriding=true
spring.shardingsphere.datasource.names=sharding
spring.shardingsphere.datasource.sharding.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.sharding.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.sharding.url=jdbc:mysql://localhost:3306/test
spring.shardingsphere.datasource.sharding.username=root
spring.shardingsphere.datasource.sharding.password=mima

spring.shardingsphere.sharding.tables.check_log.actual-data-nodes=sharding.check_log
spring.shardingsphere.sharding.tables.check_log.table-strategy.standard.sharding-column=check_date
spring.shardingsphere.sharding.tables.check_log.table-strategy.standard.precise-algorithm-class-name=com.example.demo.test.TimeShardingAlgorithm
spring.shardingsphere.sharding.tables.check_log.table-strategy.standard.range-algorithm-class-name=com.example.demo.test.TimeShardingAlgorithm


spring.shardingsphere.sharding.tables.push_log.actual-data-nodes=sharding.push_log
spring.shardingsphere.sharding.tables.push_log.table-strategy.standard.sharding-column=push_date
spring.shardingsphere.sharding.tables.push_log.table-strategy.standard.precise-algorithm-class-name=com.example.demo.test.TimeShardingAlgorithm
spring.shardingsphere.sharding.tables.push_log.table-strategy.standard.range-algorithm-class-name=com.example.demo.test.TimeShardingAlgorithm


spring.shardingsphere.sharding.tables.receives.actual-data-nodes=sharding.receives
spring.shardingsphere.sharding.tables.receives.table-strategy.standard.sharding-column=create_time
spring.shardingsphere.sharding.tables.receives.table-strategy.standard.precise-algorithm-class-name=com.example.demo.test.TimeShardingAlgorithm
spring.shardingsphere.sharding.tables.receives.table-strategy.standard.range-algorithm-class-name=com.example.demo.test.TimeShardingAlgorithm

spring 工具类

package com.example.demo.test;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

/**
 * <p> @Title SpringUtil
 * <p> @Description Spring工具类
 */
@Component
public class SpringUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext = null;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtil.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return SpringUtil.applicationContext;
    }

    public static <T> T getBean(Class<T> cla) {
        return applicationContext.getBean(cla);
    }

    public static <T> T getBean(String name, Class<T> cal) {
        return applicationContext.getBean(name, cal);
    }

    public static String getProperty(String key) {
        return applicationContext.getBean(Environment.class).getProperty(key);
    }
}

分片表缓存枚举类

package com.example.demo.test;

import java.util.*;

/**
 * <p> @Title ShardingTableCacheEnum
 * <p> @Description 分片表缓存枚举
 */
public enum ShardingTableCacheEnum {


    CHECKLOG("check_log", new HashSet<>()),

    PUSHLOG("push_log", new HashSet<>()),

    RECEIVES("receives", new HashSet<>());

    /**
     * 逻辑表名
     */
    private final String logicTableName;
    /**
     * 实际表名
     */
    private final Set<String> resultTableNamesCache;

    private static Map<String, ShardingTableCacheEnum> valueMap = new HashMap<>();

    static {
        Arrays.stream(ShardingTableCacheEnum.values()).forEach(o -> valueMap.put(o.logicTableName, o));
    }

    ShardingTableCacheEnum(String logicTableName, Set<String> resultTableNamesCache) {
        this.logicTableName = logicTableName;
        this.resultTableNamesCache = resultTableNamesCache;
    }

    public static ShardingTableCacheEnum of(String value) {
        return valueMap.get(value);
    }

    public String logicTableName() {
        return logicTableName;
    }

    public Set<String> resultTableNamesCache() {
        return resultTableNamesCache;
    }

    public static Set<String> logicTableNames() {
        return valueMap.keySet();
    }

    @Override
    public String toString() {
        return "ShardingTableCacheEnum{" +
                "logicTableName='" + logicTableName + '\'' +
                ", resultTableNamesCache=" + resultTableNamesCache +
                '}';
    }
}

分片规则实现类

package com.example.demo.test;

import cn.hutool.core.date.DateUtil;
import com.example.demo.utils.DateUtils;
import com.google.common.collect.Range;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.RangeShardingValue;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.function.Function;

/**
 * 按天分片
 */
@Slf4j
public class TimeShardingAlgorithm implements PreciseShardingAlgorithm<String>, RangeShardingAlgorithm<String> {

    /**
     * 精准分片
     *
     * @param tableNames           对应分片库中所有分片表的集合
     * @param preciseShardingValue 分片键值，其中 logicTableName 为逻辑表，columnName 分片键，value 为从 SQL 中解析出来的分片键的值
     * @return 表名
     */
    @Override
    public String doSharding(Collection<String> tableNames, PreciseShardingValue<String> preciseShardingValue) {
        String logicTableName = preciseShardingValue.getLogicTableName();
        ShardingTableCacheEnum logicTable = ShardingTableCacheEnum.of(logicTableName);
        if (logicTable == null) {
            log.error(">>>>>>>>>> 【ERROR】数据表类型错误，请稍后重试，logicTableNames：{}，logicTableName:{}",
                    ShardingTableCacheEnum.logicTableNames(), logicTableName);
            throw new IllegalArgumentException("数据表类型错误，请稍后重试");
        }

        log.info(">>>>>>>>>> 【INFO】精确分片，节点配置表名：{}，数据库缓存表名：{}", tableNames, logicTable.resultTableNamesCache());

        String dateTime = preciseShardingValue.getValue();
        String date = dateTime.replaceAll("-", "_");

        String resultTableName = logicTableName + "_" + date;
        // 检查分表获取的表名是否存在，不存在则自动建表

        return ShardingAlgorithmTool.getShardingTableAndCreate(logicTable.logicTableName(), resultTableName);
    }

    /**
     * 范围分片
     *
     * @param tableNames         对应分片库中所有分片表的集合
     * @param rangeShardingValue 分片范围
     * @return 表名集合
     */
    @Override
    public Collection<String> doSharding(Collection<String> tableNames, RangeShardingValue<String> rangeShardingValue) {
        String logicTableName = rangeShardingValue.getLogicTableName();
        ShardingTableCacheEnum logicTable = ShardingTableCacheEnum.of(logicTableName);
        if (logicTable == null) {
            log.error(">>>>>>>>>> 【ERROR】逻辑表范围异常，请稍后重试，logicTableNames：{}，logicTableName:{}",
                    ShardingTableCacheEnum.logicTableNames(), logicTableName);
            throw new IllegalArgumentException("逻辑表范围异常，请稍后重试");
        }
        log.info(">>>>>>>>>> 【INFO】范围分片，节点配置表名：{}，数据库缓存表名：{}", tableNames, logicTable.resultTableNamesCache());


        // between and 的起始值
        Range<String> valueRange = rangeShardingValue.getValueRange();
        boolean hasLowerBound = valueRange.hasLowerBound();
        boolean hasUpperBound = valueRange.hasUpperBound();

        // 获取最大值和最小值
        Set<String> tableNameCache = logicTable.resultTableNamesCache();
        String min = hasLowerBound ? valueRange.lowerEndpoint() :getLowerEndpoint(tableNameCache);
        String max = hasUpperBound ? valueRange.upperEndpoint() :getUpperEndpoint(tableNameCache);

        // 循环计算分表范围
        Set<String> resultTableNames = new LinkedHashSet<>();
        while (min.compareTo(max)<0 || min.equals(max)) {
            String temp = min.replaceAll("-", "_");
            String tableName = logicTableName + "_" + temp;
            resultTableNames.add(tableName);
            Date date = null;
            try {
                date = new SimpleDateFormat("yyyy-MM-dd").parse(min);
            } catch (ParseException e) {
                throw new RuntimeException(e);
            }
            min = DateUtil.offsetDay(date, 1).toString("yyyy-MM-dd");
        }
        // 循环计算分表范围
        return ShardingAlgorithmTool.getShardingTablesAndCreate(logicTable.logicTableName(), resultTableNames);
    }


    /**
     * 获取 最小分片值
     * @param tableNames 表名集合
     * @return 最小分片值
     */
    private String getLowerEndpoint(Collection<String> tableNames) {
        Optional<Date> optional = tableNames.stream()
                .map(o -> DateUtils.dateTime("DATE_TIME_FORMATTER_STRING",o.replace("TABLE_SPLIT_SYMBOL", "") + "01 00:00:00"))
                .min(Comparator.comparing(Function.identity()));
        if (optional.isPresent()) {
            return DateUtil.offsetDay(optional.get(), 1).toString("yyyy-MM-dd");
        } else {
            log.error("====> 【ERROR】获取数据最小分表失败，请稍后重试，tableName：{}", tableNames);
            throw new IllegalArgumentException("获取数据最小分表失败，请稍后重试");
        }
    }

    /**
     * 获取 最大分片值
     * @param tableNames 表名集合
     * @return 最大分片值
     */
    private String getUpperEndpoint(Collection<String> tableNames) {
        Optional<Date> optional = tableNames.stream()
                .map(o ->  DateUtils.dateTime("DATE_TIME_FORMATTER_STRING",o.replace("TABLE_SPLIT_SYMBOL", "") + "01 00:00:00"))
                .max(Comparator.comparing(Function.identity()));
        if (optional.isPresent()) {
            return DateUtil.offsetDay(optional.get(), 1).toString("yyyy-MM-dd");
        } else {
            log.error("====> 【ERROR】获取数据最大分表失败，请稍后重试，tableName：{}", tableNames);
            throw new IllegalArgumentException("获取数据最大分表失败，请稍后重试");
        }
    }

}

分片算法工具

package com.example.demo.test;

import cn.hutool.core.collection.ConcurrentHashSet;
import com.alibaba.druid.util.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.shardingsphere.core.rule.DataNode;
import org.apache.shardingsphere.core.rule.TableRule;
import org.apache.shardingsphere.shardingjdbc.jdbc.core.datasource.ShardingDataSource;
import org.springframework.core.env.Environment;

import javax.sql.DataSource;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.sql.*;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p> @Title ShardingAlgorithmTool
 * <p> @Description 按天分片算法工具
 */
@Slf4j
public class ShardingAlgorithmTool {

    private static volatile ShardingAlgorithmTool instance;

    /**
     * 逻辑表名，例：order
     */
    private final static List<String> LOGIC_TABLE_NAME
            = new ArrayList<>(Arrays.asList(
            "check_log",
            "push_log",
            "receives"
    ));


    /**
     * 表分片符号，例：order_20240808 中，分片符号为 "_"
     */
    private static final String TABLE_SPLIT_SYMBOL = "_";

    /**
     * 已存在表名集合缓存
     */
    private static final Set<String> TABLE_NAME_CACHE = new ConcurrentHashSet<>();

    /**
     * 数据库配置
     */
    private static final Environment ENV = SpringUtil.getApplicationContext().getEnvironment();
    private static final String DATASOURCE_URL = ENV.getProperty("spring.shardingsphere.datasource.sharding.url");
    private static final String DATASOURCE_USERNAME = ENV.getProperty("spring.shardingsphere.datasource.sharding.username");
    private static final String DATASOURCE_PASSWORD = ENV.getProperty("spring.shardingsphere.datasource.sharding.password");

    private ShardingAlgorithmTool(){

    }
    public static ShardingAlgorithmTool getInstance(){
        if (instance == null) {
            synchronized (ShardingAlgorithmTool.class) {
                if (instance == null) {
                    instance = new ShardingAlgorithmTool();
                }
            }
        }
        return instance;
    }
    /**
     * 检查分表获取的表名是否存在，不存在则自动建表
     *
     * @param logicTableName  逻辑表名，例：order
     * @param resultTableName 真实表名，例：order_20240808
     * @return 确认存在于数据库中的真实表名
     */
    public static String getShardingTableAndCreate(String logicTableName, String resultTableName) {
        // 缓存中有此表则返回，没有则判断创建
        if (TABLE_NAME_CACHE.contains(resultTableName)) {
            return resultTableName;
        } else {
            // 未创建的表返回逻辑空表
            boolean isSuccess = createShardingTable(logicTableName, resultTableName);
            return isSuccess ? resultTableName : logicTableName;
        }
    }



    /**
     * 检查分表获取的表名是否存在，不存在则自动建表
     *
     * @param logicTableName   逻辑表名，例：order
     * @param resultTableNames 真实表名，例：order_20240808
     * @return 存在于数据库中的真实表名集合
     */
    public static Set<String> getShardingTablesAndCreate(String logicTableName, Collection<String> resultTableNames) {
        return resultTableNames.stream().map(o -> getShardingTableAndCreate(logicTableName, o)).collect(Collectors.toSet());
    }

    /**
     * 缓存重载
     */
    public static void tableNameCacheReload() {
        // 读取数据库中|所有表名
        List<String> tableNameList = getAllTableNameBySchema();
        // 删除旧的缓存（如果存在）
        TABLE_NAME_CACHE.clear();
        // 写入新的缓存
        TABLE_NAME_CACHE.addAll(tableNameList);
        // 动态更新配置 actualDataNodes
        actualDataNodesRefresh();
    }

    /**
     * 获取所有表名
     *
     * @return 表名集合
     */
    public static List<String> getAllTableNameBySchema() {
        List<String> tableNames = new ArrayList<>();
        if (StringUtils.isEmpty(DATASOURCE_URL) || StringUtils.isEmpty(DATASOURCE_USERNAME) || StringUtils.isEmpty(DATASOURCE_PASSWORD)) {
            log.error(">>>>>>>>>> 【ERROR】数据库连接配置有误，请稍后重试，URL:{}, username:{}, password:{}", DATASOURCE_URL, DATASOURCE_USERNAME, DATASOURCE_PASSWORD);
            throw new IllegalArgumentException("数据库连接配置有误，请稍后重试");
        }
        try (Connection conn = DriverManager.getConnection(DATASOURCE_URL, DATASOURCE_USERNAME, DATASOURCE_PASSWORD);
             Statement st = conn.createStatement()) {
            for (int i=0;i<LOGIC_TABLE_NAME.size();i++){
                try (ResultSet rs = st.executeQuery("show TABLES like '" + LOGIC_TABLE_NAME.get(i) + TABLE_SPLIT_SYMBOL + "%'")) {
                    while (rs.next()) {
                        tableNames.add(rs.getString(1));
                    }
                }
            }
        } catch (SQLException e) {
            log.error(">>>>>>>>>> 【ERROR】数据库连接失败，请稍后重试，原因：{}", e.getMessage(), e);
            throw new IllegalArgumentException("数据库连接失败，请稍后重试");
        }
        return tableNames;
    }

    /**
     * 获取表名缓存
     *
     * @return 表名缓存
     */
    public static Set<String> getTableNameCache() {
        return TABLE_NAME_CACHE;
    }

    /**
     * 动态更新配置 actualDataNodes
     */
    public static void actualDataNodesRefresh() {
        try {
            // 获取数据分片节点
            Set<String> tableNameCache = ShardingAlgorithmTool.getTableNameCache();
            ShardingDataSource dataSource = (ShardingDataSource) SpringUtil.getBean("dataSource", DataSource.class);
            for (int i=0;i<LOGIC_TABLE_NAME.size();i++){
                TableRule tableRule = dataSource.getShardingContext().getShardingRule().getTableRule(LOGIC_TABLE_NAME.get(i));
                List<DataNode> dataNodes = tableRule.getActualDataNodes();
                String dataSourceName = dataNodes.get(0).getDataSourceName();
                List<DataNode> newDataNodes = tableNameCache.stream().map(tableName -> new DataNode(dataSourceName + "." + tableName)).collect(Collectors.toList());

                // 更新actualDataNodes
                Field actualDataNodesField = TableRule.class.getDeclaredField("actualDataNodes");
                Field modifiersField = Field.class.getDeclaredField("modifiers");
                modifiersField.setAccessible(true);
                modifiersField.setInt(actualDataNodesField, actualDataNodesField.getModifiers() & ~Modifier.FINAL);
                actualDataNodesField.setAccessible(true);
                actualDataNodesField.set(tableRule, newDataNodes);
            }

        } catch (Exception e) {
            log.error("初始化 动态表单失败，原因：{}", e.getMessage(), e);
        }
    }


    /**
     * 创建分表
     *
     * @param logicTableName  逻辑表名，例：order
     * @param resultTableName 真实表名，例：order_20240808
     * @return 创建结果（true创建成功，false未创建）
     */
    public static boolean createShardingTable(String logicTableName, String resultTableName) {
        synchronized (logicTableName.intern()) {
            // 缓存中有此表 返回
            if (TABLE_NAME_CACHE.contains(resultTableName)) {
                return false;
            }
            // 缓存中无此表，则建表并添加缓存
            executeSql(Collections.singletonList("CREATE TABLE `" + resultTableName + "` LIKE `" + logicTableName + "`;"));
            // 缓存重载
            tableNameCacheReload();
        }
        return true;
    }

    /**
     * 执行SQL
     *
     * @param sqlList SQL集合
     */
    private static void executeSql(List<String> sqlList) {
        if (StringUtils.isEmpty(DATASOURCE_URL) || StringUtils.isEmpty(DATASOURCE_USERNAME) || StringUtils.isEmpty(DATASOURCE_PASSWORD)) {
            log.error(">>>>>>>>>> 【ERROR】数据库连接配置有误，请稍后重试，URL:{}, username:{}, password:{}", DATASOURCE_URL, DATASOURCE_USERNAME, DATASOURCE_PASSWORD);
            throw new IllegalArgumentException("数据库连接配置有误，请稍后重试");
        }
        try (Connection conn = DriverManager.getConnection(DATASOURCE_URL, DATASOURCE_USERNAME, DATASOURCE_PASSWORD)) {
            try (Statement st = conn.createStatement()) {
                conn.setAutoCommit(false);
                for (String sql : sqlList) {
                    st.execute(sql);
                }
            } catch (Exception e) {
                conn.rollback();
                log.error(">>>>>>>>>> 【ERROR】数据表创建执行失败，请稍后重试，原因：{}", e.getMessage(), e);
                throw new IllegalArgumentException("数据表创建执行失败，请稍后重试");
            }
        } catch (SQLException e) {
            log.error(">>>>>>>>>> 【ERROR】数据库连接失败，请稍后重试，原因：{}", e.getMessage(), e);
            throw new IllegalArgumentException("数据库连接失败，请稍后重试");
        }
    }
}

项目启动后读取分表进行缓存

package com.example.demo.test;

import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * <p> @Title ShardingTablesLoadRunner
 * <p> @Description 项目启动后，读取已有分表，进行缓存
 */
@Order(value = 1) // 数字越小，越先执行
@Component
public class ShardingTablesLoadRunner implements CommandLineRunner {

    @Override
    public void run(String... args) {
        // 读取已有分表，进行缓存
        ShardingAlgorithmTool.tableNameCacheReload();
    }
}

参考ShardingJDBC分表使用-CSDN博客​​​​​​

忘了是不是这个了

其中的分表规则不能满足我的需求，所以做了改动然后发了出来 ，

xia66zz
关注
sharding-jdbc按月分表样例
04-09
sharind-jdbc样例，当中包含了按月动态分表，一个比较简单的demo，仅供参考！……………………
spring boot整合sharding jdbc5.2.0分库分表demo
11-01
**Spring Boot 整合 ShardingSphere (Sharding JDBC) 5.2.0 分库分表实战** 在现代企业级应用开发中，随着业务量的增长，数据库的压力也随之增大，这时就需要进行数据库的分库分表操作来提升系统性能。Spring Boot ...
SpringBoot整合ShardingJDBC按时间分表及自动建表
任凭本心的博客
03-12 2687
SpringBoot整合ShardingJDBC按时间分表及自动建表
三、Spring Boot集成sharding-jdbc实现按时间分库分表
半江残月
10-15 1万+
回顾 前篇内容已经实现了spring boot集成mybatis访问MySQL，本篇在此基础上集成sharding-jdbc实现分库分表等功能。 集成sharding-jdbc 首先创建创建数据库和表。这是sharding-jdbc所要求的。 create database db_201810; create database db_201811; use db_201810; cre...
sharding-jdbc 实现按月分表
开卷有益
06-11 8928
sharding-jdbc 实现按月分表
Sharding-JDBC（三）4.0.0-RC1版本，实现按月分表、动态建表、自动刷新节点
ACGkaka的博客
12-20 2844
按月分表、自动建表
Sharding-JDBC-5.1.0 实现按月分表、动态建表
abc_xian的博客
10-25 4046
Sharding-JDBC-5.1.0 实现按月分表、自动建表、自动刷新节点
SpringBoot集成Sharding-JDBC-5.3.0实现按月动态建表分表
最新发布
JingAi_jia917的博客
07-16 2822
本篇使用SpringBoot集成Sharding-JDBC 5.3.0，分享了自动按月自动建表分表的功能。
springboot整合sharding-jdbc实现分库分表详解
congge
05-21 7811
springboot整合sharding-jdbc实现分库分表详解
SpringBoot整合Sharding-JDBC实现水平分表
桐花思雨
01-12 1411
目录数据库的水平分表需求说明 数据库的水平分表 关于水平分表可以参考文章：https://blog.csdn.net/weixin_38192427/article/details/122441366 需求说明 创建两张表 t_order_1 和 t_order_2，这两张表是订单表水平拆分后的表，通过 Sharding-JDBC 向订单表插入数据， 按照一定的分片规则，主键为偶数的进入 t_order_1，主键为奇数进入 t_order_2，通过 Sharding-JDBC 查询数据，根据 SQL 语句的
SpringBoot整合Sharding-JDBC实现水平分库分表
桐花思雨
01-12 936
目录前言需求说明数据库表创建 前言 在 上一篇文章 中我们实现了水平分表，也就是两张列，字段完全相同的表在同一个数据库中，没有完成数据库的水平分割，这篇文章来完成水平方向的分库分表 关于水平分库分表可以参考文章：https://blog.csdn.net/weixin_38192427/article/details/122441366 需求说明 水平分库是把同一个表的 数据 按一定规则拆到不同的数据库中，每个库可以放在不同的服务器上。如 order_db_1 和 order_db_2 两个数据库，它们分别
sharding-jdbc 实现动态分表（按年按月）
热门推荐
jiejiegua的博客
01-13 2万+
1、 项目中我们希望 能够按照时间、类别来添加表。但是sharding-jdbc 是固定配置 的actual-data-nodes 参数。 也就是说我们需要提前创建好分表或者分库。那么我们需要如何来实现动态创建表，并且动态刷新actual-data-nodes 呢。 2、思路 就是 写个定时器来动态创建表 ，在创建表的时候 动态刷新actual-data-nodes 实现动态创建表被shard加载。注意的是，我的任务 采用xxl-job （主要是我们的项目是分布式项目）你们如果是单体也可以直接...
ShardingJDBC实战(一)：按年月分表
u013244613的博客
05-14 7427
云Pass平台面向多租户，需要每日统计各租户的具体使用量，用于向租户展示使用量详情和汇总每月使用量，以便对租户账户进行扣款和与租户对账。平台租户30万+，各租户每天产生的各类统计信息大致在30+，每月产生的数据记录数接近千万，因此进行水平分库分表是十分必要的。 ShardingSphere-JDBC ShardingSphere-JDBC是Apache ShardingSphere的第一个产品，也是Apache ShardingSphere的前身。定位为轻量级Java框架，在Java的JDBC层提供的额
shardingjdbc每月分表_Sharding-Jdbc实现分表分库
weixin_31661121的博客
02-22 797
Sharding-Jdbc分表分库LogicTable数据分片的逻辑表，对于水平拆分的数据库(表)，同一类表的总称。订单信息表拆分为2张表,分别是t_order_0、t_order_1，他们的逻辑表名为t_order。ActualTable在分片的数据库中真实存在的物理表。即上个示例中的t_order_0、t_order_1。DataNode数据分片的最小单元。由数据源名称和数据表组成，例：tes...
Sharding-JDBC（六）5.1.0版本，实现按月分表、自动建表、自动刷新节点
ACGkaka的博客
01-27 1万+
5.1.0版本，实现按月分表、自动建表、自动刷新节点
shardingjdbc4.0.0-RC1--＞RC2 读写分离示例错误排查
qq_42468502的博客
10-01 822
linux环境：CentOS7.8+mysql5.7.29框架：springboot2.4.5 + mybatisplus3.4.2(mybatis-plus-boot-starter)+sharding-jdbc4.0.0-RC2(sharding-jdbc-spring-boot-starter兼容性问题由1改成2)+druid。
shardingjdbc每月分表_springboot整合sharding-jdbc实现按月份分表mysql
weixin_39845306的博客
01-17 1654
这里只是简单的根据月份来进行分表，效果如图所示：1、加入依赖文件:io.shardingspheresharding-jdbc-spring-boot-starter3.0.0.M2io.shardingspheresharding-jdbc-spring-namespace3.0.0.M22.配置properties文件sharding.jdbc.driver=com.mysql.jdbc.Dr...
spring boot 八、 sharding-jdbc 分库分表 按月分表
空
09-21 1879
【代码】spring boot 八、 sharding-jdbc 分库分表 按月分表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值