Spring Boot 2 整合 shard-jdbc 中间件，实现数据分库分表

标签： dev | 发表时间：2019-11-13 00:00 | 作者：
出处：http://itindex.net/relian

一、水平分割
1、水平分库
1)、概念：
以字段为依据，按照一定策略，将一个库中的数据拆分到多个库中。
2)、结果
每个库的结构都一样；数据都不一样；
所有库的并集是全量数据；
2、水平分表
1)、概念
以字段为依据，按照一定策略，将一个表中的数据拆分到多个表中。
2)、结果
每个表的结构都一样；数据都不一样；
所有表的并集是全量数据；
二、Shard-jdbc 中间件
1、架构图

2、特点
1)、Sharding-JDBC直接封装JDBC API，旧代码迁移成本几乎为零。
2)、适用于任何基于Java的ORM框架，如Hibernate、Mybatis等 。
3)、可基于任何第三方的数据库连接池，如DBCP、C3P0、 BoneCP、Druid等。
4)、以jar包形式提供服务，无proxy代理层，无需额外部署，无其他依赖。
5)、分片策略灵活，可支持等号、between、in等多维度分片，也可支持多分片键。
6)、SQL解析功能完善，支持聚合、分组、排序、limit、or等查询。

三、项目演示
1、项目结构

   springboot     2.0 版本    
druid          1.1.13 版本    
sharding-jdbc  3.1 版本

2、数据库配置

   
    一台基础库映射（shard_one）     
   两台库做分库分表（shard_two，shard_three）。    
表使用：table_one，table_two

3、核心代码块

1）、数据源配置文件

   spring:    
  datasource:    
    # 数据源：shard_one    
    dataOne:    
      type: com.alibaba.druid.pool.DruidDataSource    
      druid:    
        driverClassName: com.mysql.jdbc.Driver    
        url: jdbc:mysql://localhost:3306/shard_one?useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false    
        username: root    
        password: 123    
        initial-size: 10    
        max-active: 100    
        min-idle: 10    
        max-wait: 60000    
        pool-prepared-statements: true    
        max-pool-prepared-statement-per-connection-size: 20    
        time-between-eviction-runs-millis: 60000    
        min-evictable-idle-time-millis: 300000    
        max-evictable-idle-time-millis: 60000    
        validation-query: SELECT 1 FROM DUAL    
        # validation-query-timeout: 5000    
        test-on-borrow: false    
        test-on-return: false    
        test-while-idle: true    
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000    
    # 数据源：shard_two    
    dataTwo:    
      type: com.alibaba.druid.pool.DruidDataSource    
      druid:    
        driverClassName: com.mysql.jdbc.Driver    
        url: jdbc:mysql://localhost:3306/shard_two?useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false    
        username: root    
        password: 123    
        initial-size: 10    
        max-active: 100    
        min-idle: 10    
        max-wait: 60000    
        pool-prepared-statements: true    
        max-pool-prepared-statement-per-connection-size: 20    
        time-between-eviction-runs-millis: 60000    
        min-evictable-idle-time-millis: 300000    
        max-evictable-idle-time-millis: 60000    
        validation-query: SELECT 1 FROM DUAL    
        # validation-query-timeout: 5000    
        test-on-borrow: false    
        test-on-return: false    
        test-while-idle: true    
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000    
    # 数据源：shard_three    
    dataThree:    
      type: com.alibaba.druid.pool.DruidDataSource    
      druid:    
        driverClassName: com.mysql.jdbc.Driver    
        url: jdbc:mysql://localhost:3306/shard_three?useUnicode=true&characterEncoding=UTF8&zeroDateTimeBehavior=convertToNull&useSSL=false    
        username: root    
        password: 123    
        initial-size: 10    
        max-active: 100    
        min-idle: 10    
        max-wait: 60000    
        pool-prepared-statements: true    
        max-pool-prepared-statement-per-connection-size: 20    
        time-between-eviction-runs-millis: 60000    
        min-evictable-idle-time-millis: 300000    
        max-evictable-idle-time-millis: 60000    
        validation-query: SELECT 1 FROM DUAL    
        # validation-query-timeout: 5000    
        test-on-borrow: false    
        test-on-return: false    
        test-while-idle: true    
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

2）、数据库分库策略

   /**    
 * 数据库映射计算    
 */    
public class DataSourceAlg implements PreciseShardingAlgorithm<String> {    
    
