您当前的位置： 首页 >  ar

Dongguo丶

暂无认证

  • 0浏览

    0关注

    472博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

mysql分库分表sharding-jdbc

Dongguo丶 发布时间：2018-05-06 15:43:27 ，浏览量：0

前一段时间研究阿里的分库框架cobar-client，cobar-client是基于ibatis的SqlMapClientTemplate进行了一层薄薄的封装，分装成CobarSqlMapClientTemplate，在用户在CRUD的时候可以透明的进行操作，算是现在大多公司分库的一个成熟解决方案，不过现在面临的一些问题：

   ①不支持分表

   ②基于ibatis而且2013年后基本维护了，没有进行升级，所以大多公司都基于该思想进行了自己的重写

来看下当当开源的sharding-jdbc，官方网址：点击打开链接

先允许我盗一波图：

好了，看了这么多的介绍，感觉还是很高大上的，注意点有：

①对JDBC API进行了原生态的分装，这是与cobar-client不一样的地方，这就是他可以支持多个第三方ORM框架的关键

②可支持=，BETWEEN，IN等操作，说明，JDBC返回结果后，sharding进行了合并操作，这里面肯定会有性能损耗

③支持分表，这也是cobar-client不支持的地方

好了，先简单的按照官方网址的demo实践一发：

先在MySQL中建2个库

分别在这2个库中运行：

[sql]  view plain  copy
  1. CREATE TABLE IF NOT EXISTS `t_order_0` (  
  2.   `order_id` INT NOT NULL,  
  3.   `user_id`  INT NOT NULL,  
  4.   PRIMARY KEY (`order_id`)  
  5. );  
  6. CREATE TABLE IF NOT EXISTS `t_order_item_0` (  
  7.   `item_id`  INT NOT NULL,  
  8.   `order_id` INT NOT NULL,  
  9.   `user_id`  INT NOT NULL,  
  10.   PRIMARY KEY (`item_id`)  
  11. );  
  12. CREATE TABLE IF NOT EXISTS `t_order_1` (  
  13.   `order_id` INT NOT NULL,  
  14.   `user_id`  INT NOT NULL,  
  15.   PRIMARY KEY (`order_id`)  
  16. );  
  17. CREATE TABLE IF NOT EXISTS `t_order_item_1` (  
  18.   `item_id`  INT NOT NULL,  
  19.   `order_id` INT NOT NULL,  
  20.   `user_id`  INT NOT NULL,  
  21.   PRIMARY KEY (`item_id`)  
  22. );  

新建maven项目

Maven依赖的pom.xml

[html]  view plain  copy
  1.   
  2.     4.0.0  
  3.   
  4.     org.study  
  5.     sharding-jdbc  
  6.     0.0.1-SNAPSHOT  
  7.     jar  
  8.   
  9.     sharding-jdbc  
  10.     http://maven.apache.org  
  11.   
  12.       
  13.         UTF-8  
  14.         3.2.5.RELEASE  
  15.         3.2.4  
  16.       
  17.   
  18.       
  19.           
  20.             junit  
  21.             junit  
  22.             4.10  
  23.           
  24.           
  25.             com.dangdang  
  26.             sharding-jdbc-core  
  27.             1.0.0  
  28.           
  29.           
  30.             org.springframework  
  31.             spring-orm  
  32.             ${spring.version}  
  33.           
  34.           
  35.             commons-dbcp  
  36.             commons-dbcp  
  37.             1.4  
  38.           
  39.           
  40.             org.mybatis  
  41.             mybatis-spring  
  42.             1.2.2  
  43.           
  44.           
  45.             org.mybatis  
  46.             mybatis  
  47.             ${mybatis.version}  
  48.           
  49.   
  50.           
  51.             org.springframework  
  52.             spring-expression  
  53.             ${spring.version}  
  54.           
  55.           
  56.             org.springframework  
  57.             spring-aop  
  58.             ${spring.version}  
  59.           
  60.           
  61.             org.springframework  
  62.             spring-beans  
  63.             ${spring.version}  
  64.           
  65.           
  66.             org.springframework  
  67.             spring-context  
  68.             ${spring.version}  
  69.           
  70.           
  71.             org.springframework  
  72.             spring-context-support  
  73.             ${spring.version}  
  74.           
  75.           
  76.             org.springframework  
  77.             spring-test  
  78.             ${spring.version}  
  79.           
  80.           
  81.             org.springframework  
  82.             spring-tx  
  83.             ${spring.version}  
  84.           
  85.           
  86.             mysql  
  87.             mysql-connector-java  
  88.             5.1.28  
  89.           
  90.           
  91.             log4j  
  92.             log4j  
  93.             1.2.16  
  94.           
  95.           
  96.             org.slf4j  
  97.             slf4j-log4j12  
  98.             1.7.5  
  99.           
  100.       
  101.   

