Sharding-jdbc 分库分表

已于 2023-04-27 16:12:00 修改
阅读量279 收藏
点赞数
文章标签： java spring 数据库
于 2021-12-06 10:38:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37663786/article/details/121741854
版权

原因:

由于业务需要,单标数据量达到800万,因此需要做分库分表

采用技术:

sharding-jdbc

集成sharding

引用pom

<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>4.0.0-RC1</version>
</dependency>

增加配置:

spring.shardingsphere.datasource.names = ds2020,ds2021

#数据源

spring.shardingsphere.datasource.ds2020.type = com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.ds2020.driver-class-name = com.mysql.jdbc.Driver

spring.shardingsphere.datasource.ds2020.url=jdbc:mysql://**.***.***.***:3306/***?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8

spring.shardingsphere.datasource.ds2020.username = root

spring.shardingsphere.datasource.ds2020.password = 11202

spring.shardingsphere.datasource.ds2021.type = com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.ds2021.driver-class-name = com.mysql.jdbc.Driver

spring.shardingsphere.datasource.ds2021.url=jdbc:mysql://**.***.***.***:3306/***?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8

spring.shardingsphere.datasource.ds2021.username = root

spring.shardingsphere.datasource.ds2021.password = 11202

# 分表配置

spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = ds$->{2020..2021}.t_order_$->{1..4}

spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.sharding-column= create_time

spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.precise-algorithm-class-name = com.test.srm.biz.shardingAlgorithm.ShardingTableByQuarterPreciseAlgorithm

spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.range-algorithm-class-name = com.test.srm.biz.shardingAlgorithm.ShardingTableByQuarterRangeAlgorithm

spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds$->{2020..2021}.t_order_item_$->{1..12}

spring.shardingsphere.sharding.tables.t_order_item.table-strategy.standard.sharding-column= create_time

spring.shardingsphere.sharding.tables.t_order_item.table-strategy.standard.precise-algorithm-class-name = com.test.srm.biz.shardingAlgorithm.ShardingTableByMonthPreciseAlgorithm

spring.shardingsphere.sharding.tables.t_order_item.table-strategy.standard.range-algorithm-class-name = com.test.srm.biz.shardingAlgorithm.ShardingTableByMonthRangeAlgorithm

spring.shardingsphere.sharding.tables.t_order_info.actual-data-nodes=ds$->{2020..2021}.t_order_info

# 分库配置

spring.shardingsphere.sharding.default-database-strategy.standard.sharding-column= create_time

spring.shardingsphere.sharding.default-database-strategy.standard.range-algorithm-class-name = com.test.srm.biz.shardingAlgorithm.ShardingDataBaseByYearRangeAlgorithm

spring.shardingsphere.sharding.default-database-strategy.standard.precise-algorithm-class-name = com.test.srm.biz.shardingAlgorithm.ShardingDataBaseByYearPreciseAlgorithm

# 不分库分表的数据源指定

spring.shardingsphere.sharding.default-data-source-name = ds2020

分库规则(按照年进行分库+精确搜索)

public class ShardingDataBaseByYearPreciseAlgorithm implements PreciseShardingAlgorithm<Date> {



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

    static {

        dataSourceMap.put("2020", "ds2020");

        dataSourceMap.put("2021", "ds2021");

        dataSourceMap.put("2022", "ds2022");

    }



    @Override

    public String doSharding(Collection<String> databaseNames, PreciseShardingValue<Date> shardingValue) {

        String year=String.format("%tY", shardingValue.getValue());

        String dataBase = dataSourceMap.get(year);

        log.info("function=ShardingDataBaseByYearPreciseAlgorithm.doSharding;msg=databaseNames:{},dataBase:{}", JSON.toJSONString(databaseNames), dataBase);

        if (StringUtils.isBlank(dataBase))

        {

            throw new UnsupportedOperationException("ShardingTableByQuarterAlgorithm ********** No database matching the rule **********");

        }

        return dataBase;

    }

}
 

分库规则(按照年进行范围搜索)
 

public class ShardingDataBaseByYearRangeAlgorithm implements RangeShardingAlgorithm<Date>
 

{
 

 

    private static Map<Integer, String> dataSourceMap = new HashMap<Integer, String>();
 

    static {
 

        dataSourceMap.put(2020, "ds2020");
 

        dataSourceMap.put(2021, "ds2021");
 

        dataSourceMap.put(2022, "ds2022");
 

    }
 

 

