SpringBoot使用sharding-jdbc分庫分表

時間  2019-11-13
標籤 springboot 使用 sharding jdbc 分庫 分表 欄目 Spring 简体版
原文   原文鏈接

1、前言

  通常來講，隨着業務的發展數據庫的數據量會愈來愈多，當單表數據超過上千萬時執行一些查詢sql語句就會遇到性能問題。一開始能夠用主從複製讀寫分離來減輕db壓力，可是後面仍是要用分庫分表把數據進行水平拆分和垂直拆分。
  實現分庫分表目前我知道的方式有兩種，第一種是使用mycat中間件實現，第二種是使用sharding-jdbc實現。相比較而言，sharding-jdbc引入一個jar包便可使用更輕量級一些，它們之間的優缺點這裏也不作比較，有興趣的能夠本身搜索相關資料。
  不清楚分庫分表原理的能夠參考這篇博客，數據庫之分庫分表-垂直？水平？html

2、使用噹噹網的sharding-jdbc分庫分表

2.1新建SpringBoot項目

新建項目sharding-jdbc-first，並在pom文件添加以下內容:java

  1. <parent> 
  2. <groupId>org.springframework.boot</groupId> 
  3. <artifactId>spring-boot-starter-parent</artifactId> 
  4. <version>1.5.16.RELEASE</version> 
  5. <relativePath/> <!-- lookup parent from repository --> 
  6. </parent> 
  7.  
  8. <properties> 
  9. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 
  10. <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> 
  11. <java.version>1.8</java.version> 
  12. </properties> 
  13.  
  14. <dependencies> 
  15. <dependency> 
  16. <groupId>org.springframework.boot</groupId> 
  17. <artifactId>spring-boot-starter-data-jpa</artifactId> 
  18. </dependency> 
  19. <dependency> 
  20. <groupId>org.springframework.boot</groupId> 
  21. <artifactId>spring-boot-starter-web</artifactId> 
  22. </dependency> 
  23.  
  24. <dependency> 
  25. <groupId>mysql</groupId> 
  26. <artifactId>mysql-connector-java</artifactId> 
  27. <scope>runtime</scope> 
  28. </dependency> 
  29. <dependency> 
  30. <groupId>org.springframework.boot</groupId> 
  31. <artifactId>spring-boot-starter-test</artifactId> 
  32. <scope>test</scope> 
  33. </dependency> 
  34. <dependency> 
  35. <groupId>com.dangdang</groupId> 
  36. <artifactId>sharding-jdbc-core</artifactId> 
  37. <version>1.4.2</version> 
  38. </dependency> 
  39. <dependency> 
  40. <groupId>com.alibaba</groupId> 
  41. <artifactId>druid</artifactId> 
  42. <version>1.0.12</version> 
  43. </dependency> 
  44.  
  45. <dependency> 
  46. <groupId>com.dangdang</groupId> 
  47. <artifactId>sharding-jdbc-self-id-generator</artifactId> 
  48. <version>1.4.2</version> 
  49. </dependency> 
  50.  
  51.  
  52. </dependencies> 

目前好像不支持SpringBoot2.0以上的版本。node

2.2編寫實體類及建庫建表

