Sharding-JDBC教程：Spring Boot整合Sharding-JDBC实现数据分表+读写分离

最新推荐文章于 2024-07-29 18:57:42 发布

我是小泽呀！

最新推荐文章于 2024-07-29 18:57:42 发布

阅读量261

点赞数

分类专栏：架构技术文章标签： Sharding-JDBC java Spring Boot 读写分离数据分表

本文链接：https://blog.csdn.net/Java__xiaoze/article/details/98590330

版权

架构技术专栏收录该内容

37 篇文章 1 订阅

订阅专栏

读写分离

在上一篇文章介绍了如何使用Sharing-JDBC实现数据库的读写分离。读写分离的好处就是在并发量比较大的情况下，将查询数据库的压力分担到多个从库中，能够满足高并发的要求。比如上一篇实现的那样，架构图如下：

数据分表

当数据量比较大的时候，比如单个表的数据量超过了500W的数据，这时可以考虑将数据存储在不同的表中。比如将user表拆分为四个表user0、user1、 user2、user3装在四个表中。此时如图所示：

案例详解

和上一篇文章使用的数据库是同一个数据库，数据库信息如下：

数据库类型	数据库	ip
主	cool	10.0.0.3
从	cool	10.0.0.13
从	cool	10.0.0.17

在主库初始化Mysql数据的脚本，初始化完后，从库也会创建这些表，脚本信息如下：

1.  `USE `cool`;`

3.  `/*Table structure for table `user_0` */`

5.  `DROP TABLE IF EXISTS `user_0`;`

7.  `CREATE TABLE `user_0`  (`

8.  ``id`  int(12) NOT NULL AUTO_INCREMENT,`

9.  ``username` varchar(12) NOT NULL,`

10.  ``password` varchar(30) NOT NULL,`

11.  `PRIMARY KEY (`id`),`

12.  `KEY `idx-username`  (`username`)`

13.  `) ENGINE=InnoDB AUTO_INCREMENT=149 DEFAULT CHARSET=utf8;`

15.  `/*Table structure for table `user_1` */`

17.  `DROP TABLE IF EXISTS `user_1`;`

19.  `CREATE TABLE `user_1`  (`

20.  ``id`  int(12) NOT NULL AUTO_INCREMENT,`

21.  ``username` varchar(12) NOT NULL,`

22.  ``password` varchar(30) NOT NULL,`

23.  `PRIMARY KEY (`id`),`

24.  `KEY `idx-username`  (`username`)`

25.  `) ENGINE=InnoDB AUTO_INCREMENT=150 DEFAULT CHARSET=utf8;`

27.  `/*Table structure for table `user_2` */`

29.  `DROP TABLE IF EXISTS `user_2`;`

31.  `CREATE TABLE `user_2`  (`

32.  ``id`  int(12) NOT NULL AUTO_INCREMENT,`

33.  ``username` varchar(12) NOT NULL,`

34.  ``password` varchar(30) NOT NULL,`

35.  `PRIMARY KEY (`id`),`

36.  `KEY `idx-username`  (`username`)`

37.  `) ENGINE=InnoDB AUTO_INCREMENT=147 DEFAULT CHARSET=utf8;`

39.  `/*Table structure for table `user_3` */`

41.  `DROP TABLE IF EXISTS `user_3`;`

43.  `CREATE TABLE `user_3`  (`

44.  ``id`  int(12) NOT NULL AUTO_INCREMENT,`

45.  ``username` varchar(12) NOT NULL,`

46.  ``password` varchar(30) NOT NULL,`

47.  `PRIMARY KEY (`id`),`

48.  `KEY `idx-username`  (`username`)`

49.  `) ENGINE=InnoDB AUTO_INCREMENT=148 DEFAULT CHARSET=utf8;`

本案例还是在上一篇文章的案例基础之上进行改造，工程的目录和pom的依赖见上一篇文章或者源码。在工程的配置文件application.yml做Sharding-JDBC的配置，代码如下：