       @Override
 

       public Collection<String> doSharding(Collection<String> databaseNames, RangeShardingValue<Date> rangeShardingValue) {
 

        List<String> dataBases = new ArrayList<>(databaseNames);
 

 

        Range<Date> valueRange = rangeShardingValue.getValueRange();
 

        if (valueRange.hasLowerBound() && valueRange.hasUpperBound())
 

        {
 

            log.info("function=ShardingDataBaseByYearRangeAlgorithm.doSharding;msg=dataBases:{},valueRange1:{},valueRange2:{}"
 

                    , JSON.toJSONString(dataBases), String.format("%tY", valueRange.lowerEndpoint()),
 

                            String.format("%tY", valueRange.upperEndpoint()));
 

            List<Integer> yearList = new ArrayList<>();
 

            for (Integer lowerYear = Integer.parseInt(String.format("%tY", valueRange.lowerEndpoint())),
 

                 upperYear = Integer.parseInt(String.format("%tY", valueRange.upperEndpoint()));
 

                    lowerYear <= upperYear; lowerYear++)
 

            {
 

                yearList.add(lowerYear);
 

            }
 

            List<String> dataNameList = new ArrayList<>();
 

            for (Integer year : yearList)
 

            {
 

                if (StringUtils.isNotBlank(dataSourceMap.get(year)))
 

                {
 

                    dataNameList.add(dataSourceMap.get(year));
 

                }
 

            }
 

            if (CollectionUtils.isEmpty(dataNameList))
 

            {
 

                return dataBases;
 

            }
 

            else {
 

                return dataNameList;
 

            }
 

        }
 

        return dataBases;
 

       }
 

}
 

 

分表规则(按照月进行分表+精确搜索)
 

public class ShardingTableByMonthPreciseAlgorithm implements PreciseShardingAlgorithm<Date> {



    @Override

    public String doSharding(Collection<String> tablesNames, PreciseShardingValue<Date> shardingValue) {



        Date date = shardingValue.getValue();

        int month = date.getMonth() + 1;

        log.info("function=ShardingTableByMonthPreciseAlgorithm.doSharding;msg=tablesNames:{},month:{}", JSON.toJSONString(tablesNames), month);

        //按月路由

        for (String each : tablesNames)

        {

            if (each.contains("_" + month) || each.contains("_0" + month) )

            {

                return each;

            }

        }

        throw new UnsupportedOperationException("ShardingTableByMonthAlgorithm ********** No database matching the rule **********");

    }

}
 

 

分表规则(按照月进行范围搜索)
 

 

public class ShardingTableByMonthRangeAlgorithm implements RangeShardingAlgorithm<Date>

{



   @Override

   public Collection<String> doSharding(Collection<String> tablesNames, RangeShardingValue<Date> rangeShardingValue)

   {

      List<String> tablesNameList = new ArrayList<>(tablesNames);

      Range<Date> valueRange = rangeShardingValue.getValueRange();

      log.info("function=ShardingTableByMonthRangeAlgorithm.doSharding;msg=tablesNames:{},rangeValue1:{},rangeValue2:{}"

            , JSON.toJSONString(tablesNames), valueRange.lowerEndpoint(), valueRange.upperEndpoint());

      // 这里一定要对valueRange重新新建对象赋值,不要改变rangeShardingValue中的参数,因为在下次进来的时候值会变

        Date startDate = new Date(valueRange.lowerEndpoint().getTime());

        Date endDate = new Date(valueRange.upperEndpoint().getTime());

        List<Integer> allMonth = ShardingCommon.getAllMonth(startDate, endDate);

        List<String> newTableNames = new ArrayList<>();

        for (Integer month : allMonth)

        {

            if (month -1 <= tablesNameList.size())

            {

                newTableNames.add(tablesNameList.get(month -1));

            }

        }

        if (CollectionUtils.isEmpty(newTableNames))

        {

            return tablesNameList;

        }

        else {

            return newTableNames;

        }

   }

}
 

分表规则(按照季度进行分表+精确搜索)
 

public class ShardingTableByQuarterPreciseAlgorithm implements PreciseShardingAlgorithm<Date> {



    // 第一季度(集合中为月份)

    private static final List<Integer> oneQuarterList = Arrays.asList(1,2,3);



    // 第二季度(集合中为月份)

    private static final List<Integer> twoQuarterList = Arrays.asList(4,5,6);



    // 第三季度(集合中为月份)

