Sharding-JDBC 整合实战：实现高效数据库分库分表

马丁的代码日记

已于 2024-08-19 15:04:13 修改

阅读量518

点赞数 6

分类专栏： MySQL SpringBoot 文章标签：数据库大数据数据库架构

于 2024-08-19 15:02:52 首次发布

本文链接：https://blog.csdn.net/2401_84664550/article/details/141325764

版权

MySQL 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

SpringBoot

1 篇文章 0 订阅

订阅专栏

Sharding-JDBC 整合实战：实现高效数据库分库分表

一、引言

（一）Sharding-JDBC 在数据库处理中的作用

（二）本次整合的目标和预期效果

二、项目初始化

（一）使用 Maven 创建 Spring Boot 2.7 项目

在当今大数据时代，随着数据量的不断增长，传统的单库单表数据库架构已经难以满足业务需求。为了提高数据库的性能和可扩展性，分库分表技术应运而生。Sharding-JDBC 作为一款优秀的分布式数据库中间件，为我们提供了一种简单、高效的分库分表解决方案。本文将详细介绍如何使用 Sharding-JDBC 实现数据库的分库分表，并通过实际代码示例进行演示。

一、引言

（一）Sharding-JDBC 在数据库处理中的作用

在现代应用程序中，数据库往往是系统的核心组成部分。随着业务的发展，数据量不断增加，单库单表的架构可能会导致性能下降、扩展性受限等问题。Sharding-JDBC 旨在解决这些问题，它可以将一个大型数据库拆分成多个小的数据库分片（Shard），每个分片可以独立地进行管理和扩展。通过这种方式，可以提高数据库的并发处理能力和存储容量，从而更好地满足业务需求。

（二）本次整合的目标和预期效果

本次整合的目标是使用 Sharding-JDBC 实现数据库的分库分表，将用户数据按照一定的规则分布到多个数据库和表中。预期效果是提高数据库的性能和可扩展性，减少数据冗余，同时保证数据的一致性和完整性。

二、项目初始化

（一）使用 Maven 创建 Spring Boot 2.7 项目

首先，我们需要使用 Maven 来创建一个 Spring Boot 2.7 项目。打开终端或命令提示符，进入到你想要创建项目的目录，然后执行以下命令：

mvn archetype:generate -DgroupId=com.example -DartifactId=sharding-jdbc-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

执行上述命令后，Maven 将会创建一个名为 sharding-jdbc-demo 的项目框架。接下来，我们需要将项目转换为 Spring Boot 项目。在项目的 pom.xml 文件中，添加以下 Spring Boot 相关的依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.0</version>
</parent>

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

（二）项目结构概述

创建好项目后，我们来了解一下项目的结构。一个典型的 Spring Boot 项目结构如下：

sharding-jdbc-demo
├── pom.xml
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── ShardingJdbcDemoApplication.java
│   │   └── resources
│   │       ├── application.properties
│   │       └── static
│   │           └──...
│   └── test
│       ├── java
│       │   └── com
│       │       └── example
│       │           └── ShardingJdbcDemoApplicationTests.java
│       └── resources
└── target
    ├── classes
    └── generated-sources

在这个项目结构中，pom.xml 是项目的 Maven 配置文件，用于管理项目的依赖和构建信息。src/main/java 目录下存放的是项目的 Java 代码，ShardingJdbcDemoApplication.java 是项目的启动类。src/main/resources 目录下存放的是项目的配置文件，如 application.properties。src/test/java 目录下存放的是项目的测试代码，ShardingJdbcDemoApplicationTests.java 是项目的测试类。

三、依赖配置

接下来，我们需要在项目的 pom.xml 文件中添加 Sharding-JDBC 和数据库驱动的依赖。以下是完整的依赖配置：

<dependencies>
    <!-- Spring Boot 相关依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Sharding-JDBC 依赖 -->
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.x.x</version>
    </dependency>
    <!-- 数据库驱动依赖 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

在上述依赖配置中，我们添加了 spring-boot-starter-web 依赖，用于构建 Web 应用程序。sharding-jdbc-spring-boot-starter 是 Sharding-JDBC 的 Spring Boot 启动器依赖，它会自动配置 Sharding-JDBC 的相关组件。mysql-connector-java 是 MySQL 数据库的驱动依赖，用于连接 MySQL 数据库。

四、配置文件

在项目的 src/main/resources 目录下，创建一个 application.properties 文件，用于配置数据源和 Sharding-JDBC 的分库分表规则。以下是完整的配置内容：

