[shardingSphere 使用与场景1] shardingSphere与mybatis集成，分库分表

本章目的为了快速搭建 shardingSphere 所讲解，提一些基本概念。

分片

垂直分片

按照业务拆分的方式称为垂直分片，又称为纵向拆分，它的核心理念是专库专用。 在拆分之前，一个数据库由多个数据表构成，每个表对应着不同的业务。

水平分片

水平分片又称为横向拆分。 相对于垂直分片，它不再将数据根据业务逻辑分类，而是通过某个字段（或某几个字段），根据某种规则将数据分散至多个库或表中，每个分片仅包含数据的一部分。

SQL

逻辑表

水平拆分的数据库（表）的相同逻辑和数据结构表的总称。
例：用户表根据地区划分，tb_user_shanghai, tb_user_shenzhen等等，他們的逻辑表为tb_user

真实表

在分片的数据库中真实存在的物理表。
tb_user_shanghai, tb_user_shenzhen为真实表，也叫物理表

数据节点

数据分片的最小单元。
由数据源名称和数据表组成，例：portal.tb_user_shenzhen

绑定表

指分片规则一致的主表和子表。例如： t_order 表和 t_order_item 表，均按照 order_id 分片，则此两张表互为绑定表关系。绑定表之间的多表关联查询不会出现笛卡尔积关联，关联查询效率将大大提升。
例子：
在不配置绑定表关系时, 路由的 SQL

SELECT i.* FROM t_order_0 o JOIN t_order_item_0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
SELECT i.* FROM t_order_0 o JOIN t_order_item_1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
SELECT i.* FROM t_order_1 o JOIN t_order_item_0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
SELECT i.* FROM t_order_1 o JOIN t_order_item_1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

在配置绑定表关系后，路由的 SQL

SELECT i.* FROM t_order_0 o JOIN t_order_item_0 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);
SELECT i.* FROM t_order_1 o JOIN t_order_item_1 i ON o.order_id=i.order_id WHERE o.order_id in (10, 11);

广播表

指所有的分片数据源中都存在的表，表结构和表中的数据在每个数据库中均完全一致。适用于数据量不大且需要与海量数据的表进行关联查询的场景，例如：字典表。

内核剖析

核心由 SQL 解析 => 执行器优化 => SQL 路由 => SQL 改写 => SQL 执行 => 结果归并 的流程组成

sharding 入门使用

项目集成框架

shardingSphere
使用 5.0.0-alpha 版本

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

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

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.16</version>
</dependency>

<!-- mybatis -->
<dependency>
	<groupId>org.mybatis.spring.boot</groupId>
	<artifactId>mybatis-spring-boot-starter</artifactId>
	<version>2.1.3</version>
</dependency>
<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.18</version>
</dependency>

配置事务处理器

配置dataSource是在 shardingsphere-jdbc-core-spring-boot-starter 自动管理的, 可以直接使用。

@Configuration
public class DatabaseConfig {

    @Resource
    private DataSource dataSource;

    @Bean
    public PlatformTransactionManager txManager() {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource);
    }
}

使用springboot 的 shardingSphere 配置

配置需注意：

1.连接池

若使用com.alibaba.druid.pool.DruidDataSource使用(url, username, password)
若使用com.zaxxer.hikari.HikariDataSource 使用(jdbcUrl,username,password)

2.开启使用

spring.shardingsphere.enabled=true

spring:
  shardingsphere:
    sharding:
      default-database-strategy: # 默认数据库策略
        standard:
          sharding-column: id
          sharding-algorithm-name: database-default
#      default-table-strategy: # 默认数据表策略
#        standard:
#          sharding-column: id
#          sharding-algorithm-name: table-default
    enabled: true
    props:
      sql-show: true
    datasource:
      common:
        driver-class-name: com.mysql.cj.jdbc.Driver
        type: com.alibaba.druid.pool.DruidDataSource
      names: ds0,ds1
      ds0:
        url: jdbc:mysql://127.0.0.1:3306/db0?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2b8
        username: root
        password:
      ds1:
        url: jdbc:mysql://127.0.0.1:3306/db1?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2b8
        username: root
        password:
    rules:
      sharding:
        broadcast-tables: tb_dict # 广播表
        key-generators: # 分布式主键策略
          snowflake: # 策略名自定义
            type: SNOWFLAKE
            props:
              worker-id: 123
        sharding-algorithms: # 数据分片策略
          table-order-id:
            type: INLINE
            props:
              algorithm-expression: tb_order$->{order_id % 5}
          table-intype:
            type: INLINE
            props:
              algorithm-expression: tb_view_log_$->{log_type}
          database-default:
            type: INLINE
            props:
              algorithm-expression: ds1
          database-inline:
            type: INLINE
            props:
              algorithm-expression: ds0
        tables: # 表配置
          tb_dict:
            key-generate-strategy:
              column: id
              key-generator-name: snowflake
          tb_order:
            actual-data-nodes: ds$->{0..1}.tb_order$->{0..4}
            table-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: table-order-id
            database-strategy:
              standard:
                sharding-column: order_id
                sharding-algorithm-name: database-inline
            key-generate-strategy:
              column: order_id
              key-generator-name: snowflake
          tb_view_log:
            actual-data-nodes: ds0.tb_view_log_article,ds0.tb_view_log_product
            table-strategy:
              standard:
                sharding-column: log_type
                sharding-algorithm-name: table-intype
            database-strategy:
              standard:
                sharding-column: id
                sharding-algorithm-name: database-inline

shardingShere的SQL运行情况

• Logic SQL 是代码中的SQL
• Actual SQL 是物理库执行的SQL

插入SQL：
逻辑表：tb_view_log
物理表：tb_view_log_article，tb_view_log_product
SELECT id, user_id ,log_type from tb_view_log 根据分片规则，log_type字段数据分别插入到不同的数据表

查询SQL：
逻辑表：tb_view_log
物理表：tb_view_log_article，tb_view_log_product
SELECT id, user_id ,log_type from tb_view_log 根据分片规则，log_type字段向所有分片表查询数据并拼接起来

tb_view_log_article数据

tb_view_log_product数据