    private static final List<Integer> threeQuarterList = Arrays.asList(7,8,9);



    // 第四季度(集合中为月份)

    private static final List<Integer> fourQuarterList = Arrays.asList(10,11,12);



    @Override

    public String doSharding(Collection<String> tableNames, PreciseShardingValue<Date> shardingValue) {

        List<String> tables = new ArrayList<>(tableNames);



        Date date = shardingValue.getValue();

        int month = date.getMonth() + 1;

        log.info("function=ShardingTableByQuarterAlgorithm.doSharding;msg=tableNames:{},month:{}", JSON.toJSONString(tableNames), month);

        // 按季度路由

        if (oneQuarterList.contains(month))

        {

            return tables.get(0);

        }



        if (twoQuarterList.contains(month))

        {

            return tables.get(1);

        }



        if (threeQuarterList.contains(month))

        {

            return tables.get(2);

        }



        if (fourQuarterList.contains(month))

        {

            return tables.get(3);

        }

        throw new UnsupportedOperationException("ShardingTableByQuarterAlgorithm ********** No database matching the rule **********");

    }

}
 

 

分表规则(按照季度进行范围搜索)
 

public class ShardingTableByQuarterRangeAlgorithm implements RangeShardingAlgorithm<Date>

{



   // 第一季度(集合中为月份)

   private static final List<Integer> oneQuarterList = Arrays.asList(1,2,3);



   // 第二季度(集合中为月份)

   private static final List<Integer> twoQuarterList = Arrays.asList(4,5,6);



   // 第三季度(集合中为月份)

   private static final List<Integer> threeQuarterList = Arrays.asList(7,8,9);



   // 第四季度(集合中为月份)

   private static final List<Integer> fourQuarterList = Arrays.asList(10,11,12);



   @Override

   public Collection<String> doSharding(Collection<String> collection, RangeShardingValue<Date> rangeShardingValue)

   {

      List<String> tablesNameList = new ArrayList<>(collection);

      Range<Date> valueRange = rangeShardingValue.getValueRange();

      if (valueRange.hasLowerBound() && valueRange.hasUpperBound())

      {

         log.info("function=ShardingTableByQuarterRangeAlgorithm.doSharding;msg=tablesNameList:{},rangeValue1:{},rangeValue2:{}"

               , JSON.toJSONString(tablesNameList), valueRange.lowerEndpoint(), valueRange.upperEndpoint());

         List<String> newTableNames = new ArrayList<>();

         // 这里一定要对valueRange重新新建对象赋值,不要改变rangeShardingValue中的参数,因为在下次进来的时候值会变

         Date startDate = new Date(valueRange.lowerEndpoint().getTime());

         Date endDate = new Date(valueRange.upperEndpoint().getTime());

         List<Integer> allMonth = ShardingCommon.getAllMonth(startDate, endDate);

         for (Integer month : allMonth)

         {



            if (oneQuarterList.contains(month))

            {

               newTableNames.add(tablesNameList.get(0));

            }

            if (twoQuarterList.contains(month))

            {

               newTableNames.add(tablesNameList.get(1));

            }

            if (threeQuarterList.contains(month))

            {

               newTableNames.add(tablesNameList.get(2));

            }

            if (fourQuarterList.contains(month))

            {

               newTableNames.add(tablesNameList.get(3));

            }

         }

         if (CollectionUtils.isNotEmpty(newTableNames))

         {

            return newTableNames;

         }

         else {

            return tablesNameList;

         }

      }

      return tablesNameList;

   }
 

 

获取两个时间段内所有的月份
 

public static List<Integer> getAllMonth(Date startDate, Date endDate)

{

    List<Integer> allMonth = new ArrayList<>();



    if (Objects.isNull(startDate) || Objects.isNull(endDate))

    {

        return allMonth;

    }

    while (startDate.getTime() <= endDate.getTime())

    {

        Integer month = startDate.getMonth() + 1;

        if (!allMonth.contains(month))

        {

            allMonth.add(month);

        }

        startDate.setMonth(startDate.getMonth() + 1);

    }

    return allMonth;

}
 

 

 

集成过程中存在的问题
 

1.获取时间中年的时候
 

int year = endDate.getYear(); 获取到结果预期为2021结果是121
 

String year=String.format("%tY", shardingValue.getValue()) 获取到结果为2021
 

2.当进行范围查询的时候首先会进分库规则,加入说查找到两个库,则会进两次分表规则
 

比如查询2020年12月->2021年1月
 

会查询
 

2020年库1月,12月库
 

2021年库1月,12月库
 

该问题暂时无法解决,因为在debug中发现无法区分出对应的是2020库 还是2021库
 

3. int month = endDate.getMonth() 结果是0->11 0:一月份
 

4.在根据时间进行范围查询的时候目前4.0.0版本不支持<= >= 查询,仅支持between and 需要升级到4.1.1版本之后才支持.

                

        

        

    

  


    

      

        

            

              
                