# 主库配置
spring.datasource.master.url=jdbc:mysql://localhost:3306/master_db?useSSL=false&serverTimezone=UTC
spring.datasource.master.username=root
spring.datasource.master.password=123456

# 从库配置（如有）
spring.datasource.slave.url=jdbc:mysql://localhost:3306/slave_db?useSSL=false&serverTimezone=UTC
spring.datasource.slave.username=root
spring.datasource.slave.password=123456

# Sharding-JDBC 分库分表配置
sharding.jdbc.config.sharding.default-database-strategy.inline.sharding-column=user_id
sharding.jdbc.config.sharding.default-database-strategy.inline.algorithm-expression=master_db_${user_id % 2}

sharding.jdbc.config.sharding.tables.user.table-strategy.inline.sharding-column=id
sharding.jdbc.config.sharding.tables.user.table-strategy.inline.algorithm-expression=user_${id % 4}

在上述配置中，我们首先配置了主库的连接信息，包括数据库 URL、用户名和密码。如果有从库，也可以在这里进行配置。接下来，我们配置了 Sharding-JDBC 的分库分表规则。sharding.jdbc.config.sharding.default-database-strategy.inline.sharding-column 用于指定分库的列，这里我们使用 user_id 作为分库列。sharding.jdbc.config.sharding.default-database-strategy.inline.algorithm-expression 用于指定分库的算法表达式，这里我们使用 master_db_${user_id % 2} 作为分库算法表达式，表示根据 user_id 的值对 2 取模，将数据分布到 master_db_0 和 master_db_1 两个数据库中。

同样地，sharding.jdbc.config.sharding.tables.user.table-strategy.inline.sharding-column 用于指定分表的列，这里我们使用 id 作为分表列。sharding.jdbc.config.sharding.tables.user.table-strategy.inline.algorithm-expression 用于指定分表的算法表达式，这里我们使用 user_${id % 4} 作为分表算法表达式，表示根据 id 的值对 4 取模，将数据分布到 user_0、user_1、user_2 和 user_3 四个表中。

五、实体类创建

接下来，我们需要创建一个实体类来表示用户数据。在 src/main/java/com/example 目录下，创建一个 User.java 文件，代码如下：

import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Data
@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private Integer age;
}

在上述代码中，我们使用了 Lombok 库来简化代码。@Data 注解用于生成 getter、setter、equals、hashCode 和 toString 方法。@Entity 注解用于将该类标识为一个实体类，@Table 注解用于指定该实体类对应的表名。@Id 注解用于指定主键，@GeneratedValue 注解用于指定主键的生成策略，这里我们使用自增策略。

六、数据访问层（DAO）

接下来，我们需要创建一个数据访问层（DAO）来操作用户数据。在 src/main/java/com/example/repository 目录下，创建一个 UserRepository.java 文件，代码如下：

import org.springframework.data.jpa.repository.JpaRepository;
import com.example.User;

public interface UserRepository extends JpaRepository<User, Long> {
}

在上述代码中，我们创建了一个 UserRepository 接口，继承自 JpaRepository 接口。JpaRepository 接口提供了一些常用的数据库操作方法，如 save、findById、findAll 等。我们通过继承 JpaRepository 接口，无需编写具体的数据库操作代码，就可以直接使用这些方法来操作数据库。

七、服务层（Service）

接下来，我们需要创建一个服务层（Service）来处理业务逻辑。在 src/main/java/com/example/service 目录下，创建一个 UserService.java 文件，代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.example.repository.UserRepository;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    // 业务方法实现
    public void saveUser(User user) {
        userRepository.save(user);
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    public Iterable<User> getAllUsers() {
        return userRepository.findAll();
    }
}

在上述代码中，我们创建了一个 UserService 类，使用 @Service 注解将其标识为一个服务类。在类中，我们通过 @Autowired 注解注入了 UserRepository 对象，然后实现了一些业务方法，如 saveUser 用于保存用户数据，getUserById 用于根据 ID 查询用户数据，getAllUsers 用于查询所有用户数据。

八、控制器（Controller）

接下来，我们需要创建一个控制器（Controller）来处理 HTTP 请求。在 src/main/java/com/example/controller 目录下，创建一个 UserController.java 文件，代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.example.service.UserService;
import com.example.User;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    // 保存用户数据
    @PostMapping
    public void saveUser(@RequestBody User user) {
        userService.saveUser(user);
    }

    // 根据 ID 查询用户数据
    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    // 查询所有用户数据
    @GetMapping
    public Iterable<User> getAllUsers() {
        return userService.getAllUsers();
    }
}