1.  `sharding:`

2.  `jdbc:`

3.  `dataSource:`

4.  `names: db-test0,db-test1,db-test2`

5.  `db-test0:  #org.apache.tomcat.jdbc.pool.DataSource`

6.  `type: com.alibaba.druid.pool.DruidDataSource`

7.  `driverClassName: com.mysql.jdbc.Driver`

8.  `url: jdbc:mysql://10.0.0.3:3306/cool?useUnicode=true&characterEncoding=utf8&tinyInt1isBit=false&useSSL=false&serverTimezone=GMT`

9.  `username: root`

10.  `password:` 

11.  `maxPoolSize:  20`

12.  `db-test1:`

13.  `type: com.alibaba.druid.pool.DruidDataSource`

14.  `driverClassName: com.mysql.jdbc.Driver`

15.  `url: jdbc:mysql://10.0.0.13:3306/cool?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT`

16.  `username: root`

17.  `password:` 

18.  `maxPoolSize:  20`

19.  `db-test2:`

20.  `type: com.alibaba.druid.pool.DruidDataSource`

21.  `driverClassName: com.mysql.jdbc.Driver`

22.  `url: jdbc:mysql://10.0.0.17:3306/cool?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&serverTimezone=GMT`

23.  `username: root`

24.  `password:` 

25.  `maxPoolSize:  20`

26.  `props:`

27.  `sql:`

28.  `show:  true`

29.  `sharding.jdbc.config.sharding.tables.user.actual-data-nodes: ds_0.user_$->{0..3}`

30.  `sharding.jdbc.config.sharding.tables.user.table-strategy.standard.sharding-column: id`

31.  `sharding.jdbc.config.sharding.tables.user.table-strategy.standard.precise-algorithm-class-name: com.forezp.sharedingjdbcmasterslavetables.MyPreciseShardingAlgorithm`

33.  `sharding.jdbc.config.sharding.master-slave-rules.ds_0.master-data-source-name: db-test0`

34.  `sharding.jdbc.config.sharding.master-slave-rules.ds_0.slave-data-source-names: db-test1,db-test2`


*   在上面的配置中，sharding.jdbc.dataSource部分是配置的数据源的信息，本案例有三个数据源db-test0、db-test1、db-test2。

*   sharding.jdbc.config.sharding.master-slave-rules.ds0.master-data-source-name配置的是主库的数据库名，本案例为db-test0，其中ds0为分区名。

*   sharding.jdbc.config.sharding.master-slave-rules.ds_0.slave-data-source-names配置的是从库的数据库名，本案例为db-test1、db-test2。

*   sharding.jdbc.config.sharding.tables.user.actual-data-nodes配置的分表信息，真实的数据库信息。ds0.user$->{0..3}，表示读取ds0数据源的user0、user1、user2、user_3。

*   sharding.jdbc.config.sharding.tables.user.table-strategy.standard.sharding-column配置的数据分表的字段，是根据id来分的。

*   sharding.jdbc.config.sharding.tables.user.table-strategy.standard.precise-algorithm-class-name是配置数据分表的策略的类，这里是自定义的类MyPreciseShardingAlgorithm。

MyPreciseShardingAlgorithm是根据id取模4来获取表名的，代码如下：

<pre class="" style="margin: 0px; padding: 8px 0px 6px; max-width: 100%; box-sizing: border-box; word-wrap: break-word !important; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: 0.544px; orphans: 2; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background: rgb(241, 239, 238); border-radius: 0px; overflow-y: auto; color: rgb(80, 97, 109); text-align: start; font-size: 10px; line-height: 12px; font-family: consolas, menlo, courier, monospace, &quot;Microsoft Yahei&quot; !important; border-width: 1px !important; border-style: solid !important; border-color: rgb(226, 226, 226) !important;">

1.  `public  class  MyPreciseShardingAlgorithm  implements  PreciseShardingAlgorithm<Integer>  {`

3.  `@Override`

