集成 Sharding-JDBC 实现分库分表

Sharding-JDBC 是 Apache ShardingSphere 提供的一款分布式数据库中间件，支持数据分片、读写分离和分布式事务等功能。本文将详细介绍如何在 RuoYi 框架中集成 Sharding-JDBC，实现订单数据的分库分表。

1. 添加 Sharding-JDBC 依赖

在 ruoyi-framework\pom.xml 文件中，添加 Sharding-JDBC 的依赖：

<!-- sharding-jdbc 分库分表 -->
<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-core</artifactId>
    <version>4.1.1</version>
</dependency>

2. 创建测试数据库

创建两个测试数据库，用于存储订单数据。

-- 创建数据库 ry-order1
create database `ry-order1`;

-- 创建数据库 ry-order2
create database `ry-order2`;

3. 创建测试订单表

在每个数据库中创建两张订单表 sys_order_0 和 sys_order_1，用于存储订单数据。

-- 创建表 sys_order_0
drop table if exists sys_order_0;
create table sys_order_0 (
  order_id      bigint(20)      not null                   comment '订单ID',
  user_id       bigint(64)      not null                   comment '用户编号',
  status        char(1)         not null                   comment '状态（0交易成功 1交易失败）',
  order_no      varchar(64)     default null               comment '订单流水',
  primary key (order_id)
) engine=innodb comment = '订单信息表';

-- 创建表 sys_order_1
drop table if exists sys_order_1;
create table sys_order_1 (
  order_id      bigint(20)      not null                   comment '订单ID',
  user_id       bigint(64)      not null                   comment '用户编号',
  status        char(1)         not null                   comment '状态（0交易成功 1交易失败）',
  order_no      varchar(64)     default null               comment '订单流水',
  primary key (order_id)
) engine=innodb comment = '订单信息表';

4. 配置数据源

在 application-druid.yml 文件中，配置多个数据源，包括主库和两个订单库。

# 数据源配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    druid:
      # 主库数据源
      master:
        url: jdbc:mysql://localhost:3306/ry?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: password
      # 订单库1
      order1:
        enabled: true
        url: jdbc:mysql://localhost:3306/ry-order1?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: password
      # 订单库2
      order2:
        enabled: true
        url: jdbc:mysql://localhost:3306/ry-order2?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: password

5. 下载并覆盖相关插件

下载并解压插件包 ruoyi/集成sharding-jdbc实现分库分表.zip，覆盖到 RuoYi 工程中。该插件包中包含了 Sharding-JDBC 的配置文件和相关代码。

6. 测试验证

通过访问以下 URL 验证分库分表的配置是否成功：

• 测试分库：

  • 访问 http://localhost/order/add/1 (opens new window) 验证数据是否入库到 ry-order2。
  • 访问 http://localhost/order/add/2 (opens new window) 验证数据是否入库到 ry-order1。

• 测试分表：

  • 根据 order_id % 2，验证数据是否分别入库到 sys_order_0 和 sys_order_1。

7. 详细代码解析

订单服务接口 (OrderService.java)：

package com.ruoyi.system.service;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.ruoyi.system.domain.SysOrder;
import com.ruoyi.system.mapper.SysOrderMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {

    @Autowired
    private SysOrderMapper orderMapper;

    /**
     * 插入订单
     * 根据order_id自动选择分库分表
     *
     * @param sysOrder 订单信息
     */
    @Transactional
    public void insertOrder(SysOrder sysOrder) {
        orderMapper.insertOrder(sysOrder);
    }

    @DS("test")
    public SysOrder selectOrderById(Long orderId) {
        return orderMapper.selectOrderById(orderId);
    }
}

订单 Mapper (SysOrderMapper.java)：

package com.ruoyi.system.mapper;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.ruoyi.system.domain.SysOrder;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

public interface SysOrderMapper {

    /**
     * 插入订单
     *
     * @param sysOrder 订单信息
     */
    @Insert("INSERT INTO sys_order_${order_id % 2} (order_id, user_id, status, order_no) VALUES (#{orderId}, #{userId}, #{status}, #{orderNo})")
    void insertOrder(SysOrder sysOrder);

    /**
     * 根据订单ID查询订单
     *
     * @param orderId 订单ID
     * @return 订单信息
     */
    @DS("test")
    @Select("SELECT * FROM sys_order_${order_id % 2} WHERE order_id = #{orderId}")
    SysOrder selectOrderById(Long orderId);
}

订单控制器 (OrderController.java)：

package com.ruoyi.web.controller.system;

import com.ruoyi.system.domain.SysOrder;
import com.ruoyi.system.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    @PostMapping("/add/{id}")
    public String addOrder(@PathVariable Long id) {
        SysOrder order = new SysOrder();
        order.setOrderId(id);
        order.setUserId(id);
        order.setStatus("0");
        order.setOrderNo("Order_" + id);
        orderService.insertOrder(order);
        return "Order added successfully!";
    }

    @GetMapping("/get/{id}")
    public SysOrder getOrder(@PathVariable Long id) {
        return orderService.selectOrderById(id);
    }
}

总结

通过本文的详细步骤，我们成功地在 RuoYi 项目中集成了 Sharding-JDBC，实现了订单数据的分库分表。Sharding-JDBC 不仅可以分库分表，还可以实现读写分离和分布式事务等功能，为项目提供了良好的扩展性和高性能保障。