目標：
db0
├── t_order_0 user_id爲偶數 order_id爲偶數
├── t_order_1 user_id爲偶數 order_id爲奇數
db1
├── t_order_0 user_id爲奇數 order_id爲偶數
├── t_order_1 user_id爲奇數 order_id爲奇數mysql

  1. 建立兩個數據庫 ds_0 和 ds_1，編碼類型UTF-8。
  2. 每一個庫分表建立兩個表t_order_0和t_order_1,sql語句以下：

    DROP TABLE IF EXISTS t_order_0;
    CREATE TABLE t_order_0 (
    order_id bigint(20) NOT NULL,
    user_id bigint(20) NOT NULL,
    PRIMARY KEY (order_id)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
  3. 新建類Order，代碼以下
  1. package cn.sp.bean; 
  2.  
  3. import javax.persistence.Entity; 
  4. import javax.persistence.Id; 
  5. import javax.persistence.Table; 
  6.  
  7. /** 
  8. * Created by 2YSP on 2018/9/23. 
  9. */ 
  10. @Entity 
  11. @Table(name="t_order") 
  12. public class Order { 
  13. @Id 
  14. private Long orderId; 
  15.  
  16. private Long userId; 
  17.  
  18. public Long getOrderId() { 
  19. return orderId; 
  20. } 
  21.  
  22. public void setOrderId(Long orderId) { 
  23. this.orderId = orderId; 
  24. } 
  25.  
  26. public Long getUserId() { 
  27. return userId; 
  28. } 
  29.  
  30. public void setUserId(Long userId) { 
  31. this.userId = userId; 
  32. } 
  33. } 
  34.  

這裏須要注意 @Id註解不要導錯包，以前我就遇到過這個問題。
4.配置文件application.ymlgit

  1. server: 
  2. port: 8000 
  3. spring: 
  4. jpa: 
  5. database: mysql 
  6. show-sql: true 
  7. hibernate: 
  8. ## 本身建表 
  9. ddl-auto: none 
  10. application: 
  11. name: sharding-jdbc-first 

這裏要注意的是spring-data-jpa默認會本身建表，這裏咱們要手動創建，因此須要將ddl-auto屬性設置爲none。github

2.3自定義分庫分表算法

1.分庫算法類須要實現SingleKeyDatabaseShardingAlgorithm<T>接口，這是一個泛型接口，T表明分庫依據的字段的類型，好比咱們根據userId%2來分庫，userId是Long型的，這裏的T就是Long。web

  1. public class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> { 
  2. @Override 
  3. public String doEqualSharding(Collection<String> availableDatabaseNames, ShardingValue<Long> shardingValue) { 
  4. for(String databaseName : availableDatabaseNames){ 
  5. if (databaseName.endsWith(shardingValue.getValue() % 2 + "")){ 
  6.  
  7. return databaseName; 
  8. } 
  9. } 
  10. throw new IllegalArgumentException(); 
  11. } 
  12.  
  13. @Override 
  14. public Collection<String> doInSharding(Collection<String> availableDatabaseNames, ShardingValue<Long> shardingValue) { 
  15. Collection<String> result = new LinkedHashSet<>(availableDatabaseNames.size()); 
  16. for(Long value : shardingValue.getValues()){ 
  17. for(String name : availableDatabaseNames){ 
  18. if (name.endsWith(value%2 + "")){ 
  19. result.add(name); 
  20. } 
  21. } 
  22. } 
  23. return result; 
  24. } 
  25.  
  26. @Override 
  27. public Collection<String> doBetweenSharding(Collection<String> availableDatabaseNames, ShardingValue<Long> shardingValue) { 
  28. Collection<String> result = new LinkedHashSet<>(availableDatabaseNames.size()); 
  29. Range<Long> range = shardingValue.getValueRange(); 
  30. for(Long i = range.lowerEndpoint() ; i < range.upperEndpoint();i++){ 
  31. for(String each : availableDatabaseNames){ 
  32. if (each.endsWith( i % 2+"")){ 
  33. result.add(each); 
  34. } 
  35. } 
  36. } 
  37.  
  38. return result; 
  39. } 
  40. } 
  41.  

2.分表算法類須要實現SingleKeyTableShardingAlgorithm<T>接口。算法

  1. /** 
  2. * 表分片算法 
  3. * Created by 2YSP on 2018/9/23. 
  4. */ 
  5. public class ModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> { 
  6.  
  7. /** 
  8. * select * from t_order from t_order where order_id = 11 
  9. * └── SELECT * FROM t_order_1 WHERE order_id = 11 
  10. * select * from t_order from t_order where order_id = 44 
  11. * └── SELECT * FROM t_order_0 WHERE order_id = 44 
  12. */ 
  13. @Override 
  14. public String doEqualSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) { 
  15. for (String tableName : tableNames) { 
  16. if (tableName.endsWith(shardingValue.getValue() % 2 + "")) { 
  17. return tableName; 
  18. } 
  19. } 
  20.  
  21. throw new IllegalArgumentException(); 
  22. } 
  23.  
  24. /** 
  25. * select * from t_order from t_order where order_id in (11,44) 
  26. * ├── SELECT * FROM t_order_0 WHERE order_id IN (11,44) 
  27. * └── SELECT * FROM t_order_1 WHERE order_id IN (11,44) 
  28. * select * from t_order from t_order where order_id in (11,13,15) 
  29. * └── SELECT * FROM t_order_1 WHERE order_id IN (11,13,15) 
  30. * select * from t_order from t_order where order_id in (22,24,26) 
  31. * └──SELECT * FROM t_order_0 WHERE order_id IN (22,24,26) 
  32. */ 
  33. @Override 
  34. public Collection<String> doInSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) { 
  35. Collection<String> result = new LinkedHashSet<>(tableNames.size()); 
  36. for (Long value : shardingValue.getValues()) { 
  37. for (String table : tableNames) { 
  38. if (table.endsWith(value % 2 + "")) { 
  39. result.add(table); 
  40. } 
  41. } 
  42. } 
  43. return result; 
  44. } 
  45.  
  46. /** 
  47. * select * from t_order from t_order where order_id between 10 and 20 
  48. * ├── SELECT * FROM t_order_0 WHERE order_id BETWEEN 10 AND 20 
  49. * └── SELECT * FROM t_order_1 WHERE order_id BETWEEN 10 AND 20 
  50. */ 
  51. @Override 
  52. public Collection<String> doBetweenSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) { 
  53. Collection<String> result = new LinkedHashSet<>(tableNames.size()); 
  54. Range<Long> range = shardingValue.getValueRange(); 
  55. for (Long i = range.lowerEndpoint(); i < range.upperEndpoint(); i++) { 
  56. for (String each : tableNames) { 
  57. if (each.endsWith(i % 2 + "")) { 
  58. result.add(each); 
  59. } 
  60. } 
  61. } 
  62.  
  63. return result; 
  64. } 
  65. } 