    private static Logger LOG = LoggerFactory.getLogger(DataSourceAlg.class);    
    @Override    
    public String doSharding(Collection<String> names, PreciseShardingValue<String> value) {    
        LOG.debug("分库算法参数 {},{}",names,value);    
        int hash = HashUtil.rsHash(String.valueOf(value.getValue()));    
        return "ds_" + ((hash % 2) + 2) ;    
    }    
}

3）、数据表1分表策略

   /**    
 * 分表算法    
 */    
public class TableOneAlg implements PreciseShardingAlgorithm<String> {    
    private static Logger LOG = LoggerFactory.getLogger(TableOneAlg.class);    
    /**    
     * 该表每个库分5张表    
     */    
    @Override    
    public String doSharding(Collection<String> names, PreciseShardingValue<String> value) {    
        LOG.debug("分表算法参数 {},{}",names,value);    
        int hash = HashUtil.rsHash(String.valueOf(value.getValue()));    
        return "table_one_" + (hash % 5+1);    
    }    
}

4）、数据表2分表策略

   /**    
 * 分表算法    
 */    
public class TableTwoAlg implements PreciseShardingAlgorithm<String> {    
    private static Logger LOG = LoggerFactory.getLogger(TableTwoAlg.class);    
    /**    
     * 该表每个库分5张表    
     */    
    @Override    
    public String doSharding(Collection<String> names, PreciseShardingValue<String> value) {    
        LOG.debug("分表算法参数 {},{}",names,value);    
        int hash = HashUtil.rsHash(String.valueOf(value.getValue()));    
        return "table_two_" + (hash % 5+1);    
    }    
}

5）、数据源集成配置

   /**    
 * 数据库分库分表配置    
 */    
@Configuration    
public class ShardJdbcConfig {    
    // 省略了 druid 配置，源码中有    
    /**    
     * Shard-JDBC 分库配置    
     */    
    @Bean    
    public DataSource dataSource (@Autowired DruidDataSource dataOneSource,    
                                  @Autowired DruidDataSource dataTwoSource,    
                                  @Autowired DruidDataSource dataThreeSource) throws Exception {    
        ShardingRuleConfiguration shardJdbcConfig = new ShardingRuleConfiguration();    
        shardJdbcConfig.getTableRuleConfigs().add(getTableRule01());    
        shardJdbcConfig.getTableRuleConfigs().add(getTableRule02());    
        shardJdbcConfig.setDefaultDataSourceName("ds_0");    
        Map<String,DataSource> dataMap = new LinkedHashMap<>() ;    
        dataMap.put("ds_0",dataOneSource) ;    
        dataMap.put("ds_2",dataTwoSource) ;    
        dataMap.put("ds_3",dataThreeSource) ;    
        Properties prop = new Properties();    
        return ShardingDataSourceFactory.createDataSource(dataMap, shardJdbcConfig, new HashMap<>(), prop);    
    }    
    
    /**    
     * Shard-JDBC 分表配置    
     */    
    private static TableRuleConfiguration getTableRule01() {    
        TableRuleConfiguration result = new TableRuleConfiguration();    
        result.setLogicTable("table_one");    
        result.setActualDataNodes("ds_${2..3}.table_one_${1..5}");    
        result.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("phone", new DataSourceAlg()));    
        result.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("phone", new TableOneAlg()));    
        return result;    
    }    
    private static TableRuleConfiguration getTableRule02() {    
        TableRuleConfiguration result = new TableRuleConfiguration();    
        result.setLogicTable("table_two");    
        result.setActualDataNodes("ds_${2..3}.table_two_${1..5}");    
        result.setDatabaseShardingStrategyConfig(new StandardShardingStrategyConfiguration("phone", new DataSourceAlg()));    
        result.setTableShardingStrategyConfig(new StandardShardingStrategyConfiguration("phone", new TableTwoAlg()));    
        return result;    
    }    
}

6）、测试代码执行流程

   @RestController    
public class ShardController {    
    @Resource    
    private ShardService shardService ;    
    /**    
     * 1、建表流程    
     */    
    @RequestMapping("/createTable")    
    public String createTable (){    
        shardService.createTable();    
        return "success" ;    
    }    
    /**    
     * 2、生成表 table_one 数据    
     */    
    @RequestMapping("/insertOne")    
    public String insertOne (){    
        shardService.insertOne();    
        return "SUCCESS" ;    
    }    
    /**    
     * 3、生成表 table_two 数据    
     */    
    @RequestMapping("/insertTwo")    
    public String insertTwo (){    
        shardService.insertTwo();    
        return "SUCCESS" ;    
    }    
    /**    
     * 4、查询表 table_one 数据    
     */    
    @RequestMapping("/selectOneByPhone/{phone}")    
    public TableOne selectOneByPhone (@PathVariable("phone") String phone){    
        return shardService.selectOneByPhone(phone);    
    }    
    /**    
     * 5、查询表 table_one 数据    
     */    
    @RequestMapping("/selectTwoByPhone/{phone}")    
    public TableTwo selectTwoByPhone (@PathVariable("phone") String phone){    
        return shardService.selectTwoByPhone(phone);    
    }    
}

