分库分表中间件Sharding-JDBC详解

1. 分库分表概述
- 1.1 为什么需要分库分表
- 1.2 分库分表的方式
- - 1.2.1.垂直分表
  - 1.2.2.垂直分库
  - 1.2.3.水平分库
  - 1.2.4.水平分表
- 1.3 分库分表问题分析
- - 1.3.1 事务一致性问题
  - 1.3.2 跨节点关联查询
  - 1.3.3 跨节点分页、排序函数
  - 1.3.4 主键避重
  - 1.3.5 公共表
1. Sharding-JDBC详解
- 2.1 Sharding-JDBC简介
- 2.2 Sharding-JDBC性能对比
- 2.3 Sharding-JDBC原理分析
1. 实现验证
- 3.1 环境准备
- - 3.1.1 环境说明
  - 3.1.2 创建数据库
- 3.2 代码实现
- - 3.2.1 pom.xml
  - 3.2.2 application.properties
  - 3.2.3 SwaggerConfig
  - 3.2.4 Order
  - 3.2.5 OrderMapper
  - 3.2.6 OrderService
  - 3.2.7 OrderServiceImpl
  - 3.2.8 OrderController
  - 3.2.8 ShardingSimpleApplication
- 3.3 数据验证

1. 分库分表概述

1.1 为什么需要分库分表

随着公司业务快速发展，数据库中的数据量增大，访问性能也变慢了，虽然通过机器集群，sql优化，性能调优等方式在一定程度上可以起到提高性能的作用，但是并不能从根本上解决单库，单表数据量过大的问题。

分库分表就是为了解决由于数据量过大而导致数据库性能降低的问题，将原来独立的数据库拆分成若干数据库组成，将数据大表拆分成若干数据表组成，使得单一数据库、单一数据表的数据量变小，从而达到提升数据库性能的目的。

1.2 分库分表的方式

分库分表按方式有两种：垂直拆分和水平拆分。
垂直切分拆的是表结构，水平拆分拆的是数据。

分库分表按类型包括分库和分表两个部分，在生产中通常包括：垂直分库、水平分库、垂直分表、水平分表四种方式。

归根结底分库要解决的是硬件资源的问题，不管是拆分字段，还是拆分数据，都是要拆到不同的数据库不同的服务器上，从硬件资源上解决性能瓶颈。而分表是解决单表数据量过大的问题，拆分完后还是放在同一数据库中不同表里面，只是减少了单表的读写锁资源消耗，如果性能瓶颈在硬件资源，只是简单的分表并不能从根本上解决问题，所有具体分库分表亦或者是结合使用都要结合具体的业务场景，一切撇开实际业务场景谈需求都是耍流氓。

1.2.1.垂直分表

垂直分表定义：将一个表按照字段分成多表，每个表存储其中一部分字段。

它带来的提升是：
1.为了避免IO争抢并减少锁表的几率，查看详情的用户与商品信息浏览互不影响。
2.充分发挥热门数据的操作效率，商品信息的操作的高效率不会被商品描述的低效率所拖累。

一般来说，某业务实体中的各个数据项的访问频次是不一样的，部分数据项可能是占用存储空间比较大的BLOB或是TEXT。例如上例中的商品描述。所以，当表数据量很大时，可以将表按字段切开，将热门字段、冷门字段分开放置在不同库中，这些库可以放在不同的存储设备上，避免IO争抢。垂直切分带来的性能提升主要集中在热门数据的操作效率上，而且磁盘争用情况减少。

通常我们按以下原则进行垂直拆分:

把不常用的字段单独放在一张表;
把text，blob等大字段拆分出来放在附表中;
经常组合查询的列放在一张表中

1.2.2.垂直分库

垂直分库是指按照业务将表进行分类，分布到不同的数据库上面，每个库可以放在不同的服务器上，它的核心理念是专库专用。