2.4配置數據源

數據源配置類DataSourceConfigspring

  1. @Configuration 
  2. public class DataSourceConfig { 
  3. @Bean 
  4. public IdGenerator getIdGenerator(){ 
  5. return new CommonSelfIdGenerator(); 
  6. } 
  7.  
  8. @Bean 
  9. public DataSource getDataSource() { 
  10. return buildDataSource(); 
  11. } 
  12.  
  13.  
  14. private DataSource buildDataSource() { 
  15. //1.設置分庫映射 
  16. Map<String, DataSource> dataSourceMap = new HashMap<>(2); 
  17. dataSourceMap.put("ds_0", createDataSource("ds_0")); 
  18. dataSourceMap.put("ds_1", createDataSource("ds_1")); 
  19. //設置默認db爲ds_0，也就是爲那些沒有配置分庫分表策略的指定的默認庫 
  20. //若是隻有一個庫，也就是不須要分庫的話，map裏只放一個映射就好了，只有一個庫時不須要指定默認庫， 
  21. // 但2個及以上時必須指定默認庫，不然那些沒有配置策略的表將沒法操做數據 
  22. DataSourceRule rule = new DataSourceRule(dataSourceMap, "ds_0"); 
  23.  
  24. //2.設置分表映射，將t_order_0和t_order_1兩個實際的表映射到t_order邏輯表 
  25. TableRule orderTableRule = TableRule.builder("t_order") 
  26. .actualTables(Arrays.asList("t_order_0", "t_order_1")) 
  27. .dataSourceRule(rule) 
  28. .build(); 
  29. //3.具體的分庫分表策略 
  30. ShardingRule shardingRule = ShardingRule.builder() 
  31. .dataSourceRule(rule) 
  32. .tableRules(Arrays.asList(orderTableRule)) 
  33. .databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm())) 
  34. .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm())) 
  35. .build(); 
  36.  
  37. DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule); 
  38. return dataSource; 
  39. } 
  40.  
  41. private static DataSource createDataSource(String dataSourceName) { 
  42. //使用druid鏈接數據庫 
  43. DruidDataSource druidDataSource = new DruidDataSource(); 
  44. druidDataSource.setDriverClassName("com.mysql.jdbc.Driver"); 
  45. druidDataSource.setUrl(String.format("jdbc:mysql://localhost:3306/%s?characterEncoding=utf-8", dataSourceName)); 
  46. druidDataSource.setUsername("root"); 
  47. druidDataSource.setPassword("1234"); 
  48. return druidDataSource; 
  49. } 
  50. } 

這裏的一些配置信息url,username,password等能夠優化下，從配置文件讀取。sql

2.5測試

1.新建OrderRepository

  1. public interface OrderRepository extends CrudRepository<Order,Long> { 
  2.  
  3. } 

