Amazon Aurora 读写能力扩展之 ShardingSphere-JDBC 篇

{"value":"文章来源亚马逊 Amazon 官方博客\n\n\n### **1.前言**\n[Amazon Aurora](https://aws.amazon.com/cn/rds/aurora/?trk=cndc-detail) 是亚马逊云科技自研的一项关系数据库服务，它在提供和开源数据库 MySQL、PostgreSQL 的完好兼容性同时，也能够提供和商业数据库媲美的性能和可用性。性能方面，Aurora MySQL 能够支持到与开源标准 MySQL 同等配置下五倍的吞吐量，Aurora PostgreSQL 能够支持与开源标准 PostgreSQL 同等配置下三倍的吞吐量的提升。在扩展性的角度，Aurora 在存储与计算、横向与纵向方面都进行了功能的增强和创新。\n\nAurora 的最大数据存储量现在支持多达 128TB，而且可以支持存储的动态收缩。计算方面，Aurora 提供多个读副本的可扩展性配置支持一个区域内多达15个读副本的扩展，提供多主的架构来支持同一个区域内4个写节点的扩展，提供 Serverless [无服务器](https://aws.amazon.com/cn/serverless/?trk=cndc-detail)化的架构实例级别的秒级纵向扩展，提供全球数据库来实现数据库的低延迟跨区域扩展。\n\n随着用户数据量的增长，Aurora 已经提供了很好的扩展性，那是否可以进一步增强更多的数据量、更多的并发访问能力呢？您可以考虑利用分库分表的方式，来支持底层多个 Aurora 集群的配置。基于此，包含这篇博客在内的系列博客会进行相应的介绍，旨在为您进行分库分表时代理或者 JDBC 的选择提供参考。\n\n#### **1.1为什么要分库分表**\n\n\n[Amazon Aurora](https://aws.amazon.com/cn/rds/aurora/?trk=cndc-detail) 提供了关系型数据库单机，主从，多主，全球数据库等托管架构形式可以满足以上各种架构场景，但分库分表的场景下 Aurora 没有提供直接的支持，并且分库分表还衍生出来如垂直与水平多种形态,再进一步提升数据容量的情况下，也带来一些需要解决的问题，如跨节点数据库 Join 关联查询、分布式事务、执行的 SQL 排序、翻页、函数计算、数据库全局主键、容量规划、分库分表后二次扩容等问题。\n\n#### **1.2分库分表的方式**\n查询一次所花的时间业界公认 MySQL 单表容量在1千万以下是最佳状态，因为这时它的 BTREE 索引树高在3~5之间。通过对数据的切分可以在降低单表的数据量的同时，将读写的压力分摊到不同的数据节点上，数据切分可以分为：垂直切分和水平切分。\n\n\n\n**1.垂直切分的优点**\n解决业务系统层面的耦合，业务清晰；\n\n与微服务的治理类似，也能对不同业务的数据进行分级管理、维护、监控、扩展等；\n\n高并发场景下，垂直切分一定程度的提升 IO、数据库连接数、单机硬件资源的瓶颈。\n\n**2.垂直切分的缺点**\n分库后无法 Join，只能通过接口聚合方式解决，提升了开发的复杂度；\n\n分库后分布式事务处理复杂；\n\n依然存在单表数据量过大的问题（需要水平切分）。\n\n**3.水平切分的优点**\n不存在单库数据量过大、高并发的性能瓶颈，提升系统稳定性和负载能力；\n\n应用端改造较小，不需要拆分业务模块。\n\n**4.水平切分的缺点**\n跨分片的事务一致性难以保证；\n\n跨库的 Join 关联查询性能较差；\n\n数据多次扩展难度和维护量极大。\n\n结合以上分析，在调研了常见的分库分表的中间件基础上，我们选取 ShardingSphere 开源产品结合 [Amazon Aurora](https://aws.amazon.com/cn/rds/aurora/?trk=cndc-detail)，介绍这两种产品的结合是如何满足各种形式的分库分表方式和如何解决由分库分表带来的一些问题。\n\n### **2.Sharding-JDBC 功能测试**\n#### **2.1样例工程说明**\n\n下载样例工程代码到本地，为保证测试代码的稳定性我们这里选择使 shardingsphere-example-4.0.0 这个 tag 版本。\n```git clone https://github.com/apache/shardingsphere-example.git\\n```\n**工程项目说明：**\n```shardingsphere-example\\n ├── example-core\\n │ ├── config-utility\\n │ ├── example-api\\n │ ├── example-raw-jdbc\\n │ ├── example-spring-jpa #spring+jpa集成基础的entity，repository\\n │ └── example-spring-mybatis\\n ├── sharding-jdbc-example\\n │ ├── sharding-example\\n │ │ ├── sharding-raw-jdbc-example\\n │ │ ├── sharding-spring-boot-jpa-example #集成基础的sharding-jdbc的功能\\n │ │ ├── sharding-spring-boot-mybatis-example\\n │ │ ├── sharding-spring-namespace-jpa-example\\n │ │ └── sharding-spring-namespace-mybatis-example\\n │ ├── orchestration-example\\n │ │ ├── orchestration-raw-jdbc-example\\n │ │ ├── orchestration-spring-boot-example #集成基础的sharding-jdbc的治理的功能\\n │ │ └── orchestration-spring-namespace-example\\n │ ├── transaction-example\\n │ │ ├── transaction-2pc-xa-example #sharding-jdbc分布式事务两阶段提交的样例\\n │ │ └──transaction-base-seata-example #sharding-jdbc分布式事务seata的样例\\n │ ├── other-feature-example\\n │ │ ├── hint-example\\n │ │ └── encrypt-example\\n ├── sharding-proxy-example\\n │ └── sharding-proxy-boot-mybatis-example\\n └── src/resources\\n └── manual_schema.sql \\n```\n**配置文件说明：**\n```application-master-slave.properties #读写分离配置文件\\napplication-sharding-databases-tables.properties #分库分表配置文件\\napplication-sharding-databases.properties #仅分库配置文件\\napplication-sharding-master-slave.properties #分库分表加读写分离的配置文件\\napplication-sharding-tables.properties #分表配置文件\\napplication.properties #spring boot 配置文件\\n```\n**代码逻辑说明：**\n\nSpring Boot 应用的入口类，执行该类就可以运行工程\n\n\n\n其中 demo 的执行逻辑如下：\n\n\n\n#### **2.2读写分离验证**\n\n随着业务增长，写和读请求分离到不同的数据库节点上能够有效提高整个数据库集群的处理能力。Aurora 通过读/写的 endpoint 可以满足用户写和强一致性读的需求，单独只读的 endpoint 可以满足用户非强一致性读的需求。Aurora 的读写延迟通常在毫秒级别，比 MySQL 基于 binlog 的逻辑复制要低得多，所以有很多负载是直接打到只读 endpoint。\n\n通过一主多从的配置方式，可以将查询请求均匀的分散到多个数据副本，能够进一步的提升系统的处理能力。读写分离虽然可以提升系统的吞吐量和可用性，但同时也带来了数据不一致的问题。Aurora 以完全托管的形式提供了主从架构，但上层应用在与 Aurora 交互时，仍然需要管理多个数据源，根据 SQL 语句的读写类型和一定的路由策略将 SQL 请求路由到不同的节点上。\n\nSharding-JDBC 提供的读写分离的特性，应用程序与 Sharding-JDBC 集成，将应用程序与数据库集群之间复杂配置关系从应用程序中剥离出来，开发者通过配置文件管理 Shard，再结合一些 ORM 框架如 Spring JPA、Mybatis 就可以完全将这些复制的逻辑从代码中分离。极大的提高代码的可维护性，降低代码与数据库的耦合。\n\n##### **2.2.1数据库环境准备**\n首先创建一套 Aurora MySQL 读写分离集群，机型为 db.r5.2xlarge，每套集群有一个写节点 2 个读节点。如下图所示\n\n\n\n\n\n##### 2.2.2Sharding-JDBC 配置\n**application.properties spring boot 主配置文件说明**\n\n如下图所属：绿色标注的部分你需要替换成自己环境上的配置\n```# jpa自动根据实体创建和drop数据表\\nspring.jpa.properties.hibernate.hbm2ddl.auto=create-drop\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n\\n#spring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n#激活master-slave 配置项，这样sharding-jdbc将使用master-slave配置文件\\nspring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n```\n**application-master-slave.properties sharding-jdbc 配置文件说明**\n```spring.shardingsphere.datasource.names=ds_master,ds_slave_0,ds_slave_1\\n# 数据源 主库-master\\nspring.shardingsphere.datasource.ds_master.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master.password= 您自己的主db密码\\nspring.shardingsphere.datasource.ds_master.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master.jdbc-url=您自己的主db数据源url spring.shardingsphere.datasource.ds_master.username=您自己的主db用户名 \\n# 数据源 从库\\nspring.shardingsphere.datasource.ds_slave_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_slave_0.password= 您自己的从db密码\\nspring.shardingsphere.datasource.ds_slave_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_slave_0.jdbc-url=您自己的从db数据源url\\nspring.shardingsphere.datasource.ds_slave_0.username= 您自己的从db用户名\\n# 数据源 从库\\nspring.shardingsphere.datasource.ds_slave_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_slave_1.password=您自己的从db密码\\nspring.shardingsphere.datasource.ds_slave_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_slave_1.jdbc-url= 您自己的从db数据源url\\nspring.shardingsphere.datasource.ds_slave_1.username= 您自己的从db用户名\\n# 路由策略配置\\nspring.shardingsphere.masterslave.load-balance-algorithm-type=round_robin\\nspring.shardingsphere.masterslave.name=ds_ms\\nspring.shardingsphere.masterslave.master-data-source-name=ds_master\\nspring.shardingsphere.masterslave.slave-data-source-names=ds_slave_0,ds_slave_1\\n# sharding-jdbc 配置信息存储方式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere 日志，开启的情况下从打印中可以看到逻辑SQL到实际SQL的转换\\nspring.shardingsphere.props.sql.show=true\\n```\n##### **2.2.3测试验证过程说明**\n\n测试环境数据初始化：Spring JPA 初始化自动创建用于测试的表\n\n\n\n- 在主实例上写入数据\n\n\n如下图 ShardingSphere-SQL log 所示，写 SQL 在 ds_master 数据源上执行。\n\n\n\n- 数据查询操作在从库上执行\n\n如下图 ShardingSphere-SQL log 所示，读 SQL 按照轮询的方式在 ds_slave 数据源上执行。\n```[INFO ] 2022-04-02 19:43:39,376 --main-- [ShardingSphere-SQL] Rule Type: master-slave \\n[INFO ] 2022-04-02 19:43:39,376 --main-- [ShardingSphere-SQL] SQL: select orderentit0_.order_id as order_id1_1_, orderentit0_.address_id as address_2_1_, \\norderentit0_.status as status3_1_, orderentit0_.user_id as user_id4_1_ from t_order orderentit0_ ::: DataSources: ds_slave_0 \\n---------------------------- Print OrderItem Data -------------------\\nHibernate: select orderiteme1_.order_item_id as order_it1_2_, orderiteme1_.order_id as order_id2_2_, orderiteme1_.status as status3_2_, orderiteme1_.user_id \\nas user_id4_2_ from t_order orderentit0_ cross join t_order_item orderiteme1_ where orderentit0_.order_id=orderiteme1_.order_id\\n[INFO ] 2022-04-02 19:43:40,898 --main-- [ShardingSphere-SQL] Rule Type: master-slave \\n[INFO ] 2022-04-02 19:43:40,898 --main-- [ShardingSphere-SQL] SQL: select orderiteme1_.order_item_id as order_it1_2_, orderiteme1_.order_id as order_id2_2_, orderiteme1_.status as status3_2_, \\norderiteme1_.user_id as user_id4_2_ from t_order orderentit0_ cross join t_order_item orderiteme1_ where orderentit0_.order_id=orderiteme1_.order_id ::: DataSources: ds_slave_1 \\n```\n注意：如下图所示，如果在一个事务中既有读也有写，Sharding-JDBC 将读写操作都路由到主库；如果读写请求不在一个事务中，那么对应读请求将按照路由策略分发到不同的读节点上。\n```@Override\\n@Transactional // 开启事务时在该事务中读写都走主库；关闭事务时，读走从库，写走主库\\npublic void processSuccess() throws SQLException {\\n System.out.println(\\"-------------- Process Success Begin ---------------\\");\\n List<Long> orderIds = insertData();\\n printData();\\n deleteData(orderIds);\\n printData();\\n System.out.println(\\"-------------- Process Success Finish --------------\\");\\n}\\n```\n##### **2.2.4Aurora failover 场景验证**\nAurora 数据库环境采用 2.2.1 中的配置。\n###### **2.2.4.1验证过程中说明**\n1.启动 Spring-Boot 工程\n2.在 Aurora 的 console 上执行故障转移操作\n\n\n\n3.执行 Rest API 请求\n4.多次执行 POST([http://localhost:8088/save-user](http://localhost:8088/save-user))直到该 API 的调用写入 Aurora 失败到最终恢复成功。\n5.观测执行代码 failover 过程如下图所示，从 log 可以分析最近一次 SQL 执行写入操作成功到下次执行再次写入成功大概需要 37s，也就是应用从 Aurora failover 中可以自动恢复，恢复的时长大概是 37s。\n\n\n\n#### **2.3仅分表功能验证**\n##### **2.3.1Sharding-JDBC 配置**\n**application.properties spring boot 主配置文件说明**\n```# jpa 自动根据实体创建和drop数据表\\nspring.jpa.properties.hibernate.hbm2ddl.auto=create-drop\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n#spring.profiles.active=sharding-databases\\n#激活sharding-tables配置项\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n# spring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n```\n**application-sharding-tables.properties sharding-jdbc 配置文件说明**\n```## 主键策略配置\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds.t_order_item_\$->{0..1}\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_\$->{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# 配置t_order与 t_order_item的绑定关系\\nspring.shardingsphere.sharding.binding-tables[0]=t_order,t_order_item\\n# 配置广播表\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n```\n##### **2.3.2测试验证过程说明**\n1.DDL 操作\n\n如下图所属，JPA 自动创建用于测试的表，在配置了 Sharding-JDBC 的路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表，由于只有一个主实例，所以创建一个 t_address；t_order 按照取模分表，创建 t_order 时会创建 t_order_0, t_order_1 两张表物理表。\n\n\n\n2.写操作\n\n如下图所示 Logic SQL 向 t_order 插入一条记录，Sharding-JDBC 执行的时候会根据分表规则将数据分布放到 t_order_0, t_order_1 中。\n\n当 t_order 和 t_order_item 配置了绑定关系时，order_item 与 order 有关联关系的记录会放到同一个物理分表中。\n\n\n\n3.读操作\n\n绑定表下的 join 查询操作 order 和 order_item，如下图所示，会根据绑定关系精确定位对应的物理 shard 上。\n\n\n\n非绑定表下的 join 查询操作 order 和 order_item，如下图所属，会遍历所有的 shard。\n\n\n\n#### **2.4仅分库功能验证**\n##### **2.4.1数据库环境准备**\n\n如下图所属，在 Aurora 上创建两个实例：ds_0 和 ds_1\n\n\n\n启动 Sharding-spring-boot-jpa-example 工程时会在两个 Aurora 实例上创建表 t_order, t_order_item，t_address\n\n##### **2.4.2Sharding-JDBC 配置**\n**application.properties springboot 主配置文件说明**\n```# jpa 自动根据实体创建和drop数据表\\nspring.jpa.properties.hibernate.hbm2ddl.auto=create\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n\\n# 激活sharding-databases配置项\\nspring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n#spring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n\\napplication-sharding-databases.properties sharding-jdbc 配置文件说明\\n\\nspring.shardingsphere.datasource.names=ds_0,ds_1\\n# ds_0\\nspring.shardingsphere.datasource.ds_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_0.jdbc-url= spring.shardingsphere.datasource.ds_0.username= \\nspring.shardingsphere.datasource.ds_0.password=\\n# ds_1\\nspring.shardingsphere.datasource.ds_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_1.jdbc-url= \\nspring.shardingsphere.datasource.ds_1.username= \\nspring.shardingsphere.datasource.ds_1.password=\\nspring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id\\nspring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_\$->{user_id % 2}\\nspring.shardingsphere.sharding.binding-tables=t_order,t_order_item\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\nspring.shardingsphere.sharding.default-data-source-name=ds_0\\n\\nspring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_\$->{0..1}.t_order\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_\$->{0..1}.t_order_item\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n```\n##### **2.4.3测试验证过程说明**\n1.DDL 操作\n\nJPA 自动创建用于测试的表，如下图所属，在配置了 Sharding-JDBC 的分库路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表在 ds_0 和 ds_1 上都会创建物理表 t_address，t_order，t_order_item 按照取模分库，这三个表会分别在 ds_0 和 ds_1 上创建。\n\n2.写操作\n\n对于广播表 t_address，每写入一条记录会在 ds_0 和 ds_1 的 t_address 表上都写入\n\n对于分库的表 t_order，t_order_item，会按照分库字段和路由策略写入到对应实例上的表中。\n\n3.读操作\n\n如下图所示，查询 order，根据分库路由规则路由到对应的 Aurora 实例上。\n\n如下图所示，查询 Address，由于 address 是广播表，会在所用的节点中随机选择一个 address 所在的实例查询。\n\n如下图所示，绑定表下的 join 查询操作 order 和 order_item 时，会根据绑定关系精确定位对应的物理 shard 上。\n\n#### **2.5分库分表功能验证**\n##### **2.5.1数据库环境准备**\n如下图所示，在 Aurora 上创建两个实例：ds_0和ds_1\n\n启动 sharding-spring-boot-jpa-example 工程时会在两个 Aurora 实例上创建物理表 t_order_01, t_order_02, t_order_item_01，t_order_item_02 和 t_address 全局表。\n\n### 2.5.2Sharding-JDBC 配置\n**application.properties springboot 主配置文件说明**\n```# jpa 自动根据实体创建和drop数据表\\nspring.jpa.properties.hibernate.hbm2ddl.auto=create\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n# 激活sharding-databases-tables配置项\\n#spring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\nspring.profiles.active=sharding-databases-tables\\n#spring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n```\n**application-sharding-databases.properties sharding-jdbc 配置文件说明**\n```spring.shardingsphere.datasource.names=ds_0,ds_1\\n# ds_0\\nspring.shardingsphere.datasource.ds_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_0.jdbc-url= 306/dev?useSSL=false&characterEncoding=utf-8\\nspring.shardingsphere.datasource.ds_0.username= \\nspring.shardingsphere.datasource.ds_0.password=\\nspring.shardingsphere.datasource.ds_0.max-active=16\\n# ds_1\\nspring.shardingsphere.datasource.ds_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_1.jdbc-url= \\nspring.shardingsphere.datasource.ds_1.username= \\nspring.shardingsphere.datasource.ds_1.password=\\nspring.shardingsphere.datasource.ds_1.max-active=16\\n# 默认的分库策略\\nspring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id\\nspring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_\$->{user_id % 2}\\nspring.shardingsphere.sharding.binding-tables=t_order,t_order_item\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\n# 不满足分库策略的表放在ds_0上\\nspring.shardingsphere.sharding.default-data-source-name=ds_0\\n# t_order分表策略\\nspring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_\$->{0..1}.t_order_\$->{0..1}\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_\$->{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\n# t_order_item分表策略\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_\$->{0..1}.t_order_item_\$->{0..1}\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_\$->{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n```\n##### **2.5.3测试验证过程说明**\n1.DDL 操作\n\nJPA 自动创建用于测试的表，如下图所示，在配置了 Sharding-JDBC 的分库分表路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表在 ds_0 和 ds_1 上都会创建 t_address。t_order，t_order_item 按照取模分库分表，这三个表会分别在 ds_0 和 ds_1 上创建。\n\n\n2.写操作\n\n对于广播表 t_address，每写入一条记录会在 ds_0 和 ds_1 的 t_address 表上都写入。\n\n\n\n对于分库的表 t_order，t_order_item，会按照分库字段和路由策略写入到对应实例上的表中。\n\n\n3.读操作\n\n读操作与仅分库功能验证类似，这里不再赘述\n\n#### **2.6分库分表加读写分离功能验证**\n\n##### **2.6.1数据库环境准备**\n\n创建的数据库实例于对应的物理表如下图所示。\n\n\n\n\n\n##### **2.6.2Sharding-JDBC 配置**\n\n**application.properties spring boot 主配置文件说明**\n```# jpa 自动根据实体创建和drop数据表\\nspring.jpa.properties.hibernate.hbm2ddl.auto=create\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n\\n# 激活sharding-databases-tables配置项\\n#spring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n#spring.profiles.active=master-slave\\nspring.profiles.active=sharding-master-slave\\n```\n**application-sharding-master-slave.properties sharding-jdbc 配置文件说明**\n其中数据库的 url、name、password 需要修改成你自己的数据库的参数。\n```spring.shardingsphere.datasource.names=ds_master_0,ds_master_1,ds_master_0_slave_0,ds_master_0_slave_1,ds_master_1_slave_0,ds_master_1_slave_1\\nspring.shardingsphere.datasource.ds_master_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_0.jdbc-url= spring.shardingsphere.datasource.ds_master_0.username= \\nspring.shardingsphere.datasource.ds_master_0.password=\\nspring.shardingsphere.datasource.ds_master_0.max-active=16\\nspring.shardingsphere.datasource.ds_master_0_slave_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_0_slave_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_0_slave_0.jdbc-url= spring.shardingsphere.datasource.ds_master_0_slave_0.username= \\nspring.shardingsphere.datasource.ds_master_0_slave_0.password=\\nspring.shardingsphere.datasource.ds_master_0_slave_0.max-active=16\\nspring.shardingsphere.datasource.ds_master_0_slave_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_0_slave_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_0_slave_1.jdbc-url= spring.shardingsphere.datasource.ds_master_0_slave_1.username= \\nspring.shardingsphere.datasource.ds_master_0_slave_1.password=\\nspring.shardingsphere.datasource.ds_master_0_slave_1.max-active=16\\nspring.shardingsphere.datasource.ds_master_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_1.jdbc-url= \\nspring.shardingsphere.datasource.ds_master_1.username= \\nspring.shardingsphere.datasource.ds_master_1.password=\\nspring.shardingsphere.datasource.ds_master_1.max-active=16\\nspring.shardingsphere.datasource.ds_master_1_slave_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_1_slave_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_1_slave_0.jdbc-url=\\nspring.shardingsphere.datasource.ds_master_1_slave_0.username=\\nspring.shardingsphere.datasource.ds_master_1_slave_0.password=\\nspring.shardingsphere.datasource.ds_master_1_slave_0.max-active=16\\nspring.shardingsphere.datasource.ds_master_1_slave_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_1_slave_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_1_slave_1.jdbc-url= spring.shardingsphere.datasource.ds_master_1_slave_1.username=admin\\nspring.shardingsphere.datasource.ds_master_1_slave_1.password=\\nspring.shardingsphere.datasource.ds_master_1_slave_1.max-active=16\\nspring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id\\nspring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_\$->{user_id % 2}\\nspring.shardingsphere.sharding.binding-tables=t_order,t_order_item\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\nspring.shardingsphere.sharding.default-data-source-name=ds_master_0\\nspring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_\$->{0..1}.t_order_\$->{0..1}\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_\$->{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_\$->{0..1}.t_order_item_\$->{0..1}\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_\$->{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# 主从数据源，分库数据源配置\\nspring.shardingsphere.sharding.master-slave-rules.ds_0.master-data-source-name=ds_master_0\\nspring.shardingsphere.sharding.master-slave-rules.ds_0.slave-data-source-names=ds_master_0_slave_0, ds_master_0_slave_1\\nspring.shardingsphere.sharding.master-slave-rules.ds_1.master-data-source-name=ds_master_1\\nspring.shardingsphere.sharding.master-slave-rules.ds_1.slave-data-source-names=ds_master_1_slave_0, ds_master_1_slave_1\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n```\n##### **2.6.3测试验证过程说明**\n\n1.DDL 操作所属\n\nJPA 自动创建用于测试的表，如下图，在配置了 Sharding-JDBC 的分库路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表在 ds_0 和 ds_1 上都会创建, t_address，t_order，t_order_item 按照取模分库，这三个表会分别在 ds_0 和 ds_1 上创建。\n\n\n\n2.写操作\n\n对于广播表 t_address，每写入一条记录会在 ds_0 和 ds_1 的 t_address 表上都写入\n\n\n\n对于分库的表 t_order，t_order_item，会按照分库字段和路由策略写入到对应实例上的表中。\n\n\n3.读操作\n\n绑定表下的 join 查询操作 order 和 order_item，如下图所示。\n\n\n\n### **3.结语**\n\nShardingSphere 作为一款专注于数据库增强的开源产品，从社区活跃度、产品成熟度、文档丰富程度上来看都是比较好的。其中的 Sharding-JDBC 是基于客户端的分库分表方案，它支持了所有的分库分表的场景，并且无需引入 Proxy 这样的中间层，所以降低了运维的复杂性，相比 Proxy 这种方式由于少了中间层所以时延理论上会比 Proxy 低，其次 Sharding-JDBC 可以支持各种基于 SQL 标准的关系型数据库如 MySQL/PostgreSQL/Oracle/SQL Server 等。但由于 Sharding-JDBC 与应用程序集成，目前支持的语言仅限于 Java，对应用程序有一定的耦合性，但 Sharding-JDBC 将所以分库分表的配置从应用程序中分离，这样面临切换其他的中间件时由此带来的变更相对较小。综上所述如果您不希望引入中间层，且使用基于 Java 语言开发的系统，且需要对接不同的关系型数据库，Sharding-JDBC 将会是一个不错的选择。\n\n\n\n**作者**\n\n**孙进华**\n亚马逊云科技资深解决方案架构师，负责帮助客户进行上云架构的设计和咨询。加入亚马逊云科技前自主创业负责电商平台搭建和车企电商平台整体架构设计。曾就职于全球领先的通讯设备公司，担任高级工程师，负责 LTE 设备系统的多个子系统的开发与架构设计。在高并发、高可用系统架构设计、微服务架构设计、数据库、中间件、IOT 等方面有着丰富的经验。","render":"<p>文章来源亚马逊 Amazon 官方博客</p>\n<h3><a id=\\"1_3\\"></a><strong>1.前言</strong></h3>\\n<p>Amazon Aurora 是亚马逊云科技自研的一项关系数据库服务，它在提供和开源数据库 MySQL、PostgreSQL 的完好兼容性同时，也能够提供和商业数据库媲美的性能和可用性。性能方面，Aurora MySQL 能够支持到与开源标准 MySQL 同等配置下五倍的吞吐量，Aurora PostgreSQL 能够支持与开源标准 PostgreSQL 同等配置下三倍的吞吐量的提升。在扩展性的角度，Aurora 在存储与计算、横向与纵向方面都进行了功能的增强和创新。</p>\n<p>Aurora 的最大数据存储量现在支持多达 128TB，而且可以支持存储的动态收缩。计算方面，Aurora 提供多个读副本的可扩展性配置支持一个区域内多达15个读副本的扩展，提供多主的架构来支持同一个区域内4个写节点的扩展，提供 Serverless 无服务器化的架构实例级别的秒级纵向扩展，提供全球数据库来实现数据库的低延迟跨区域扩展。</p>\n<p>随着用户数据量的增长，Aurora 已经提供了很好的扩展性，那是否可以进一步增强更多的数据量、更多的并发访问能力呢？您可以考虑利用分库分表的方式，来支持底层多个 Aurora 集群的配置。基于此，包含这篇博客在内的系列博客会进行相应的介绍，旨在为您进行分库分表时代理或者 JDBC 的选择提供参考。</p>\n<h4><a id=\\"11_10\\"></a><strong>1.1为什么要分库分表</strong></h4>\\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/df3406b985fe4b5cbb99fa0dc21fa078_image.png\\" alt=\\"image.png\\" /></p>\n<p>Amazon Aurora 提供了关系型数据库单机，主从，多主，全球数据库等托管架构形式可以满足以上各种架构场景，但分库分表的场景下 Aurora 没有提供直接的支持，并且分库分表还衍生出来如垂直与水平多种形态,再进一步提升数据容量的情况下，也带来一些需要解决的问题，如跨节点数据库 Join 关联查询、分布式事务、执行的 SQL 排序、翻页、函数计算、数据库全局主键、容量规划、分库分表后二次扩容等问题。</p>\n<h4><a id=\\"12_15\\"></a><strong>1.2分库分表的方式</strong></h4>\\n<p>查询一次所花的时间业界公认 MySQL 单表容量在1千万以下是最佳状态，因为这时它的 BTREE 索引树高在3~5之间。通过对数据的切分可以在降低单表的数据量的同时，将读写的压力分摊到不同的数据节点上，数据切分可以分为：垂直切分和水平切分。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/d48c8328c43241f995b5ca9e2cc49f38_image.png\\" alt=\\"image.png\\" /></p>\n<p><strong>1.垂直切分的优点</strong><br />\\n解决业务系统层面的耦合，业务清晰；</p>\n<p>与微服务的治理类似，也能对不同业务的数据进行分级管理、维护、监控、扩展等；</p>\n<p>高并发场景下，垂直切分一定程度的提升 IO、数据库连接数、单机硬件资源的瓶颈。</p>\n<p><strong>2.垂直切分的缺点</strong><br />\\n分库后无法 Join，只能通过接口聚合方式解决，提升了开发的复杂度；</p>\n<p>分库后分布式事务处理复杂；</p>\n<p>依然存在单表数据量过大的问题（需要水平切分）。</p>\n<p><strong>3.水平切分的优点</strong><br />\\n不存在单库数据量过大、高并发的性能瓶颈，提升系统稳定性和负载能力；</p>\n<p>应用端改造较小，不需要拆分业务模块。</p>\n<p><strong>4.水平切分的缺点</strong><br />\\n跨分片的事务一致性难以保证；</p>\n<p>跨库的 Join 关联查询性能较差；</p>\n<p>数据多次扩展难度和维护量极大。</p>\n<p>结合以上分析，在调研了常见的分库分表的中间件基础上，我们选取 ShardingSphere 开源产品结合 Amazon Aurora，介绍这两种产品的结合是如何满足各种形式的分库分表方式和如何解决由分库分表带来的一些问题。</p>\n<h3><a id=\\"2ShardingJDBC__48\\"></a><strong>2.Sharding-JDBC 功能测试</strong></h3>\\n<h4><a id=\\"21_49\\"></a><strong>2.1样例工程说明</strong></h4>\\n<p>下载样例工程代码到本地，为保证测试代码的稳定性我们这里选择使 shardingsphere-example-4.0.0 这个 tag 版本。</p>\n<pre><code class=\\"lang-git\\"></code></pre>\\n<p><strong>工程项目说明：</strong></p>\\n<pre><code class=\\"lang-shardingsphere-example\\"> ├── example-core\\n │ ├── config-utility\\n │ ├── example-api\\n │ ├── example-raw-jdbc\\n │ ├── example-spring-jpa #spring+jpa集成基础的entity，repository\\n │ └── example-spring-mybatis\\n ├── sharding-jdbc-example\\n │ ├── sharding-example\\n │ │ ├── sharding-raw-jdbc-example\\n │ │ ├── sharding-spring-boot-jpa-example #集成基础的sharding-jdbc的功能\\n │ │ ├── sharding-spring-boot-mybatis-example\\n │ │ ├── sharding-spring-namespace-jpa-example\\n │ │ └── sharding-spring-namespace-mybatis-example\\n │ ├── orchestration-example\\n │ │ ├── orchestration-raw-jdbc-example\\n │ │ ├── orchestration-spring-boot-example #集成基础的sharding-jdbc的治理的功能\\n │ │ └── orchestration-spring-namespace-example\\n │ ├── transaction-example\\n │ │ ├── transaction-2pc-xa-example #sharding-jdbc分布式事务两阶段提交的样例\\n │ │ └──transaction-base-seata-example #sharding-jdbc分布式事务seata的样例\\n │ ├── other-feature-example\\n │ │ ├── hint-example\\n │ │ └── encrypt-example\\n ├── sharding-proxy-example\\n │ └── sharding-proxy-boot-mybatis-example\\n └── src/resources\\n └── manual_schema.sql \\n</code></pre>\\n<p><strong>配置文件说明：</strong></p>\\n<pre><code class=\\"lang-application-master-slave.properties\\">application-sharding-databases-tables.properties #分库分表配置文件\\napplication-sharding-databases.properties #仅分库配置文件\\napplication-sharding-master-slave.properties #分库分表加读写分离的配置文件\\napplication-sharding-tables.properties #分表配置文件\\napplication.properties #spring boot 配置文件\\n</code></pre>\\n<p><strong>代码逻辑说明：</strong></p>\\n<p>Spring Boot 应用的入口类，执行该类就可以运行工程</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/37a63ea47e534bb6bbd3717007cd563b_image.png\\" alt=\\"image.png\\" /></p>\n<p>其中 demo 的执行逻辑如下：</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/0b746d6849f24769bd1ac7479521e53d_image.png\\" alt=\\"image.png\\" /></p>\n<h4><a id=\\"22_102\\"></a><strong>2.2读写分离验证</strong></h4>\\n<p>随着业务增长，写和读请求分离到不同的数据库节点上能够有效提高整个数据库集群的处理能力。Aurora 通过读/写的 endpoint 可以满足用户写和强一致性读的需求，单独只读的 endpoint 可以满足用户非强一致性读的需求。Aurora 的读写延迟通常在毫秒级别，比 MySQL 基于 binlog 的逻辑复制要低得多，所以有很多负载是直接打到只读 endpoint。</p>\n<p>通过一主多从的配置方式，可以将查询请求均匀的分散到多个数据副本，能够进一步的提升系统的处理能力。读写分离虽然可以提升系统的吞吐量和可用性，但同时也带来了数据不一致的问题。Aurora 以完全托管的形式提供了主从架构，但上层应用在与 Aurora 交互时，仍然需要管理多个数据源，根据 SQL 语句的读写类型和一定的路由策略将 SQL 请求路由到不同的节点上。</p>\n<p>Sharding-JDBC 提供的读写分离的特性，应用程序与 Sharding-JDBC 集成，将应用程序与数据库集群之间复杂配置关系从应用程序中剥离出来，开发者通过配置文件管理 Shard，再结合一些 ORM 框架如 Spring JPA、Mybatis 就可以完全将这些复制的逻辑从代码中分离。极大的提高代码的可维护性，降低代码与数据库的耦合。</p>\n<h5><a id=\\"221_110\\"></a><strong>2.2.1数据库环境准备</strong></h5>\\n<p>首先创建一套 Aurora MySQL 读写分离集群，机型为 db.r5.2xlarge，每套集群有一个写节点 2 个读节点。如下图所示</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/30737f619bb846da9deb46a2cfdb2a51_image.png\\" alt=\\"image.png\\" /></p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/00cb01b76ee042a59f1647632367ac21_image.png\\" alt=\\"image.png\\" /></p>\n<h5><a id=\\"222ShardingJDBC__117\\"></a>2.2.2Sharding-JDBC 配置</h5>\\n<p><strong>application.properties spring boot 主配置文件说明</strong></p>\\n<p>如下图所属：绿色标注的部分你需要替换成自己环境上的配置</p>\n<pre><code class=\\"lang-#\\">spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n\\n#spring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n#激活master-slave 配置项，这样sharding-jdbc将使用master-slave配置文件\\nspring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n</code></pre>\\n<p><strong>application-master-slave.properties sharding-jdbc 配置文件说明</strong></p>\\n<pre><code class=\\"lang-spring.shardingsphere.datasource.names=ds_master,ds_slave_0,ds_slave_1\\"># 数据源 主库-master\\nspring.shardingsphere.datasource.ds_master.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master.password= 您自己的主db密码\\nspring.shardingsphere.datasource.ds_master.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master.jdbc-url=您自己的主db数据源url spring.shardingsphere.datasource.ds_master.username=您自己的主db用户名 \\n# 数据源 从库\\nspring.shardingsphere.datasource.ds_slave_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_slave_0.password= 您自己的从db密码\\nspring.shardingsphere.datasource.ds_slave_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_slave_0.jdbc-url=您自己的从db数据源url\\nspring.shardingsphere.datasource.ds_slave_0.username= 您自己的从db用户名\\n# 数据源 从库\\nspring.shardingsphere.datasource.ds_slave_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_slave_1.password=您自己的从db密码\\nspring.shardingsphere.datasource.ds_slave_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_slave_1.jdbc-url= 您自己的从db数据源url\\nspring.shardingsphere.datasource.ds_slave_1.username= 您自己的从db用户名\\n# 路由策略配置\\nspring.shardingsphere.masterslave.load-balance-algorithm-type=round_robin\\nspring.shardingsphere.masterslave.name=ds_ms\\nspring.shardingsphere.masterslave.master-data-source-name=ds_master\\nspring.shardingsphere.masterslave.slave-data-source-names=ds_slave_0,ds_slave_1\\n# sharding-jdbc 配置信息存储方式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere 日志，开启的情况下从打印中可以看到逻辑SQL到实际SQL的转换\\nspring.shardingsphere.props.sql.show=true\\n</code></pre>\\n<h5><a id=\\"223_162\\"></a><strong>2.2.3测试验证过程说明</strong></h5>\\n<p>测试环境数据初始化：Spring JPA 初始化自动创建用于测试的表</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/7845c776b068437b905a6ef7303004e3_image.png\\" alt=\\"image.png\\" /></p>\n<ul>\\n<li>在主实例上写入数据</li>\n</ul>\\n<p>如下图 ShardingSphere-SQL log 所示，写 SQL 在 ds_master 数据源上执行。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/882045fbee644a69adcecae4b5805293_image.png\\" alt=\\"image.png\\" /></p>\n<ul>\\n<li>数据查询操作在从库上执行</li>\n</ul>\\n<p>如下图 ShardingSphere-SQL log 所示，读 SQL 按照轮询的方式在 ds_slave 数据源上执行。</p>\n<pre><code class=\\"lang-[INFO\\">[INFO ] 2022-04-02 19:43:39,376 --main-- [ShardingSphere-SQL] SQL: select orderentit0_.order_id as order_id1_1_, orderentit0_.address_id as address_2_1_, \\norderentit0_.status as status3_1_, orderentit0_.user_id as user_id4_1_ from t_order orderentit0_ ::: DataSources: ds_slave_0 \\n---------------------------- Print OrderItem Data -------------------\\nHibernate: select orderiteme1_.order_item_id as order_it1_2_, orderiteme1_.order_id as order_id2_2_, orderiteme1_.status as status3_2_, orderiteme1_.user_id \\nas user_id4_2_ from t_order orderentit0_ cross join t_order_item orderiteme1_ where orderentit0_.order_id=orderiteme1_.order_id\\n[INFO ] 2022-04-02 19:43:40,898 --main-- [ShardingSphere-SQL] Rule Type: master-slave \\n[INFO ] 2022-04-02 19:43:40,898 --main-- [ShardingSphere-SQL] SQL: select orderiteme1_.order_item_id as order_it1_2_, orderiteme1_.order_id as order_id2_2_, orderiteme1_.status as status3_2_, \\norderiteme1_.user_id as user_id4_2_ from t_order orderentit0_ cross join t_order_item orderiteme1_ where orderentit0_.order_id=orderiteme1_.order_id ::: DataSources: ds_slave_1 \\n</code></pre>\\n<p>注意：如下图所示，如果在一个事务中既有读也有写，Sharding-JDBC 将读写操作都路由到主库；如果读写请求不在一个事务中，那么对应读请求将按照路由策略分发到不同的读节点上。</p>\n<pre><code class=\\"lang-@Override\\">@Transactional // 开启事务时在该事务中读写都走主库；关闭事务时，读走从库，写走主库\\npublic void processSuccess() throws SQLException {\\n System.out.println(&quot;-------------- Process Success Begin ---------------&quot;);\\n List&lt;Long&gt; orderIds = insertData();\\n printData();\\n deleteData(orderIds);\\n printData();\\n System.out.println(&quot;-------------- Process Success Finish --------------&quot;);\\n}\\n</code></pre>\\n<h5><a id=\\"224Aurora_failover__200\\"></a><strong>2.2.4Aurora failover 场景验证</strong></h5>\\n<p>Aurora 数据库环境采用 2.2.1 中的配置。</p>\n<h6><a id=\\"2241_202\\"></a><strong>2.2.4.1验证过程中说明</strong></h6>\\n<p>1.启动 Spring-Boot 工程<br />\\n2.在 Aurora 的 console 上执行故障转移操作</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/0ac67af4b8464feca55ba2576319227b_image.png\\" alt=\\"image.png\\" /></p>\n<p>3.执行 Rest API 请求<br />\\n4.多次执行 POST(<a href=\\"http://localhost:8088/save-user\\" target=\\"_blank\\">http://localhost:8088/save-user</a>)直到该 API 的调用写入 Aurora 失败到最终恢复成功。<br />\\n5.观测执行代码 failover 过程如下图所示，从 log 可以分析最近一次 SQL 执行写入操作成功到下次执行再次写入成功大概需要 37s，也就是应用从 Aurora failover 中可以自动恢复，恢复的时长大概是 37s。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/3bdc6bd340ef4464bd9df7dedc8adb0f_image.png\\" alt=\\"image.png\\" /></p>\n<h4><a id=\\"23_214\\"></a><strong>2.3仅分表功能验证</strong></h4>\\n<h5><a id=\\"231ShardingJDBC__215\\"></a><strong>2.3.1Sharding-JDBC 配置</strong></h5>\\n<p><strong>application.properties spring boot 主配置文件说明</strong></p>\\n<pre><code class=\\"lang-#\\">spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n#spring.profiles.active=sharding-databases\\n#激活sharding-tables配置项\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n# spring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n</code></pre>\\n<p><strong>application-sharding-tables.properties sharding-jdbc 配置文件说明</strong></p>\\n<pre><code class=\\"lang-##\\">spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds.t_order_item_\$-&gt;{0..1}\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_\$-&gt;{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# 配置t_order与 t_order_item的绑定关系\\nspring.shardingsphere.sharding.binding-tables[0]=t_order,t_order_item\\n# 配置广播表\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n</code></pre>\\n<h5><a id=\\"232_248\\"></a><strong>2.3.2测试验证过程说明</strong></h5>\\n<p>1.DDL 操作</p>\n<p>如下图所属，JPA 自动创建用于测试的表，在配置了 Sharding-JDBC 的路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表，由于只有一个主实例，所以创建一个 t_address；t_order 按照取模分表，创建 t_order 时会创建 t_order_0, t_order_1 两张表物理表。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/f18770f96872485490d8a57a07ddfff0_image.png\\" alt=\\"image.png\\" /></p>\n<p>2.写操作</p>\n<p>如下图所示 Logic SQL 向 t_order 插入一条记录，Sharding-JDBC 执行的时候会根据分表规则将数据分布放到 t_order_0, t_order_1 中。</p>\n<p>当 t_order 和 t_order_item 配置了绑定关系时，order_item 与 order 有关联关系的记录会放到同一个物理分表中。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/9ed1ac5858e64a54af2a5c2915551fa7_image.png\\" alt=\\"image.png\\" /></p>\n<p>3.读操作</p>\n<p>绑定表下的 join 查询操作 order 和 order_item，如下图所示，会根据绑定关系精确定位对应的物理 shard 上。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/710393f61b2945798462a7a56a382538_image.png\\" alt=\\"image.png\\" /></p>\n<p>非绑定表下的 join 查询操作 order 和 order_item，如下图所属，会遍历所有的 shard。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/9ed1ac5858e64a54af2a5c2915551fa7_image.png\\" alt=\\"配图14.png\\" /></p>\n<h4><a id=\\"24_273\\"></a><strong>2.4仅分库功能验证</strong></h4>\\n<h5><a id=\\"241_274\\"></a><strong>2.4.1数据库环境准备</strong></h5>\\n<p>如下图所属，在 Aurora 上创建两个实例：ds_0 和 ds_1</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/9c1b143903be4a2e8f77208af4e0bd82_%E9%85%8D%E5%9B%BE15.png\\" alt=\\"配图15.png\\" /></p>\n<p>启动 Sharding-spring-boot-jpa-example 工程时会在两个 Aurora 实例上创建表 t_order, t_order_item，t_address</p>\n<h5><a id=\\"242ShardingJDBC__282\\"></a><strong>2.4.2Sharding-JDBC 配置</strong></h5>\\n<p><strong>application.properties springboot 主配置文件说明</strong></p>\\n<pre><code class=\\"lang-#\\">spring.jpa.properties.hibernate.hbm2ddl.auto=create\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n\\n# 激活sharding-databases配置项\\nspring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n#spring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n\\napplication-sharding-databases.properties sharding-jdbc 配置文件说明\\n\\nspring.shardingsphere.datasource.names=ds_0,ds_1\\n# ds_0\\nspring.shardingsphere.datasource.ds_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_0.jdbc-url= spring.shardingsphere.datasource.ds_0.username= \\nspring.shardingsphere.datasource.ds_0.password=\\n# ds_1\\nspring.shardingsphere.datasource.ds_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_1.jdbc-url= \\nspring.shardingsphere.datasource.ds_1.username= \\nspring.shardingsphere.datasource.ds_1.password=\\nspring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id\\nspring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_\$-&gt;{user_id % 2}\\nspring.shardingsphere.sharding.binding-tables=t_order,t_order_item\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\nspring.shardingsphere.sharding.default-data-source-name=ds_0\\n\\nspring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_\$-&gt;{0..1}.t_order\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_\$-&gt;{0..1}.t_order_item\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n</code></pre>\\n<h5><a id=\\"243_329\\"></a><strong>2.4.3测试验证过程说明</strong></h5>\\n<p>1.DDL 操作</p>\n<p>JPA 自动创建用于测试的表，如下图所属，在配置了 Sharding-JDBC 的分库路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表在 ds_0 和 ds_1 上都会创建物理表 t_address，t_order，t_order_item 按照取模分库，这三个表会分别在 ds_0 和 ds_1 上创建。<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/34c0ec5466ba4905ad8d03b6a939831a_%E9%85%8D%E5%9B%BE16.png\\" alt=\\"配图16.png\\" /><br />\\n2.写操作</p>\n<p>对于广播表 t_address，每写入一条记录会在 ds_0 和 ds_1 的 t_address 表上都写入<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/94f71f3a0db44222a1c7a565e4b95001_%E9%85%8D%E5%9B%BE17.png\\" alt=\\"配图17.png\\" /><br />\\n对于分库的表 t_order，t_order_item，会按照分库字段和路由策略写入到对应实例上的表中。<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/c211621c137a4ba0b7415e0ad67803b4_%E9%85%8D%E5%9B%BE18.png\\" alt=\\"配图18.png\\" /><br />\\n3.读操作</p>\n<p>如下图所示，查询 order，根据分库路由规则路由到对应的 Aurora 实例上。<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/180caee1799f478d98db4d52735f2e63_%E9%85%8D%E5%9B%BE19.png\\" alt=\\"配图19.png\\" /><br />\\n如下图所示，查询 Address，由于 address 是广播表，会在所用的节点中随机选择一个 address 所在的实例查询。<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/37296971c360410fbf187f384c52bbf1_%E9%85%8D%E5%9B%BE20.png\\" alt=\\"配图20.png\\" /><br />\\n如下图所示，绑定表下的 join 查询操作 order 和 order_item 时，会根据绑定关系精确定位对应的物理 shard 上。<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/3099feca55624949b54cd425880afe0e_%E9%85%8D%E5%9B%BE21.png\\" alt=\\"配图21.png\\" /></p>\n<h4><a id=\\"25_348\\"></a><strong>2.5分库分表功能验证</strong></h4>\\n<h5><a id=\\"251_349\\"></a><strong>2.5.1数据库环境准备</strong></h5>\\n<p>如下图所示，在 Aurora 上创建两个实例：ds_0和ds_1</p>\n<p>启动 sharding-spring-boot-jpa-example 工程时会在两个 Aurora 实例上创建物理表 t_order_01, t_order_02, t_order_item_01，t_order_item_02 和 t_address 全局表。<br />\\n<img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/492949621ed24793b385c638f5e31ecb_%E9%85%8D%E5%9B%BE22.png\\" alt=\\"配图22.png\\" /></p>\n<h3><a id=\\"252ShardingJDBC__354\\"></a>2.5.2Sharding-JDBC 配置</h3>\\n<p><strong>application.properties springboot 主配置文件说明</strong></p>\\n<pre><code class=\\"lang-#\\">spring.jpa.properties.hibernate.hbm2ddl.auto=create\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n# 激活sharding-databases-tables配置项\\n#spring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\nspring.profiles.active=sharding-databases-tables\\n#spring.profiles.active=master-slave\\n#spring.profiles.active=sharding-master-slave\\n</code></pre>\\n<p><strong>application-sharding-databases.properties sharding-jdbc 配置文件说明</strong></p>\\n<pre><code class=\\"lang-spring.shardingsphere.datasource.names=ds_0,ds_1\\"># ds_0\\nspring.shardingsphere.datasource.ds_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_0.jdbc-url= 306/dev?useSSL=false&amp;characterEncoding=utf-8\\nspring.shardingsphere.datasource.ds_0.username= \\nspring.shardingsphere.datasource.ds_0.password=\\nspring.shardingsphere.datasource.ds_0.max-active=16\\n# ds_1\\nspring.shardingsphere.datasource.ds_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_1.jdbc-url= \\nspring.shardingsphere.datasource.ds_1.username= \\nspring.shardingsphere.datasource.ds_1.password=\\nspring.shardingsphere.datasource.ds_1.max-active=16\\n# 默认的分库策略\\nspring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id\\nspring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_\$-&gt;{user_id % 2}\\nspring.shardingsphere.sharding.binding-tables=t_order,t_order_item\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\n# 不满足分库策略的表放在ds_0上\\nspring.shardingsphere.sharding.default-data-source-name=ds_0\\n# t_order分表策略\\nspring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_\$-&gt;{0..1}.t_order_\$-&gt;{0..1}\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_\$-&gt;{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\n# t_order_item分表策略\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_\$-&gt;{0..1}.t_order_item_\$-&gt;{0..1}\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_\$-&gt;{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n</code></pre>\\n<h5><a id=\\"253_409\\"></a><strong>2.5.3测试验证过程说明</strong></h5>\\n<p>1.DDL 操作</p>\n<p>JPA 自动创建用于测试的表，如下图所示，在配置了 Sharding-JDBC 的分库分表路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表在 ds_0 和 ds_1 上都会创建 t_address。t_order，t_order_item 按照取模分库分表，这三个表会分别在 ds_0 和 ds_1 上创建。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/10c686d55ffc4562809b35d971160528_%E9%85%8D%E5%9B%BE23.png\\" alt=\\"配图23.png\\" /><br />\\n2.写操作</p>\n<p>对于广播表 t_address，每写入一条记录会在 ds_0 和 ds_1 的 t_address 表上都写入。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/b1968c9b0aef408e8ffe4178b652404e_%E9%85%8D%E5%9B%BE24.png\\" alt=\\"配图24.png\\" /></p>\n<p>对于分库的表 t_order，t_order_item，会按照分库字段和路由策略写入到对应实例上的表中。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/ce289864049a4900aae82d50f053f2c5_%E9%85%8D%E5%9B%BE25.png\\" alt=\\"配图25.png\\" /><br />\\n3.读操作</p>\n<p>读操作与仅分库功能验证类似，这里不再赘述</p>\n<h4><a id=\\"26_428\\"></a><strong>2.6分库分表加读写分离功能验证</strong></h4>\\n<h5><a id=\\"261_430\\"></a><strong>2.6.1数据库环境准备</strong></h5>\\n<p>创建的数据库实例于对应的物理表如下图所示。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/57978479fbdb4931bb135219ed084a35_%E9%85%8D%E5%9B%BE26.png\\" alt=\\"配图26.png\\" /></p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/34b134a8dd7d453994f9da4696d6e2cb_%E9%85%8D%E5%9B%BE27.png\\" alt=\\"配图27.png\\" /></p>\n<h5><a id=\\"262ShardingJDBC__438\\"></a><strong>2.6.2Sharding-JDBC 配置</strong></h5>\\n<p><strong>application.properties spring boot 主配置文件说明</strong></p>\\n<pre><code class=\\"lang-#\\">spring.jpa.properties.hibernate.hbm2ddl.auto=create\\nspring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect\\nspring.jpa.properties.hibernate.show_sql=true\\n\\n# 激活sharding-databases-tables配置项\\n#spring.profiles.active=sharding-databases\\n#spring.profiles.active=sharding-tables\\n#spring.profiles.active=sharding-databases-tables\\n#spring.profiles.active=master-slave\\nspring.profiles.active=sharding-master-slave\\n</code></pre>\\n<p><strong>application-sharding-master-slave.properties sharding-jdbc 配置文件说明</strong><br />\\n其中数据库的 url、name、password 需要修改成你自己的数据库的参数。</p>\n<pre><code class=\\"lang-spring.shardingsphere.datasource.names=ds_master_0,ds_master_1,ds_master_0_slave_0,ds_master_0_slave_1,ds_master_1_slave_0,ds_master_1_slave_1\\">spring.shardingsphere.datasource.ds_master_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_0.jdbc-url= spring.shardingsphere.datasource.ds_master_0.username= \\nspring.shardingsphere.datasource.ds_master_0.password=\\nspring.shardingsphere.datasource.ds_master_0.max-active=16\\nspring.shardingsphere.datasource.ds_master_0_slave_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_0_slave_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_0_slave_0.jdbc-url= spring.shardingsphere.datasource.ds_master_0_slave_0.username= \\nspring.shardingsphere.datasource.ds_master_0_slave_0.password=\\nspring.shardingsphere.datasource.ds_master_0_slave_0.max-active=16\\nspring.shardingsphere.datasource.ds_master_0_slave_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_0_slave_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_0_slave_1.jdbc-url= spring.shardingsphere.datasource.ds_master_0_slave_1.username= \\nspring.shardingsphere.datasource.ds_master_0_slave_1.password=\\nspring.shardingsphere.datasource.ds_master_0_slave_1.max-active=16\\nspring.shardingsphere.datasource.ds_master_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_1.jdbc-url= \\nspring.shardingsphere.datasource.ds_master_1.username= \\nspring.shardingsphere.datasource.ds_master_1.password=\\nspring.shardingsphere.datasource.ds_master_1.max-active=16\\nspring.shardingsphere.datasource.ds_master_1_slave_0.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_1_slave_0.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_1_slave_0.jdbc-url=\\nspring.shardingsphere.datasource.ds_master_1_slave_0.username=\\nspring.shardingsphere.datasource.ds_master_1_slave_0.password=\\nspring.shardingsphere.datasource.ds_master_1_slave_0.max-active=16\\nspring.shardingsphere.datasource.ds_master_1_slave_1.type=com.zaxxer.hikari.HikariDataSource\\nspring.shardingsphere.datasource.ds_master_1_slave_1.driver-class-name=com.mysql.jdbc.Driver\\nspring.shardingsphere.datasource.ds_master_1_slave_1.jdbc-url= spring.shardingsphere.datasource.ds_master_1_slave_1.username=admin\\nspring.shardingsphere.datasource.ds_master_1_slave_1.password=\\nspring.shardingsphere.datasource.ds_master_1_slave_1.max-active=16\\nspring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id\\nspring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds_\$-&gt;{user_id % 2}\\nspring.shardingsphere.sharding.binding-tables=t_order,t_order_item\\nspring.shardingsphere.sharding.broadcast-tables=t_address\\nspring.shardingsphere.sharding.default-data-source-name=ds_master_0\\nspring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds_\$-&gt;{0..1}.t_order_\$-&gt;{0..1}\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_\$-&gt;{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id\\nspring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order.key-generator.props.worker.id=123\\nspring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds_\$-&gt;{0..1}.t_order_item_\$-&gt;{0..1}\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id\\nspring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_\$-&gt;{order_id % 2}\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.column=order_item_id\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE\\nspring.shardingsphere.sharding.tables.t_order_item.key-generator.props.worker.id=123\\n# 主从数据源，分库数据源配置\\nspring.shardingsphere.sharding.master-slave-rules.ds_0.master-data-source-name=ds_master_0\\nspring.shardingsphere.sharding.master-slave-rules.ds_0.slave-data-source-names=ds_master_0_slave_0, ds_master_0_slave_1\\nspring.shardingsphere.sharding.master-slave-rules.ds_1.master-data-source-name=ds_master_1\\nspring.shardingsphere.sharding.master-slave-rules.ds_1.slave-data-source-names=ds_master_1_slave_0, ds_master_1_slave_1\\n# sharding-jdbc的模式\\nspring.shardingsphere.mode.type=Memory\\n# 开启shardingsphere日志\\nspring.shardingsphere.props.sql.show=true\\n</code></pre>\\n<h5><a id=\\"263_515\\"></a><strong>2.6.3测试验证过程说明</strong></h5>\\n<p>1.DDL 操作所属</p>\n<p>JPA 自动创建用于测试的表，如下图，在配置了 Sharding-JDBC 的分库路由规则的情况下，client 端执行 DDL，Sharding-JDBC 会自动根据分表规则创建对应的表；如 t_address 是广播表在 ds_0 和 ds_1 上都会创建, t_address，t_order，t_order_item 按照取模分库，这三个表会分别在 ds_0 和 ds_1 上创建。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/57534702d1744c239cdf9d8b53349cca_%E9%85%8D%E5%9B%BE28.png\\" alt=\\"配图28.png\\" /></p>\n<p>2.写操作</p>\n<p>对于广播表 t_address，每写入一条记录会在 ds_0 和 ds_1 的 t_address 表上都写入</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/940a40099eb44992b8d7813175515155_%E9%85%8D%E5%9B%BE29.png\\" alt=\\"配图29.png\\" /></p>\n<p>对于分库的表 t_order，t_order_item，会按照分库字段和路由策略写入到对应实例上的表中。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/1dd3501dc81b47799cd95aea8572577a_%E9%85%8D%E5%9B%BE30.png\\" alt=\\"配图30.png\\" /><br />\\n3.读操作</p>\n<p>绑定表下的 join 查询操作 order 和 order_item，如下图所示。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/b410bca3eef84b5ab81a2b48aa49d018_%E9%85%8D%E5%9B%BE31.png\\" alt=\\"配图31.png\\" /></p>\n<h3><a id=\\"3_538\\"></a><strong>3.结语</strong></h3>\\n<p>ShardingSphere 作为一款专注于数据库增强的开源产品，从社区活跃度、产品成熟度、文档丰富程度上来看都是比较好的。其中的 Sharding-JDBC 是基于客户端的分库分表方案，它支持了所有的分库分表的场景，并且无需引入 Proxy 这样的中间层，所以降低了运维的复杂性，相比 Proxy 这种方式由于少了中间层所以时延理论上会比 Proxy 低，其次 Sharding-JDBC 可以支持各种基于 SQL 标准的关系型数据库如 MySQL/PostgreSQL/Oracle/SQL Server 等。但由于 Sharding-JDBC 与应用程序集成，目前支持的语言仅限于 Java，对应用程序有一定的耦合性，但 Sharding-JDBC 将所以分库分表的配置从应用程序中分离，这样面临切换其他的中间件时由此带来的变更相对较小。综上所述如果您不希望引入中间层，且使用基于 Java 语言开发的系统，且需要对接不同的关系型数据库，Sharding-JDBC 将会是一个不错的选择。</p>\n<p><img src=\\"https://awsdevweb.s3.cn-north-1.amazonaws.com.cn/e3c60e9e14b244099aafb614ecbc24ca_%E6%96%87%E6%9C%AB%E5%9B%BE.jpeg\\" alt=\\"文末图.jpeg\\" /></p>\n<p><strong>作者</strong></p>\\n<p><strong>孙进华</strong><br />\\n亚马逊云科技资深解决方案架构师，负责帮助客户进行上云架构的设计和咨询。加入亚马逊云科技前自主创业负责电商平台搭建和车企电商平台整体架构设计。曾就职于全球领先的通讯设备公司，担任高级工程师，负责 LTE 设备系统的多个子系统的开发与架构设计。在高并发、高可用系统架构设计、微服务架构设计、数据库、中间件、IOT 等方面有着丰富的经验。</p>\n"}