4.  `public  String doSharding(Collection<String> availableTargetNames,  PreciseShardingValue<Integer> shardingValue)  {`

5.  `for  (String tableName : availableTargetNames)  {`

6.  `if  (tableName.endsWith(shardingValue.getValue()  %  4  +  ""))  {`

7.  `return tableName;`

8.  `}`

9.  `}`

10.  `throw  new  IllegalArgumentException();`

11.  `}`

13.  `}`

测试

写一个API来测试，代码如下：

1.  `@RestController`

2.  `public  class  UserController  {`

4.  `Logger logger=  LoggerFactory.getLogger(UserController.class);`

6.  `@Autowired`

7.  `private  UserService userService;`

9.  `@GetMapping("/users")`

10.  `public  Object list()  {`

11.  `return userService.list();`

12.  `}`

14.  `@GetMapping("/add")`

15.  `public  Object add()  {`

17.  `for(int i=100;i<150;i++)  {`

18.  `User user =  new  User();`

19.  `user.setId(i);`

20.  `user.setUsername("forezp"+(i));`

21.  `user.setPassword("1233edwd");`

22.  `long resutl= userService.addUser(user);`

23.  `logger.info("insert:"+user.toString()+" result:"+resutl);`

24.  `}`

25.  `return  "ok";`

26.  `}`

27.  `}`

</pre>

启动Spring Boot工程，在浏览器上执行localhost:8080/add，然后去数据库中查询，可以看到user0、user1、user2、user3分别插入了数据。 然后访问localhost:8080/users，可以查询数据库中四个表中的所有数据。可见Sharding-JDBC在插入数据的时候，根据数据分表策略，将数据存储在 不同的表中，查询的时候将数据库从多个表中查询并聚合。

在数据库的主机的日志里面，可以看到查询的日志也验证了这个结论，如下：

<pre class="" style="margin: 0px; padding: 8px 0px 6px; max-width: 100%; box-sizing: border-box; word-wrap: break-word !important; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: normal; letter-spacing: 0.544px; orphans: 2; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; background: rgb(241, 239, 238); border-radius: 0px; overflow-y: auto; color: rgb(80, 97, 109); text-align: start; font-size: 10px; line-height: 12px; font-family: consolas, menlo, courier, monospace, &quot;Microsoft Yahei&quot; !important; border-width: 1px !important; border-style: solid !important; border-color: rgb(226, 226, 226) !important;">

1.  `2019-06-20T02:50:25.183174Z  2030  Query  select  @@session.transaction_read_only`

2.  `2019-06-20T02:50:25.193506Z  2030  Query INSERT INTO user_2 (`

3.  `id, username, password`

4.  `)`

5.  `VALUES (`

6.  `134,`

7.  `'forezp134',`

8.  `'1233edwd'`

9.  `)`

11.  `...省略`

从库查询日志：

1.  `2019-06-20T02:41:28.450643Z  7367  Query SELECT u.* FROM user_1 u`

2.  `2019-06-20T02:41:28.450644Z  7366  Query SELECT u.* FROM user_0 u`

3.  `2019-06-20T02:41:28.461238Z  7367  Query SELECT u.* FROM user_3 u`

4.  `2019-06-20T02:41:28.462188Z  7366  Query SELECT u.* FROM user_2 u`

源码

https://github.com/forezp/SpringBootLearning/tree/master/sharding-jdbc-example/shareding-jdbc-master-slave-tables

我是小泽呀！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Sharding-JDBC教程：Spring Boot整合Sharding-JDBC实现数据分表+读写分离

读写分离在上一篇文章介绍了如何使用Sharing-JDBC实现数据库的读写分离。读写分离的好处就是在并发量比较大的情况下，将查询数据库的压力分担到多个从库中，能够满足高并发的要求。比如上一篇实现的那样，架构图如下：数据分表当数据量比较大的时候，比如单个表的数据量超过了500W的数据，这时可以考虑将数据存储在不同的表中。比如将user表拆分为四个表user0、user1、 user...
复制链接

扫一扫