ShardingJdbc

[java]  view plain  copy
  1. package com.study.base;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.PreparedStatement;  
  5. import java.sql.ResultSet;  
  6. import java.sql.SQLException;  
  7. import java.util.Arrays;  
  8. import java.util.HashMap;  
  9. import java.util.Map;  
  10.   
  11. import javax.sql.DataSource;  
  12.   
  13. import org.apache.commons.dbcp.BasicDataSource;  
  14.   
  15. import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSource;  
  16. import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;  
  17. import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;  
  18. import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;  
  19. import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;  
  20. import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy;  
  21. import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;  
  22.   
  23. public class ShardingJdbc {  
  24.       
  25.     public static void main(String[] args) throws SQLException {  
  26.           
  27.         //数据源  
  28.         Map dataSourceMap = new HashMap(2);  
  29.         dataSourceMap.put("sharding_0", createDataSource("sharding_0"));  
  30.         dataSourceMap.put("sharding_1", createDataSource("sharding_1"));  
  31.           
  32.         DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap);  
  33.           
  34.         //分表分库的表，第一个参数是逻辑表名，第二个是实际表名，第三个是实际库  
  35.         TableRule orderTableRule = new TableRule("t_order", Arrays.asList("t_order_0", "t_order_1"), dataSourceRule);  
  36.         TableRule orderItemTableRule = new TableRule("t_order_item", Arrays.asList("t_order_item_0", "t_order_item_1"), dataSourceRule);  
  37.           
  38.           
  39.           
  40.         /** 
  41.          * DatabaseShardingStrategy 分库策略 
  42.          * 参数一：根据哪个字段分库 
  43.          * 参数二：分库路由函数 
  44.          * TableShardingStrategy 分表策略 
  45.          * 参数一：根据哪个字段分表 
  46.          * 参数二：分表路由函数 
  47.          *  
  48.          */  
  49.         ShardingRule shardingRule = new ShardingRule(dataSourceRule, Arrays.asList(orderTableRule, orderItemTableRule),  
  50.                 Arrays.asList(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule))),  
  51.                 new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()),  
  52.                 new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()));  
  53.           
  54.           
  55.         DataSource dataSource = new ShardingDataSource(shardingRule);  
  56.         String sql = "SELECT i.* FROM t_order o JOIN t_order_item i ON o.order_id=i.order_id WHERE o.user_id=? AND o.order_id=?";  
  57.         try (  
  58.                 Connection conn = dataSource.getConnection();  
  59.                 PreparedStatement pstmt = conn.prepareStatement(sql)) {  
  60.                 pstmt.setInt(1, 10);  
  61.                 pstmt.setInt(2, 1001);  
  62.             try (ResultSet rs = pstmt.executeQuery()) {  
  63.                 while(rs.next()) {  
  64.                     System.out.println(rs.getInt(1));  
  65.                     System.out.println(rs.getInt(2));  
  66.                     System.out.println(rs.getInt(3));  
  67.                 }  
  68.             }  
  69.         }  
  70.     }  
  71.   
  72.     /** 
  73.      * 创建数据源 
  74.      * @param dataSourceName 
  75.      * @return 
  76.      */  
  77.     private static DataSource createDataSource(String dataSourceName) {  
  78.         BasicDataSource result = new BasicDataSource();  
  79.         result.setDriverClassName(com.mysql.jdbc.Driver.class.getName());  
  80.         result.setUrl(String.format("jdbc:mysql://localhost:3306/%s", dataSourceName));  
  81.         result.setUsername("root");  
  82.         result.setPassword("");  
  83.         return result;  
  84.     }  
  85.   
  86. }  

