分库分表亲自实践

最新推荐文章于 2024-01-22 08:48:31 发布

原创最新推荐文章于 2024-01-22 08:48:31 发布 · 420 阅读

0 ·

CC 4.0 BY-SA版权

分库分表专栏收录该内容

0 篇文章

订阅专栏

本文详细介绍了在SpringBoot项目中实现分库分表的具体策略，包括使用Redis双主从集群生成连续自增ID，以及如何通过ID定位数据所在的数据库和表。并通过示例代码展示了如何在两个库两个表中进行数据的插入操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

今天我要来分享我们项目中用到的分表策略：用Redis 双主从集群产生连续自增ID（后文会详细介绍），先根据ID的大范围来确定组，每组里面有若干个数据库，通过对数据库的数量继续取余数，来确定在那个数据库，每个数据库又有若干个表，根据小范围来确定表。

假设目前有一个ID=5千万，通过group 表知道这个数据应该落在组2中，通过第二张表我们知道组2中一共有三个数据库，让后计算5千万%3=2，这条数据将定位到DB表中db_id 等于四的记录，也就组2中db0,因为这里每个组是4千万数据，如果分为三涨表就是4千万到5千五百万， 5千五百万到七千万，七千万到八千万，就是table表中

table_id 等于11 -13这三张表，ID等于五千万这条数据刚好落在11这张表中。

设计几张关系表；

通过三张关系表就可以定位什么ID的数据应该插入什么表中，id 等于啥的数据在什么库，什么表中。

接下来我们就用springboot 来实际一下分库分表的功能实现。我会贴出全部代码，想参考的人直接拷贝就行。这次我用的是mysql8 妈的坑死我了，MySQL8就是坑。

化了半天时间踩了很多坑才实现的，便宜读者了。一定要先点赞哦。

这里我们只用两个库两个表来做个基本演示就够了。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.1.6.RELEASE</version>
       <relativePath /> 
   </parent>
   <groupId>com.example</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

<dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>8.0.11</version>
       </dependency>

<dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>druid</artifactId>
           <version>1.1.10</version>
       </dependency>

       <dependency>
           <groupId>org.mybatis.spring.boot</groupId>
           <artifactId>mybatis-spring-boot-starter</artifactId>
           <version>2.1.0</version>
       </dependency>

       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>

       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-logging</artifactId>
       </dependency>

</dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>

</project>

package com.demo.conf;

public class DataSourceTypeManager {
/**
* 注意：数据源标识保存在线程变量中，避免多线程操作数据源时互相干扰
*/
private static final ThreadLocal<String> THREAD_DATA_SOURCE = new ThreadLocal<String>();

public static String getDataSource() {
return THREAD_DATA_SOURCE.get();
}

public static void setDataSource(String dataSource) {
THREAD_DATA_SOURCE.set(dataSource);
}

public static void clear() {
THREAD_DATA_SOURCE.remove();
}
}

再建立一个类

package com.demo.conf;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {
   @Override
   protected Object determineCurrentLookupKey() {
       // 获取数据源
return DataSourceTypeManager.getDataSource();
   }
}

新疆一个类用来给实体类继承用，用来传递表名到Mybaits 中，实现表名的动态需要。

package com.demo.entity;

public class TableEntity {

   public transient String dbNane;

   public transient String tableName;

   public String getDbNane() {
       return dbNane;
   }

   public void setDbNane(String dbNane) {
       this.dbNane = dbNane;
   }

   public String getTableName() {
       return tableName;
   }

   public void setTableName(String tableName) {
       this.tableName = tableName;
   }

}

实体类：

package com.demo.entity;

public class Man extends TableEntity{
private Integer id;

private String name;

private Integer age;

public Integer getId() {
return id;
}

public void setId(Integer id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name == null ? null : name.trim();
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age = age;
}
}

新疆一个数据源的db.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">

新建 spring-context.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:cache="http://www.springframework.org/schema/cache"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">

<import resource="classpath:db.xml" />

</beans>

配置日志：不然跑不起来，出错也不知道啥错：

logback-spring.xml:

<?xml version="1.0" encoding="UTF-8"?>




<configuration scan="true" scanPeriod="10 seconds">
<contextName>logback</contextName>

<property name="log.path" value="G:/logs/pmp" />

<conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
<conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
<conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />

<property name="CONSOLE_LOG_PATTERN" value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">

<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
<level>debug</level>
</filter>
<encoder>
<Pattern>${CONSOLE_LOG_PATTERN}</Pattern>

<charset>UTF-8</charset>
</encoder>
</appender>

<appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

<file>${log.path}/web_debug.log</file>

<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
<charset>UTF-8</charset> 
</encoder>

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

<fileNamePattern>${log.path}/web-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>

<maxHistory>15</maxHistory>
</rollingPolicy>

<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>debug</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>

<appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

<file>${log.path}/web_info.log</file>

<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
<charset>UTF-8</charset>
</encoder>

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">

<fileNamePattern>${log.path}/web-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>

<maxHistory>15</maxHistory>
</rollingPolicy>

<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>info</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>

<appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

<file>${log.path}/web_warn.log</file>

<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
<charset>UTF-8</charset> 
</encoder>

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>${log.path}/web-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>

<maxHistory>15</maxHistory>
</rollingPolicy>

<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>warn</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>

<appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">

<file>${log.path}/web_error.log</file>

<encoder>
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
<charset>UTF-8</charset> 
</encoder>

<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
<fileNamePattern>${log.path}/web-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
<timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
<maxFileSize>100MB</maxFileSize>
</timeBasedFileNamingAndTriggeringPolicy>

<maxHistory>15</maxHistory>
</rollingPolicy>

<filter class="ch.qos.logback.classic.filter.LevelFilter">
<level>ERROR</level>
<onMatch>ACCEPT</onMatch>
<onMismatch>DENY</onMismatch>
</filter>
</appender>

<springProfile name="dev">
<logger name="com.sdcm.pmp" level="debug"/>
</springProfile>

</configuration>

application.properties:

server.port=8087

logging.config=classpath:logback-spring.xml
logging.level.dao=debug
logging.level.org.mybatis=debug

main 函数所在的类：

package com.demo;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@MapperScan("com.demo.mapper")
@SpringBootApplication
@ImportResource("classpath:spring-context.xml")
public class DemoApplication {

   public static void main(String[] args) {
       SpringApplication.run(DemoApplication.class, args);
   }

}

mybatis 的其他东西我不写来了，都是插件生成的，

改一下表明为参数：

<insert id="insert" parameterType="com.demo.entity.Man">
insert into ${tableName} (id,name, age)
values (#{id,jdbcType=INTEGER},#{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})
</insert>

因为分库分表后ID不能再自动生成了，而是要有一个ID生成的的方法；

package com.demo.conf;

import com.demo.entity.TableEntity;

public class IDUtil {

public static Integer getID(String entityName) {

/* 可以用一个redis主从集群模式，记为集群A ，一台主两台从负责生产自然递增ID，用另外一套同样的redis 来记录 A中拿到的最新ID，即为集群B。

由于reids 主从同步是从库发起，通过快照同步，异步线程执行，那么同步肯定不是非常及时的，一定是滞后，如果主机宕机，从新选举出新的主机，里面的数据一定不是最新的，如果新的从库再次产生自增ID，那一定和之前产生的重复了。

应用拿到最新ID后都去，和B中记录的ID比较,并且将新的ID记录到B中，如果A中主从因为宕机切换过，那么A中拿到的数据大概率就会小于B中的记录ID，这时候拿B中的记录去替代A中的记录，再次获取递增ID，如果B中出现宕机而导致主从切换，A的记录还是大于B的记录，不影响，完美的ID生成策略*/

//这里不做具体实现，模拟以下就好
return 1;

   }

   public static Integer getIDAndSetDBTable(String entityName,TableEntity entity) {
       //通过实体类名获取这个实体对应的数据库中的最大ID，这里不做具体实现，模拟以下就好
       //int id =IDUtil.getID(entityName);
       entity.tableName="man_1";//实际情况是我们要拿到这个ID后通过这个ID去查ID和库表关系，就是前文上说的那三张关系表，
       //这三张表可以做缓存到本地,拿到关系表后就能知道库名和表名了，这里为了演示就直接写死了
       //设置库名test_1，同样这样也写死
       DataSourceTypeManager.setDataSource("test_1");

return 1;

}

写个junit test 一下：

package com.demo.test;

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;

import com.demo.DemoApplication;
import com.demo.conf.DataSourceTypeManager;
import com.demo.conf.IDUtil;
import com.demo.entity.Man;
import com.demo.mapper.ManMapper;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemoApplication.class)
public class DemoApplicationTests {

@Autowired
ManMapper manMapper;

@Test
public void contextLoads() throws Exception {

       Man man = new Man();
       int id = IDUtil.getIDAndSetDBTable("Man", man);

       man.setId(id);
       man.setAge(32);
       man.setName("如花");
       manMapper.insert(man);
       DataSourceTypeManager.clear();

   }

}

我们数据库有两个表，一个库名叫test ，有个表man 一个数据库名叫test_1,里面有个表man_1,现在都没有数据，

我们执行单元测试跑一下，看看结果如何？

结果如我们所料，当我们修改库名表名的时候真的插入到了不同的库表中，因为太卡了我的电脑就不截图了，上面的精华部分我已经全部贴出，如果有遗漏没有贴出的部分请在下方留意。

这里只演示了插入，查询也是类似，更简单了，相信聪明的读者已经明白怎么弄了