                  lowerjava
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Sharding-JDBC分库分表详解--干货

				
			

			

				

					hins
				

				

					04-12
					
					656
					
				

			

		

		

			
				
一、Sharding-JDBC 简介
Sharding-JDBC 最早是当当网内部使用的一款分库分表框架，到2017年的时候才开始对外开源，这几年在大量社区贡献者的不断迭代下，功能也逐渐完善，现已更名为 ShardingSphere，2020年4⽉16⽇正式成为 Apache 软件基⾦会的顶级项⽬。
随着版本的不断更迭 ShardingSphere 的核心功能也变得多元化起来。从最开始 Sharding-JDBC 1.0 版本只有数据分片，到 Sharding-JDBC 2.0 版本开始支持数据库治理（注册

			
		

	



                

              
                



	

		

			

				
					
SpringBoot+Sharding-JDBC分库分表实战

				
			

			

				

					06-11
				

			

		

		

			
				
《SpringBoot+Sharding-JDBC分库分表实战》是一个深度探讨如何在Java环境中利用SpringBoot框架和Sharding-JDBC库实现数据库分库分表的实践教程。本教程旨在帮助开发者掌握在高并发、大数据量场景下，如何有效提升...

			
		

	



                


  
              

                


	

		

			

				
					
跟着小刘一起入门一下Sharding jdbc

				
			

			

				

					程序员小刘
				

				

					06-27
					
					724
					
				

			

		

		

			
				
文章目录sharding jdbc -缘起分库分表的出现小结分库分表带来问题Sharding JDBC 介绍快速入门
sharding jdbc -缘起


前段时间，在工作接手了一个新的项目，我问Boss，这个项目使用的是什么技术，老板轻描淡写的说到，还是那一套 Springboot ，就是 用了一下了那个分库分表技术，你端午节，去了解一下这个技术 ,Sharding jdbc
唉！  又要了解新技术，还真是活到老，学到老啊！


天天都有去了解新技术，这东西居然没听过，加上我不喜欢看视频，然后就默默打开

			
		

	





	

		

			

				
					
如何使用Sharding-JDBC，进行分库分表

					
最新发布

				
			

			

				

					qq_54523931的博客
				

				

					08-01
					
					1581
					
				

			

		

		

			
				
Sharding-JDBC是当当网研发的开源分布式数据库中间件，定位为轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架，从3.0开始Sharding-JDBC被包含在Sharding-Sphere中。ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidec

			
		

	



		

			
		



	

		

			

				
					
基于springboot使用sharding-sphere实现智能化分库分表

				
			

			

				

					Emmmmmm_m的博客
				

				

					05-21
					
					781
					
				

			

		

		

			
				
话不多说，直接先上代码

pom.xml文件引入依赖

<dependency>
	<groupId>org.apache.shardingsphere</groupId>
	<artifactId>sharding-jdbc-core</artifactId>
	<version>4.0.1</version>
</dependency>


springboot配置文件中加入如下配置

spring:
  #

			
		

	





	

		

			

				
					
Sharding-JDBC 分库分表

				
			

			

				

					AkiraNicky的博客
				

				

					08-01
					
					8880
					
				

			

		

		

			
				
一. 初识Sharding-JDBC

1. Sharding-JDBC是什么？

Sharding-JDBC提供标准化的数据分片、分布式事务和数据库治理功能，定位为轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。
适用于任何基于Java的ORM框...

			
		

	





	

		

			

				
					
sharding-jdbc分库分表

				
			

			

				

					07-23
				

			

		

		

			
				
总结，Sharding-JDBC作为一个优秀的数据库中间件，通过分库分表和读写分离技术，为Java开发者提供了强大的数据库扩展能力。通过深入学习和实践"shanjupay"项目，我们可以更好地理解和运用这一技术，以应对日益增长的...

			
		

	





	

		

			

				
					
集成sharding-jdbc实现分库分表.zip

				
			

			

				