在上述代码中，我们创建了一个 UserController 类，使用 @RestController 注解将其标识为一个 RESTful 控制器。@RequestMapping("/users") 注解用于指定控制器的请求路径前缀。在类中，我们通过 @Autowired 注解注入了 UserService 对象，然后实现了三个接口，分别用于保存用户数据、根据 ID 查询用户数据和查询所有用户数据。

九、测试与结果演示

（一）编写单元测试用例

接下来，我们需要编写一些单元测试用例来验证我们的代码是否正确。在 src/test/java/com/example 目录下，创建一个 UserControllerTest.java 文件，代码如下：

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.when;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import com.example.controller.UserController;
import com.example.service.UserService;
import com.example.User;

@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    void saveUser() throws Exception {
        User user = new User();
        user.setName("John Doe");
        user.setAge(30);

        when(userService.saveUser(user)).thenReturn(user);

        mockMvc.perform(MockMvcRequestBuilders.post("/users")
               .contentType(MediaType.APPLICATION_JSON)
               .content("{\"name\":\"John Doe\",\"age\":30}"))
               .andExpect(MockMvcResultMatchers.status().isCreated())
               .andExpect(MockMvcResultMatchers.jsonPath("$.name").value("John Doe"))
               .andExpect(MockMvcResultMatchers.jsonPath("$.age").value(30));
    }

    @Test
    void getUserById() throws Exception {
        User user = new User();
        user.setId(1L);
        user.setName("John Doe");
        user.setAge(30);

        when(userService.getUserById(1L)).thenReturn(user);

        mockMvc.perform(MockMvcRequestBuilders.get("/users/1"))
               .andExpect(MockMvcResultMatchers.status().isOk())
               .andExpect(MockMvcResultMatchers.jsonPath("$.id").value(1))
               .andExpect(MockMvcResultMatchers.jsonPath("$.name").value("John Doe"))
               .andExpect(MockMvcResultMatchers.jsonPath("$.age").value(30));
    }

    @Test
    void getAllUsers() throws Exception {
        User user1 = new User();
        user1.setId(1L);
        user1.setName("John Doe");
        user1.setAge(30);

        User user2 = new User();
        user2.setId(2L);
        user2.setName("Jane Doe");
        user2.setAge(25);

        when(userService.getAllUsers()).thenReturn(Iterable.of(user1, user2));

        mockMvc.perform(MockMvcRequestBuilders.get("/users"))
               .andExpect(MockMvcResultMatchers.status().isOk())
               .andExpect(MockMvcResultMatchers.jsonPath("$[0].id").value(1))
               .andExpect(MockMvcResultMatchers.jsonPath("$[0].name").value("John Doe"))
               .andExpect(MockMvcResultMatchers.jsonPath("$[0].age").value(30))
               .andExpect(MockMvcResultMatchers.jsonPath("$[1].id").value(2))
               .andExpect(MockMvcResultMatchers.jsonPath("$[1].name").value("Jane Doe"))
               .andExpect(MockMvcResultMatchers.jsonPath("$[1].age").value(25));
    }
}

在上述代码中，我们使用了 Spring Boot 的 WebMvcTest 注解来对 UserController 进行单元测试。@MockBean 注解用于创建一个模拟的 UserService 对象，我们可以通过 when 方法来设置模拟对象的行为。在测试方法中，我们使用 MockMvc 对象来发送 HTTP 请求，并使用 MockMvcResultMatchers 来验证响应的状态码和内容是否符合预期。

（二）展示数据插入、查询等操作的结果

运行单元测试用例，确保所有测试都通过。接下来，我们可以启动应用程序，然后使用 Postman 或其他 HTTP 客户端来发送 HTTP 请求，进行数据插入、查询等操作。以下是一些示例请求：

插入用户数据

POST http://localhost:8080/users
Content-Type: application/json

{
    "name": "John Doe",
    "age": 30
}

查询用户数据

GET http://localhost:8080/users/1

查询所有用户数据

GET http://localhost:8080/users

通过发送这些请求，我们可以验证数据是否成功插入到数据库中，并且是否能够按照分库分表规则进行查询。

（三）验证分库分表的效果