2.controller層

  1. /** 
  2. * Created by 2YSP on 2018/9/23. 
  3. */ 
  4. @RestController 
  5. @RequestMapping("/order") 
  6. public class OrderController { 
  7.  
  8. @Autowired 
  9. private OrderRepository repository; 
  10.  
  11. @Autowired 
  12. private IdGenerator idGenerator; 
  13.  
  14. @RequestMapping("/add") 
  15. public String add(){ 
  16. for(int i=0;i<10;i++){ 
  17. Order order = new Order(); 
  18. order.setOrderId((long) i); 
  19. order.setUserId((long) i); 
  20. repository.save(order); 
  21. } 
  22. // Order order = new Order(); 
  23. // order.setUserId(1L); 
  24. // order.setOrderId(idGenerator.generateId().longValue()); 
  25. // repository.save(order); 
  26. return "success"; 
  27. } 
  28.  
  29. @RequestMapping("/query") 
  30. public List<Order> queryAll(){ 
  31. List<Order> orders = (List<Order>) repository.findAll(); 
  32. return orders; 
  33. } 
  34. } 
  35.  

3.訪問http://localhost:8080/order/add，便可在數據庫ds_0,ds_1發現多了一些數據。
訪問http://localhost:8080/order/query能夠查詢剛剛添加的訂單數據。
完整代碼地址:https://github.com/2YSP/sharding-jdbc-first

3、使用sharding-jdbc-spring-boot-starter分庫分表

3.1引入依賴

由於個人SpringBoot是2.X版本，因此引入最新的依賴。由於目前的maven倉庫（包括阿里倉庫）尚未對應的jar，須要本身去github下載源代碼，而後執行 mvn clean install打包到本地maven倉庫。

  1. <dependency> 
  2. <groupId>io.shardingsphere</groupId> 
  3. <artifactId>sharding-jdbc-spring-boot-starter</artifactId> 
  4. <version>3.0.0.M4</version> 
  5. </dependency> 

3.2SpringBoot配置

在application.properties文件添加以下內容：

##########分庫分表配置##########
sharding.jdbc.datasource.names=ds0,ds1
## 這裏使用阿里的Druid鏈接池
sharding.jdbc.datasource.ds0.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds0.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds0.url=jdbc:mysql://localhost:3306/ds_0
sharding.jdbc.datasource.ds0.username=root
sharding.jdbc.datasource.ds0.password=1234

sharding.jdbc.datasource.ds1.type=com.alibaba.druid.pool.DruidDataSource
sharding.jdbc.datasource.ds1.driver-class-name=com.mysql.jdbc.Driver
sharding.jdbc.datasource.ds1.url=jdbc:mysql://localhost:3306/ds_1
sharding.jdbc.datasource.ds1.username=root
sharding.jdbc.datasource.ds1.password=1234

##默認的分庫策略：user_id爲奇數-->數據庫ds_1,user_id爲偶數-->數據庫ds_0
sharding.jdbc.config.sharding.default-database-strategy.inline.sharding-column=user_id
sharding.jdbc.config.sharding.default-database-strategy.inline.algorithm-expression=ds$->{user_id % 2}
## 這裏的t_order是邏輯表，由數據源名 + 表名組成，以小數點分隔。多個表以逗號分隔，支持inline表達式
sharding.jdbc.config.sharding.tables.t_order.actual-data-nodes=ds$->{0..1}.t_order_$->{0..1}
## 行表達式分片策略
sharding.jdbc.config.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
sharding.jdbc.config.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_$->{order_id % 2}

這裏還能夠用Java配置，Yaml配置來代替，感興趣的話能夠訪問github地址瞭解更多，上面有對應的中文文檔。

4、總結

在分庫分表的時候要根據實際狀況來決定根據哪一個字段來分（不必定都是主鍵），須要分幾個庫幾張表。 分庫分表後遇到的問題： 1.不能像之前同樣使用數據庫自增的主鍵了，會出現主鍵重複的問題（可使用分佈式主鍵來代替）。 2.不支持一些關鍵字。 3.在作一些統計查詢的時候也更加困難，那時候可能須要引入搜索引擎ES了。 4.以前覺得sharding-jdbc不支持分頁操做，那天測試了下居然能夠。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程