它带来的提升是：
解决业务层面的耦合，业务清晰能对不同业务的数据进行分级管理、维护、监控、扩展等高并发场景下，垂直分库一定程度的提升IO、数据库连接数、降低单机硬件资源的瓶颈垂直分库通过将表按业务分类，然后分布在不同数据库，并且可以将这些数据库部署在不同服务器上，从而达到多个服务器共同分摊压力的效果，但是依然没有解决单表数据量过大的问题。

1.2.3.水平分库

水平分库是把同一个表的数据按一定规则拆到不同的数据库中，每个库可以放在不同的服务器上。

它带来的提升是：
解决了单库大数据，高并发的性能瓶颈。提高了系统的稳定性及可用性。当一个应用难以再细粒度的垂直切分，或切分后数据量行数巨大，存在单库读写、存储性能瓶颈，这时候就需要进行水平分库了，经过水平切分的优化，往往能解决单库存储量及性能瓶颈。但由于同一个表被分配在不同的数据库，需要额外进行数据操作的路由工作，因此大大提升了系统复杂度。

1.2.4.水平分表

水平分表是在同一个数据库内，把同一个表的数据按一定规则拆到多个表中。

它带来的提升是：
优化单一表数据量过大而产生的性能问题避免IO争抢并减少锁表的几率库内的水平分表，解决了单一表数据量过大的问题，分出来的小表中只包含一部分数据，从而使得单个表的数据量变小，提高检索性能。

1.3 分库分表问题分析

1.3.1 事务一致性问题

由于分库分表把数据分布在不同库甚至不同服务器，不可避免会带来分布式事务问题。

1.3.2 跨节点关联查询

由于原来一张表的数据现在分布在不同数据库，不同表中，在涉及到多表关联，一定要设计好分片策略以及查询条件，否则很可能出现笛卡尔积现象，导致性能更低。

1.3.3 跨节点分页、排序函数

跨节点多库进行查询时，limit分页、order by排序等问题，就变得比较复杂了。需要先在不同的分片节点中将数据进行排序并返回，然后将不同分片返回的结果集进行汇总和再次排序。

1.3.4 主键避重

不能在采用数据库自增主键，应采用分布式id，保证全局唯一。

1.3.5 公共表

实际的应用场景中，参数表、数据字典表等都是数据量较小，变动少，而且属于高频联合查询的依赖表。例子中地理区域表也属于此类型。可以将这类表在每个数据库都保存一份，所有对公共表的更新操作都同时发送到所有分库执行。

2. Sharding-JDBC详解

2.1 Sharding-JDBC简介

Apache ShardingSphere 是一套开源的分布式数据库解决方案组成的生态圈，它由 JDBC、Proxy 和 Sidecar（规划中）这 3 款既能够独立部署，又支持混合部署配合使用的产品组成。它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如 Java 同构、异构语言、云原生等各种多样化的应用场景。

Apache ShardingSphere 5.x 版本开始致力于可插拔架构，项目的功能组件能够灵活的以可插拔的方式进行扩展。目前，数据分片、读写分离、数据加密、影子库压测等功能，以及 MySQL、PostgreSQL、SQLServer、Oracle 等 SQL 与协议的支持，均通过插件的方式织入项目。开发者能够像使用积木一样定制属于自己的独特系统。Apache ShardingSphere 目前已提供数十个 SPI 作为系统的扩展点，仍在不断增加中。

ShardingSphere 已于2020年4月16日成为 Apache 软件基金会的顶级项目。

定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。

适用于任何基于 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC。
支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP 等。
支持任意实现 JDBC 规范的数据库，目前支持 MySQL，Oracle，SQLServer，PostgreSQL 以及任何遵循 SQL92 标准的数据库。

官方地址：https://shardingsphere.apache.org/index_zh.html

sharding-jdbc官网文档：https://shardingsphere.apache.org/document/current/cn/overview/#shardingsphere-jdbc

在这里插入图片描述

2.2 Sharding-JDBC性能对比

1.性能损耗测试：服务器资源充足、并发数相同，比较JDBC和Sharding-JDBC性能损耗，Sharding-JDBC相对JDBC损耗不超过7%。
2.性能对比测试：服务器资源使用到极限，相同的场景JDBC与Sharding-JDBC的吞吐量相当。