ModuloDatabaseShardingAlgorithm

[java]  view plain  copy
  1. package com.study.base;  
  2.   
  3. import java.util.Collection;  
  4. import java.util.LinkedHashSet;  
  5.   
  6. import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;  
  7. import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;  
  8. import com.google.common.collect.Range;  
  9.   
  10. /** 
  11.  *  
  12.  * @author lyncc 
  13.  * 
  14.  */  
  15. public class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm{  
  16.   
  17.     @Override  
  18.     public String doEqualSharding(Collection availableTargetNames, ShardingValue shardingValue) {  
  19.         for (String each : availableTargetNames) {  
  20.             if (each.endsWith(shardingValue.getValue() % 2 + "")) {  
  21.                 return each;  
  22.             }  
  23.         }  
  24.         throw new IllegalArgumentException();  
  25.     }  
  26.   
  27.     @Override  
  28.     public Collection doInSharding(Collection availableTargetNames, ShardingValue shardingValue) {  
  29.         Collection result = new LinkedHashSet(availableTargetNames.size());  
  30.         for (Integer value : shardingValue.getValues()) {  
  31.             for (String tableName : availableTargetNames) {  
  32.                 if (tableName.endsWith(value % 2 + "")) {  
  33.                     result.add(tableName);  
  34.                 }  
  35.             }  
  36.         }  
  37.         return result;  
  38.     }  
  39.   
  40.     @Override  
  41.     public Collection doBetweenSharding(Collection availableTargetNames,  
  42.             ShardingValue shardingValue) {  
  43.         Collection result = new LinkedHashSet(availableTargetNames.size());  
  44.         Range range = (Range) shardingValue.getValueRange();  
  45.         for (Integer i = range.lowerEndpoint(); i       
  46.     
  47.     
  48.       
  49.       
  50.          
  51.          
  52.          
  53.            
  54.          
  55.       
  56.     
  57.       
  58.       
  59.          
  60.          
  61.          
  62.          
  63.          
  64.         
  65.          
  66.        
  67.     
  68.        
  69.        
  70.          
  71.          
  72.          
  73.          
  74.          
  75.          
  76.             
  77.          
  78.        
  79.     
  80.        
  81.        
  82.          
  83.          
  84.          
  85.          
  86.          
  87.         
  88.          
  89.        
  90.     
  91.        
  92.        
  93.           
  94.           
  95.           
  96.        
  97.     
  98.        
  99.        
  100.            
  101.            
  102.            
  103.           
  104.           
  105.        
  106.     

好了，按照官方教程说明：

我们现在user_id是10，order_id是1001

我们应该在sharding0库中的t_order_1和t_order_item_1中新建数据：

[java]  view plain  copy
  1. INSERT INTO `t_order_1` VALUES ('1001', '10');  
  2.   
  3. INSERT INTO `t_order_item_1` VALUES ('4', '1001', '2');  

好了，准备工作做完了，我们运行main函数，运行结果为：

好了，sharding-jdbc正常工作了

关注
打赏
1638062488
查看更多评论

最近更新

热门博客

[ 申请 ]友情链接：

ClashX教程 绘画宝宝 配音宝宝
立即登录/注册

微信扫码登录

0.0444s