					12-19
				

			

		

		

			
				
在这个"集成sharding-jdbc实现分库分表.zip"的压缩包中，我们可以深入学习如何将Sharding-JDBC应用于实际项目，以提升系统的性能和可扩展性。  1. **Sharding-JDBC简介**  Sharding-JDBC是Java语言实现的，它工作在...

			
		

	





	

		

			

				
					
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能

				
			

			

				

					09-07
				

			

		

		

			
				
本篇文章将详细讲解如何使用Spring Boot结合Sharding-JDBC和Mybatis-Plus实现分库分表功能。  一、Sharding-JDBC简介  Sharding-JDBC是由Apache ShardingSphere项目提供的一个轻量级数据库中间件，它作为JDBC驱动...

			
		

	





	

		

			

				
					
4-Sharding-JDBC分库分表.pdf

				
			

			

				

					07-12
				

			

		

		

			
				
分库分表的概念、垂直拆分与水平拆分、分片策略和分片算法是Sharding-JDBC中核心的知识点，下面将对这些概念进行详细的解释。  ### 分库分表概念  分库分表是为了解决随着业务数据量的不断增长，单库单表模式面临的...

			
		

	





	

		

			

				
					
sharding-jdbc按月分表样例

				
			

			

				

					10-25
				

			

		

		

			
				
sharind-jdbc样例，当中包含了按月动态分表，一个比较简单的demo，大家可以结合自己的需求进行修改，以及可以看下实现思路，仅供参考！

			
		

	





	

		

			

				
					
Sharding-JDBC分库分表

				
			

			

				

					shaopengjie的博客
				

				

					05-19
					
					1893
					
				

			

		

		

			
				
垂直分表： 按字段访问频次、是否大字段等原则，将原先的大表拆分为多个小表，从而提升数据库性能。垂直分表会导致表结构改变，所以拆分时尽量从业务角度出发，避免联查，否则得不偿失。垂直分库：可以按照数据表业务，将相同业务的表拆分到多个数据库，这些数据库可以分布在不同的服务器上。这个过程中，表结构不发生改变。拆分之后，压力被多个服务器分别承担，从而提升访问数据，同时可以提高业务清晰度。但它需要解决跨库所带来的所有复杂问题。水平分库。

			
		

	





	

		

			

				
					
Sharding-jdbc分库分表

				
			

			

				

					Lyzxii
				

				

					07-30
					
					6015
					
				

			

		

		

			
				
引入

不断增长的业务数据会对MySQL数据库的存储和访问造成极大的性能影响，由于单台服务器的资源（CPU、磁盘、内存等）总是有限的，所以单台数据库所能承载的数据量、数据处理能力都将遭遇瓶颈。不论是获取连接还是插入或查询都会有极大的性能问题。

MySQL大数据量造成的性能瓶颈解决方案：

从SQL入手 加入索引 -> 缓存 -> 主从复制/读写分离
	使用缓存，减少对数据库的同步访问
	减少MySQL使用，可以使用HBase、polarDB、TiDB等分布式存储，ES查询
	分库分表


拓展

			
		

	





	

		

			

				
					
分库分表(sharding-jdbc)

				
			

			

				

					gun_wqy的博客
				

				

					03-04
					
					372
					
				

			

		

		

			
				
分库分表相关内容（sharding-jdbc等）

			
		

	





	

		

			

				
					
SpringBoot 集成 Sharding-JDBC 实现易于扩容的分库分表

				
			

			

				

					木子雷的博客
				

				

					06-20
					
					2064
					
				

			

		

		

			
				
前言：

今天来聊下 SpringBoot 集成 Sharding-JDBC 实现分库分表；为此写了一个小***Demo***，这个Demo是基于SpringBoot，并集成了  Mybatis、Redis、Swagger（生成在线的接口文档 ）、PageHelper（分页工具） 等，当然绝对也集成了 Sharding-JDBC ；以及设计了 RestFul 风格的接口 ，添加了 单元测试 。
下面简单介绍下本文的主线：
①、首先介绍下Demo的工程目录，并且介绍下使用的基本环境，如：sql、工程的pom.

			
		

	





	

		

			

				
					
数据量大了一定要分表，分库分表Sharding-JDBC入门与项目实战

				
			

			

				

					Java知音
				

				

					08-27
					
					706
					
				

			

		

		

			
				
作者：六点半起床juejin.im/post/6844904182365814797最近项目中不少表的数据量越来越大，并且导致了一些数据库的性能问题。因此想借助一些分库分表的中间件，实现...

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值