shareJDBC+springboot 實現垂直分庫水平分表

目標：t_order0/1表數據存放在數據庫db0;t_order_item0/1表數據存放在數據庫db1中；

建表語句：

數據庫db0:
CREATE TABLE `t_order0` (
  `order_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL,
  `status` varchar(10) COLLATE utf8_bin DEFAULT NULL,
  `create_at` date DEFAULT NULL,
  `update_at` date DEFAULT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB AUTO_INCREMENT=888827342141919233 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

CREATE TABLE `t_order0` (
  `order_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) NOT NULL,
  `status` varchar(10) COLLATE utf8_bin DEFAULT NULL,
  `create_at` date DEFAULT NULL,
  `update_at` date DEFAULT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB AUTO_INCREMENT=888827342141919233 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

數據庫db1:
CREATE TABLE `t_order_item0` (
  `order_item_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `order_id` bigint(20) NOT NULL,
  `user_id` int(11) NOT NULL,
  `status` varchar(10) COLLATE utf8_bin DEFAULT NULL,
  `create_at` date DEFAULT NULL,
  `update_at` date DEFAULT NULL,
  PRIMARY KEY (`order_item_id`)
) ENGINE=InnoDB AUTO_INCREMENT=888827342146113538 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

CREATE TABLE `t_order_item1` (
  `order_item_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `order_id` bigint(20) NOT NULL,
  `user_id` int(11) NOT NULL,
  `status` varchar(10) COLLATE utf8_bin DEFAULT NULL,
  `create_at` date DEFAULT NULL,
  `update_at` date DEFAULT NULL,
  PRIMARY KEY (`order_item_id`)
) ENGINE=InnoDB AUTO_INCREMENT=888827342146113538 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

 

pom關鍵依賴：

        <dependency>
            <groupId>io.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        </dependency>

 

yml：這里我對yml進行了分層，由於有其他要測試的

#垂直分庫水平分表
sharding:
  jdbc:
    config:
      sharding:
        props:
          sql.show: true
        tables:
          t_order: #t_user表
            key-generator-column-name: order_id  #主鍵
            actual-data-nodes: ds0.t_order${0..1}    #垂直分庫，t_order只在ds0庫中
            table-strategy: #分表策略
              inline: #行表達式
                sharding-column: user_id
                algorithm-expression: t_order${user_id % 2}  #按模運算分配
          t_order_item: #t_user表
            key-generator-column-name: order_item_id  #主鍵
            actual-data-nodes: ds1.t_order_item${0..1}    #垂直分庫，t_order_item只在ds1庫中
            table-strategy: #分表策略
              inline: #行表達式
                sharding-column: user_id
                algorithm-expression: t_order_item${user_id % 2}  #按模運算分配

 

 

mybatis:
  mapper-locations: classpath:mapper/*.xml

# 官網 https://shardingsphere.apache.org/document/current/cn/user-manual/shardingsphere-jdbc/usage/sharding/yaml/
sharding:
  jdbc:
    datasource:
      # 數據源ds0,ds1
      names: ds0,ds1
      ds0:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/db0?useSSL=false&serverTimezone=UTC
        username: root
        password: root
      ds1:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/db1?useSSL=false&serverTimezone=UTC
        username: root
        password: root

#引入yml文件
spring:
  profiles:
    active: vertical

 

 xml中sql編寫：

        <insert id="saveOrder" parameterType="com.example.sharejdbctable.dto.OrderDto">
        INSERT INTO t_order(order_id,user_id,status)
        VALUES
        (
            #{order_id},#{user_id},#{status}
        )
    </insert>

        <insert id="saveOrderDetail" parameterType="java.util.ArrayList">
        INSERT INTO t_order_item(order_item_id,order_id,user_id,status)
        VALUES
        <foreach collection="list" item="item" separator=",">
        (#{item.order_item_id},#{item.order_id},#{item.user_id},#{item.status})
        </foreach>
    </insert>

dao層：

    void saveOrder(OrderDto orderDto);

    void saveOrderDetail(@Param("list")List<OrderItem>orderItemList);

service層：

    public void saveOrder(OrderDto orderDto) {
        userMapper.saveOrder(orderDto);
    }

    public  void saveOrderDetail(List orderItemList) {
        userMapper.saveOrderDetail(orderItemList);
    }

controller層：

    @Transactional
    @RequestMapping("/saveOrder")
    public String save1() {
        SnowflakeIdWorker order_id = new SnowflakeIdWorker(1, 3);
        OrderDto orderDto = null;
        List<OrderItem> list = null;
        for (int i = 0; i < 10; i++) {
            list=new ArrayList<>();
            orderDto = new OrderDto();
            SnowflakeIdWorker item_id = new SnowflakeIdWorker(1, 3);
            Long orderId = order_id.nextId();
            orderDto.setOrder_id(orderId);
            orderDto.setUser_id(i);
            orderDto.setStatus("test" + i);
            this.userService.saveOrder(orderDto); //保存訂單
            //明細
            OrderItem orderItem = null;
            for (int j = 0; j < 2; j++) {
                orderItem = new OrderItem();
                orderItem.setOrder_id(orderId);
                orderItem.setOrder_item_id(item_id.nextId());
                orderItem.setUser_id(i);
                orderItem.setStatus("itest" + j);
                list.add(orderItem);
            }
            this.userService.saveOrderDetail(list); //保存訂單明細
        }
        return "success";
    }

數據庫插入的數據：

db0庫中只有訂單表數據，而且用戶id為奇數的在訂單表1中，偶數在訂單表0中

 

 db1庫中只有訂單明細表數據，而且用戶id為奇數的在訂單明細表1中，偶數在訂單明細表0中

 

 總結：和預期的結果一致，撒花