ShardingSphere、SpringBoot、mybatis-plus 分库分表demo

ShardingSphere 是一款开源的分布式数据库中间件，可以实现数据分片、读写分离、分布式事务等功能。下面是一个实战示例，展示如何使用 ShardingSphere 进行数据分片。

示例目标

我们将实现一个简单的应用，通过 ShardingSphere 实现数据库的水平分片。假设我们有一个用户表，我们希望根据用户 ID 进行分片，将数据存储到两个不同的数据库中。

前提条件

1. 安装并配置好 MySQL 数据库。
2. 配置好 ShardingSphere。

步骤

1. 创建数据库和表

假设我们有两个数据库 db0 和 db1，分别在两个 MySQL 实例上。

在 db0 上创建用户表：

CREATE DATABASE db0;
USE db0;
CREATE TABLE t_user (
    user_id INT PRIMARY KEY,
    user_name VARCHAR(50)
);
CREATE TABLE t_user_0 (
                          user_id INT PRIMARY KEY,
                          user_name VARCHAR(50)
);
CREATE TABLE t_user_1 (
                          user_id INT PRIMARY KEY,
                          user_name VARCHAR(50)
);

在 db1 上创建用户表：

CREATE DATABASE db1;
USE db1;
CREATE TABLE t_user (
                        user_id INT PRIMARY KEY,
                        user_name VARCHAR(50)
);
CREATE TABLE t_user_0 (
                          user_id INT PRIMARY KEY,
                          user_name VARCHAR(50)
);
CREATE TABLE t_user_1 (
                          user_id INT PRIMARY KEY,
                          user_name VARCHAR(50)
);

2. 集成 ShardingSphere 到 Spring Boot 应用

添加依赖到 pom.xml：

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

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
        <version>5.1.1</version>
    </dependency>

    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.3.1</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>

</dependencies>

在 application.yml 中配置数据源：

spring:
  shardingsphere:
    # 是否开启
    datasource:
      # 数据源（逻辑名字）
      names: m0,m1
      # 配置数据源
      m0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db0?useSSL=false&autoReconnect=true&characterEncoding=UTF-8&serverTimezone=UTC
        username: root
        password: 123456
      m1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db1?useSSL=false&autoReconnect=true&characterEncoding=UTF-8&serverTimezone=UTC
        username: root
        password: 123456
    # 分片的配置
    rules:
      sharding:
        # 表的分片策略
        tables:
          # 逻辑表的名称
          t_user:
            # 数据节点配置，采用Groovy表达式
            actual-data-nodes: m$->{0..1}.t_user_$->{0..1}
            # 配置策略
            table-strategy:
              # 用于单分片键的标准分片场景
              standard:
                sharding-column: user_id
                # 分片算法名字
                sharding-algorithm-name: user_inline
            database-strategy:
              standard:
                sharding-column: user_id
                sharding-algorithm-name: database_inline
        sharding-algorithms:
          user_inline:
            type: INLINE
            props:
              algorithm-expression: t_user_$->{ user_id % 2}
          database_inline:
            type: INLINE
            props:
              algorithm-expression: m$->{user_id % 2}
    props:
      # 日志显示具体的SQL
      sql-show: true
      sql-comment-parse-enabled: true

创建实体类和仓库：

/**
 * 实体类
 */
@Data
public class TUser {

    @TableId(value = "user_id")
    private Integer userId;

    private String userName;
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, TUser> implements UserService {
}

@Mapper
public interface UserMapper extends BaseMapper<TUser> {
}

编写一个简单的控制器进行数据插入和查询：

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

    @Resource
    private UserServiceImpl userServiceImpl;

    @PostMapping("/add")
    public void addUser(@RequestBody TUser tUser) {
        userServiceImpl.save(tUser);
    }

    @GetMapping("/get")
    public List<TUser> getAllUsers() {
        List<TUser> list = userServiceImpl.list();
        return list;
    }
}

运行应用

1. 启动 MySQL 数据库实例，并创建相应的数据库和表。
2. 启动 Spring Boot 应用。

测试

可以通过以下 RESTful API 测试数据插入和查询：

# 插入用户
curl -X POST -H "Content-Type: application/json" -d '{"userId": 1, "userName": "John"}' http://localhost:8080/users
curl -X POST -H "Content-Type: application/json" -d '{"userId": 2, "userName": "Jane"}' http://localhost:8080/users

# 查询所有用户
curl http://localhost:8080/users

通过这种方式，你可以看到 ShardingSphere 自动将数据分片到不同的数据库中。

这是一个简单的示例，展示了如何使用 ShardingSphere 进行数据分片。ShardingSphere 还提供了更多高级功能，如读写分离、分布式事务等，可以根据需要进一步配置和使用。