为了验证分库分表的效果，我们可以查看数据库中的数据分布情况。根据我们的分库分表规则，数据应该被分布到 master_db_0 和 master_db_1 两个数据库中，以及 user_0、user_1、user_2和user_3`四个表中。

我们可以通过数据库管理工具连接到数据库，查看各个数据库和表中的数据情况。如果数据按照我们预期的规则进行了分布，那么说明分库分表的配置是成功的。

例如，我们可以查看master_db_0和master_db_1数据库中的user表，确认数据是否根据user_id进行了分库存储。同时，查看每个数据库中的user_0、user_1、user_2和user_3表，确认数据是否根据id进行了分表存储。

通过实际查看数据库中的数据分布情况，我们可以直观地验证分库分表的效果，确保数据被正确地分散到多个数据库和表中，从而提高数据库的性能和可扩展性。

十、总结

（一）整合过程中的关键步骤和注意事项

在整合 Sharding-JDBC 的过程中，以下是一些关键步骤和需要注意的事项：

项目初始化：使用 Maven 创建 Spring Boot 项目，并确保添加了正确的依赖，包括 Spring Boot 相关依赖、Sharding-JDBC 依赖和数据库驱动依赖。
配置文件：在application.properties或application.yml中配置数据源信息和 Sharding-JDBC 的分库分表规则。需要仔细设置分库分表的列和算法表达式，以确保数据能够按照预期进行分布。
实体类创建：创建与数据库表对应的实体类，使用合适的注解来标识实体类的属性和表结构的映射关系。
数据访问层（DAO）：创建数据访问层接口，继承自JpaRepository，以便利用其提供的常用数据库操作方法。
服务层（Service）：在服务层中实现业务逻辑，通过注入数据访问层对象来进行数据库操作。
控制器（Controller）：创建控制器来处理 HTTP 请求，将请求转发到服务层进行处理，并将结果返回给客户端。

在整合过程中，还需要注意以下几点：

确保数据库服务器已经启动并正常运行，且数据库连接信息正确无误。
仔细检查分库分表规则的配置，避免出现错误的分片策略，导致数据分布不均匀或查询结果不准确。
在进行测试时，要全面覆盖各种操作场景，包括数据插入、查询、更新和删除等，以确保系统的稳定性和正确性。

（二）对未来扩展和优化的思考

通过使用 Sharding-JDBC 实现了数据库的分库分表，为系统的性能和可扩展性提供了一定的保障。然而，随着业务的不断发展，可能还需要进一步扩展和优化系统。

在未来的扩展方面，可以考虑以下几点：

增加从库：根据实际业务需求，可以增加从库来提高读性能，缓解主库的压力。可以在配置文件中添加从库的连接信息，并配置读写分离策略。
动态分库分表：目前的分库分表规则是在配置文件中静态定义的。在实际应用中，可以考虑实现动态分库分表，根据数据量的增长和业务需求的变化，自动调整分库分表的策略。
分布式事务处理：在分库分表的环境下，分布式事务处理是一个重要的问题。可以研究和采用合适的分布式事务解决方案，确保数据的一致性和完整性。

在优化方面，可以考虑以下几点：

索引优化：根据查询需求，合理地创建索引，提高查询性能。但要注意避免过度创建索引，以免影响插入和更新操作的性能。

SQL 优化：编写高效的 SQL 查询语句，避免全表扫描和不必要的连接操作。可以通过分析查询计划和性能指标，对 SQL 语句进行优化。
缓存优化：合理地使用缓存，将经常访问的数据缓存起来，减少对数据库的查询次数，提高系统的性能。

总之，Sharding-JDBC 为我们提供了一种强大的数据库分库分表解决方案，但在实际应用中，还需要根据业务需求和系统性能进行不断的扩展和优化，以确保系统能够满足不断增长的业务需求。

十一、作者介绍

我是马丁，一名专业的 Java 程序员。我热衷于探索和分享技术知识，希望通过这篇博客能够帮助大家更好地理解和应用 Sharding-JDBC 技术。感谢读者的阅读，欢迎大家交流和关注！

马丁的代码日记

关注

6
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Sharding-JDBC 整合实战：实现高效数据库分库分表

创建好项目后，我们来了解一下项目的结构。├── src│ ├── main│ │ └──...│ └── test│ ├── java└── target在这个项目结构中，pom.xml是项目的 Maven 配置文件，用于管理项目的依赖和构建信息。目录下存放的是项目的 Java 代码，是项目的启动类。目录下存放的是项目的配置文件，如。目录下存放的是项目的测试代码，是项目的测试类。项目初始化。
复制链接

扫一扫