性能对比测试：服务器资源使用到极限，Sharding-JDBC采用分库分表后，Sharding-JDBC吞吐量较JDBC不分表有接近2倍的提升。

2.3 Sharding-JDBC原理分析

执行流程： SQL解析 => 查询优化 => SQL路由 => SQL改写 => SQL执行 => 结果归并

3. 实现验证

人工创建两张表，t_order_1和t_order_2，这两张表是订单表拆分后的表，通过Sharding-Jdbc向订单表插入数据，按照一定的分片规则，主键为偶数的进入t_order_1，另一部分数据进入t_order_2，通过Sharding-Jdbc 查询数据，根据 SQL语句的内容从t_order_1或t_order_2查询数据。

3.1 环境准备

3.1.1 环境说明

操作系统：Win10
数据库：MySQL-5.7.25
JDK：64位 jdk1.8.0_201
应用框架：spring-boot-2.1.3.RELEASE，Mybatis3.5.0
Sharding-JDBC：sharding-jdbc-spring-boot-starter-4.0.0-RC1

3.1.2 创建数据库

创建订单库order_db_1，order_db_2
在order_db_1yuorder_db_2中分别创建t_order_1、t_order_2表

-- 创建订单库order_db
CREATE DATABASE `order_db_1` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
CREATE DATABASE `order_db_2` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
-- 在order_db中创建t_order_1、t_order_2表,这个要在两个库分别创建
DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE `t_order_1` (
`order_id` bigint(20) NOT NULL COMMENT '订单id',
`price` decimal(10, 2) NOT NULL COMMENT '订单价格',
`user_id` bigint(20) NOT NULL COMMENT '下单用户id',
`status` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
DROP TABLE IF EXISTS `t_order_2`;
CREATE TABLE `t_order_2` (
`order_id` bigint(20) NOT NULL COMMENT '订单id',
`price` decimal(10, 2) NOT NULL COMMENT '订单价格',
`user_id` bigint(20) NOT NULL COMMENT '下单用户id',
`status` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

3.2 代码实现

3.2.1 pom.xml

<?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 https://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.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zrj.sharding</groupId>
    <artifactId>sharding-simple</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sharding-simple</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--swagger2依赖-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--sharding-jdbc-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
        </dependency>
        <dependency>
            <groupId>javax.interceptor</groupId>
            <artifactId>javax.interceptor-api</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-typehandlers-jsr310</artifactId>
            <version>1.0.2</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3.2.2 application.properties

server.port=8080
spring.application.name = sharding-jdbc-simple-demo
server.servlet.context-path = /sharding-jdbc-simple-demo
server.servlet.encoding.enabled = true
server.servlet.encoding.charset = UTF-8
server.servlet.encoding.force = true
spring.main.allow-bean-definition-overriding = true
# mybatis驼峰映射
mybatis.configuration.map-underscore-to-camel-case = true
#sharding-jdbc分片规则配置
#数据源
spring.shardingsphere.datasource.names = m0,m1,m2
spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 123456
spring.shardingsphere.datasource.m2.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = 123456
spring.shardingsphere.datasource.m0.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m0.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m0.url = jdbc:mysql://localhost:3306/user_db?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
spring.shardingsphere.datasource.m0.username = root
spring.shardingsphere.datasource.m0.password = 123456
# 主库从库逻辑数据源定义 ds0为user_db
#spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-source-name=m0
#spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-source-names=s0
# 分库策略，以user_id为分片键，分片策略为user_id % 2 + 1，user_id为偶数操作m1数据源，否则操作m2。
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}
# 指定t_order表的数据分布情况，配置数据节点 m1.t_order_1,m1.t_order_2,m2.t_order_1,m2.t_order_2
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m$->{1..2}.t_order_$->{1..2}
#spring.shardingsphere.sharding.tables.t_user.actual-data-nodes = m$->{0}.t_user
#spring.shardingsphere.sharding.tables.t_user.actual‐data‐nodes = m$‐>{0}.t_user
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes = m0.t_user
# 指定t_order表的主键生成策略为SNOWFLAKE
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE
# 指定t_order表的分片策略，分片策略包括分片键和分片算法
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column = order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression = t_order_$->{order_id % 2 + 1}
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression = t_user
# 打开sql输出日志
spring.shardingsphere.props.sql.show = true
swagger.enable = true
logging.level.root = info
logging.level.org.springframework.web = info
logging.level.com.zrj.sharding  = debug
logging.level.druid.sql = debug

3.2.3 SwaggerConfig

package com.zrj.sharding.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/** * Swagger2配置 * * @author zrj * @since 2021/8/22 **/
@Configuration
@EnableSwagger2
public class SwaggerConfig { 
    /** * swagger2的配置文件，这里可以配置swagger2的一些基本的内容，比如扫描的包等等 */
    @Bean
    public Docket createRestApi() { 
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                // 为当前包路径
                .apis(RequestHandlerSelectors.basePackage("com.zrj.sharding.controller")).paths(PathSelectors.any())
                .build();
    }
    /** * 构建 api文档的详细信息函数,注意这里的注解引用的是哪个 */
    private ApiInfo apiInfo() { 
        return new ApiInfoBuilder()
                // 页面标题
                .title("分库分表管理")
                // 创建人信息
                .contact(new Contact("shardingsphere", "https://shardingsphere.apache.org/index_zh.html", ""))
                // 版本号
                .version("V1.0")
                // 描述
                .description("sharding-jdbc")
                .build();
    }
}

3.2.4 Order

package com.zrj.sharding.entity;
import java.io.Serializable;
/** * (TOrder)实体类 * * @author zrj * @since 2021/8/22 */
public class Order implements Serializable { 
    private static final long serialVersionUID = 849675519182821942L;
    /** * 订单id */
    private Long orderId;
    /** * 订单价格 */
    private Double price;
    /** * 下单用户id */
    private Long userId;
    /** * 订单状态 */
    private String status;
    public Long getOrderId() { 
        return orderId;
    }
    public void setOrderId(Long orderId) { 
        this.orderId = orderId;
    }
    public Double getPrice() { 
        return price;
    }
    public void setPrice(Double price) { 
        this.price = price;
    }
    public Long getUserId() { 
        return userId;
    }
    public void setUserId(Long userId) { 
        this.userId = userId;
    }
    public String getStatus() { 
        return status;
    }
    public void setStatus(String status) { 
        this.status = status;
    }
    @Override
    public String toString() { 
        return "TOrder {" +
                "orderId : " + orderId + ", " +
                "price : " + price + ", " +
                "userId : " + userId + ", " +
                "status : " + status + ", " +
                '}';
    }
}

Response

package com.zrj.sharding.entity;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/** * 统一结果集 * * @author zrj * @since 2021/8/22 **/
@Data
@Component
public class Response<T> { 
    public static ResponseCode responseCode;
    /** * 提示消息 */
    public String message;
    /** * 具体返回的数据 */
    public T data;
    /** * 状态码 */
    public String code;
    public Response(String code, String message, T data) { 
        this.message = message;
        this.code = code;
        this.data = data;
    }
    public Response(String code, String msg) { 
        this.message = msg;
        this.code = code;
    }
    @Autowired
    public Response(ResponseCode responseCode) { 
        Response.responseCode = responseCode;
    }
    /** * 返回成功Response对象 */
    public static <T> Response<T> success(String successMessage, T data) { 
        return new Response<>(responseCode.getSuccessCode(), successMessage, data);
    }
    /** * 返回错误Response对象 */
    public static <T> Response<T> fail(String errorMessage) { 
        return new Response<>(responseCode.getErrorCode(), errorMessage);
    }
}
@Data
@Component
public class ResponseCode { 
    public String successCode = "200";
    public String errorCode = "500";
    public String authErrorCode = "300";
}

3.2.5 OrderMapper

package com.zrj.sharding.mapper;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
/** * 订单Mapper接口 * * @author zrj * @since 2021/8/22 **/
@Mapper
@Component
public interface OrderMapper { 
    /** * 新增订单 * * @param price 订单价格 * @param userId 用户id * @param status 订单状态 * @return */
    @Insert("insert into t_order(price,user_id,status) value(#{price},#{userId},#{status})")
    int insertOrder(@Param("price") Double price, @Param("userId") Long userId,
                    @Param("status") String status);
    /** * 根据id列表查询多个订单 * * @param orderIds 订单id列表 * @return */
    @Select({ "<script>" +
            "select " +
            " * " +
            " from t_order t" +
            " where t.order_id in " +
            "<foreach collection='orderIds' item='id' open='(' separator=',' close=')'>" +
            " #{id} " +
            "</foreach>" +
            "</script>"})
    List<Map> selectOrderbyIds(@Param("orderIds") List<Long> orderIds);
}

3.2.6 OrderService

package com.zrj.sharding.service;
import com.zrj.sharding.entity.Order;
import java.util.List;
import java.util.Map;
/** * 订单接口 * * @author zrj * @since 2021/8/22 */
public interface OrderService { 
    /** * 新增订单 */
    int insertOrder(Order order);
    /** * 根据id列表查询多个订单 */
    List<Map> selectOrderbyIds(List<Long> orderIds);
}

3.2.7 OrderServiceImpl

package com.zrj.sharding.service.impl;
import com.zrj.sharding.entity.Order;
import com.zrj.sharding.mapper.OrderMapper;
import com.zrj.sharding.service.OrderService;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
/** * 订单实现类 * * @author zrj * @since 2021/8/22 */
@Service("OrderService")
public class OrderServiceImpl implements OrderService { 
    @Resource
    private OrderMapper orderMapper;
    @Override
    public int insertOrder(Order order) { 
        return orderMapper.insertOrder(order.getPrice(), order.getUserId(), order.getStatus());
    }
    @Override
    public List<Map> selectOrderbyIds(List<Long> orderIds) { 
        return orderMapper.selectOrderbyIds(orderIds);
    }
}

3.2.8 OrderController

package com.zrj.sharding.controller;
import com.zrj.sharding.entity.Order;
import com.zrj.sharding.entity.Response;
import com.zrj.sharding.service.OrderService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
/** * 订单管理 * 采用分库分表中间件ShardingJdbc * * @author zrj * @since 2021/8/22 */
@RestController
@RequestMapping("/order")
@Api(tags = "订单管理", description = "分库分表")
public class OrderController { 
    @Resource
    private OrderService orderService;
    /** * 测试服务 */
    @GetMapping("/test")
    @ApiOperation(value = "测试服务", notes = "测试方法的备注说明", httpMethod = "GET")
    public Response test() { 
        return Response.success("查询成功", null);
    }
    /** * 新增订单 */
    @ApiOperation(value = "新增订单", httpMethod = "POST")
    @RequestMapping(value = "insert", method = RequestMethod.POST)
    public Response<Integer> insert(@RequestBody Order order) { 
        int result = orderService.insertOrder(order);
        if (result > 0) { 
            return Response.success("新增成功", result);
        }
        return Response.fail("新增失败");
    }
    /** * 根据ids查询订单 */
    @ApiOperation(value = "查询订单", httpMethod = "POST")
    @RequestMapping(value = "selectOrderbyIds", method = RequestMethod.POST)
    public Response<List> selectOrderbyIds(@RequestBody List<Long> orderIds) { 
        List<Map> result = orderService.selectOrderbyIds(orderIds);
        if (result != null) { 
            return Response.success("查询成功", result);
        }
        return Response.fail("查询失败");
    }
}

3.2.8 ShardingSimpleApplication

package com.zrj.sharding;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/** * 订单服务 * * @author zrj * @since 2021/8/22 */
@SpringBootApplication
@MapperScan("com.zrj.sharding.mapper")
public class ShardingSimpleApplication { 
    public static void main(String[] args) { 
        SpringApplication.run(ShardingSimpleApplication.class, args);
    }
}