ShardingSphere结合MySQL实现分库分表的项目实践

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.2</version>
</dependency>

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

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
</dependency>

<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>shardingsphere-jdbc-core-spring-boot-starter</artifactId>
    <version>5.1.0</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-logging</artifactId>
</dependency>

CREATE TABLE `t_order_5`
(
    `order_id`    bigint NOT NULL AUTO_INCREMENT,
    `price`       double(12,2),
    `user_id`     int    NOT NULL,
    `address_id`  bigint NOT NULL,
    `city`        varchar(32) NULL DEFAULT NULL,
    `status`      tinyint NULL DEFAULT NULL,
    `interval_time` datetime NULL DEFAULT NULL,
    `creator`     varchar(32) NULL DEFAULT NULL,
    `create_time` datetime NULL DEFAULT NULL,
    `updater`     varchar(32) NULL DEFAULT NULL,
    `update_time` datetime NULL DEFAULT NULL,
    PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic

spring:
  main:
    banner-mode: off

  shardingsphere:
    # 配置数据源，给数据源起别名ds
    datasource:
      ds:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 1234
      names: ds
    rules:
      sharding:
        binding-tables:
          - t_order,t_order_item
        broadcast-tables: t_address
        # 分片算法
        sharding-algorithms:
          t-order-algorithm:
            type: HASH_MOD
            props:
              sharding-count: '6'
          t-order-item-inline:
            type: INLINE
            props:
              algorithm-expression: t_order_item_$->{order_id % 2}
        tables:
        # 分表
          t_order:
            actual-data-nodes: ds.t_order_$->{0..5}   # 真实表名
            table-strategy:
              standard:
                sharding-algorithm-name: t-order-algorithm
                sharding-column: order_id   # 分片键
          t_order_item:
            actual-data-nodes: ds.t_order_item_$->{0..1}
            table-strategy:
              standard:
                sharding-algorithm-name: t-order-item-inline
                sharding-column: order_id
    props:
      sql-show: true



#mybatis-plus:
#  global-config:
#    banner: false
#    db-config:
#      id-type: assign_id  #使用雪花算法开启数据入库时ID自增
#      logic-delete-field: deleted
#      logic-delete-value: 1
#      logic-not-delete-value: 0
#  #开启mp的日志（控制台输出）
#  configuration:
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

mybatis:
  mapper-locations: classpath*:/mappers/*-mapper.xml
  type-aliases-package: com.panliu.domain
  configuration:
    default-fetch-size: 20
    default-statement-timeout: 30
    map-underscore-to-camel-case: true
    use-generated-keys: true

@Slf4j
@SpringBootTest
public class OrderMapperTests {
    private final static String[] CITIES = {"shanghai", "beijing"};
    /**
     * -120000, 0, 18, 20000, 40000, 50000, 60000, 64000, 80000, 99000
     */
    private final static long[] PRICES = {-120000, 0, 18, 20000, 40000, 50000, 60000, 64000, 80000, 99000};
    @Autowired
    private OrderMapper orderMapper;

    @Test
    //@Disabled
    void save() {
        ThreadLocalRandom random = ThreadLocalRandom.current();

        Date[] dates = create();
        IntStream.range(0, 20).forEach(i -> {
            Order order = new Order();
            order.setOrderId(System.nanoTime() + i);
            order.setPrice(PRICES[i % PRICES.length]);
            order.setAddressId(i);
            order.setCity(CITIES[i % 2]);
            order.setUserId(Math.abs(random.nextInt()));
            order.setCreator("user.0" + i);
            order.setIntervalTime(dates[i % 5]);
            order.setUpdater(order.getCreator());
            log.info("====>{}", order);
            orderMapper.save(order);
        });
    }

    @Test
   // @Disabled
    void findAll() {
        List<Order> list = orderMapper.findAllAtPrice(60000);
        log.info("===>{}", list);
    }

    private Date[] create() {
        Date[] dates = new Date[6];

        try {
            Date date = DateUtils.parseDate("2023-08-14 00:00:00", Locale.CHINA, "yyyy-MM-dd HH:mm:ss");
            IntStream.range(0, 6).forEach(i -> dates[i] = DateUtils.addDays(date, i));
        } catch (ParseException e) {
            log.error("date parse fail: ", e);
        }
        return dates;
    }
}

rules:
  sharding:
    sharding-algorithms:
      t-order-algorithm:
        type: COMPLEX_INLINE
        props:
          algorithm-expression: t_order_$->{city}_$->{order_id % 2}
          sharding-columns: city,order_id
    tables:
      t_order:
        actual-data-nodes: ds.t_order_$->{['shanghai','beijing']}_$->{0..1}
        table-strategy:
          complex:
            sharding-algorithm-name: t-order-algorithm
            sharding-columns: city,order_id