四、项目源码


相关 [spring boot shard] 推荐：

Spring Boot 2 整合 shard-jdbc 中间件，实现数据分库分表

- - IT瘾-dev
以字段为依据，按照一定策略，将一个库中的数据拆分到多个库中. 每个库的结构都一样；数据都不一样；. 所有库的并集是全量数据；. 以字段为依据，按照一定策略，将一个表中的数据拆分到多个表中. 每个表的结构都一样；数据都不一样；. 所有表的并集是全量数据；. 二、Shard-jdbc 中间件. 1)、Sharding-JDBC直接封装JDBC API，旧代码迁移成本几乎为零.

Spring boot传统部署

- - 企业架构 - ITeye博客
使用spring boot很方便，一个jar包就可以启动了，因为它里面内嵌了tomcat等服务器. 但是spring boot也提供了部署到独立服务器的方法. 如果你看文档的话，从jar转换为war包很简单，pom.xml的配置修改略去不讲. 只看source的修改，很简单，只要一个配置类，继承自SpringBootServletInitializer， 并覆盖configure方法.

值得使用的Spring Boot

- - ImportNew
2013年12月12日，Spring发布了4.0版本. 这个本来只是作为Java平台上的控制反转容器的库，经过将近10年的发展已经成为了一个巨无霸产品. 不过其依靠良好的分层设计，每个功能模块都能保持较好的独立性，是Java平台不可多得的好用的开源应用程序框架. Spring的4.0版本可以说是一个重大的更新，其全面支持Java8，并且对Groovy语言也有良好的支持.

Spring Boot配置多个DataSource

- - 廖雪峰的官方网站
使用Spring Boot时，默认情况下，配置 DataSource非常容易. Spring Boot会自动为我们配置好一个 DataSource. 如果在 application.yml中指定了 spring.datasource的相关配置，Spring Boot就会使用该配置创建一个 DataSource.

Spring boot executable jar/war 原理

- - ImportNew
spring boot里其实不仅可以直接以 Java -jar demo.jar的方式启动，还可以把jar/war变为一个可以执行的脚本来启动，比如./demo.jar. 把这个executable jar/war 链接到/etc/init.d下面，还可以变为Linux下的一个service. 只要在spring boot maven plugin里配置：.

Spring Boot Starter是什么？

- - 技术，永无止境
在工作中我们经常能看到各种各样的springboot starter，如spring-cloud-netflix、spring-cloud-alibaba等等. 这些starter究竟有什么作用呢. 在了解这些starter之前，我们需要先大概知道Spring MVC与Spring Boot的关系.

SPRING BOOT OAUTH2 + KEYCLOAK - service to service call

- - BlogJava-首页技术区
employee-service调用department-service，如果要按OAUTH2.0流程，只需要提供client-id和client-secrect即可. 在KEYCLOAK中引入service-account，即配置该employee-service时，取消standard-flow，同时激活service-account.

spring boot与spring batch、postgres及elasticsearch整合

- - 互联网 - ITeye博客
当系统有大量数据需要从数据库导入elasticsearch时，使用sping batch可以提高导入的效率. 这篇文章使用spring batch将数据从postgres导入elasticsearch. 本文使用spring data jest连接ES（也可以使用spring data elasticsearch连接ES）,ES版本为5.5.3.

Spring Boot使用redis做数据缓存

- - ITeye博客
SysUser.class)); //请注意这里. 3 redis服务器配置. /** *此处的dao操作使用的是spring data jpa,使用@Cacheable可以在任意方法上，*比如@Service或者@Controller的方法上 */ public interface SysUserRepo1 extends CustomRepository {.

spring boot应用启动原理分析

- - ImportNew
在spring boot里，很吸引人的一个特性是可以直接把应用打包成为一个jar/war，然后这个jar/war是可以直接启动的，不需要另外配置一个Web Server. 如果之前没有使用过spring boot可以通过下面的demo来感受下. 下面以这个工程为例，演示如何启动Spring boot项目：.