2. 程式人生 > >dangdang的擴充套件 sharding-jdbc實現動態資料來源分庫分表分頁查詢

dangdang的擴充套件 sharding-jdbc實現動態資料來源分庫分表分頁查詢

阿新 • • 發佈：2019-01-02

dangdang的擴充套件 sharding-jdbc實現動態資料來源分庫分表分頁查詢


原文地址

dangdang的分庫分表擴充套件 sharding-jdbc

這段時間應公司需求需要分庫查詢資料，還好不是分表
研究了一下sharding-jdbc
我這裡需求有點複雜，說是資料來源不固定，隨時新增一個數據源我就想到不能配置到專案檔案中，就在業務庫中新建一個表用來儲存資料來源的資訊
表資訊


用最原始的jdbc連線資料庫的方式實現分庫查詢

封裝的DBUtil

import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy;
 

import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.jdbc.core.datasource.ShardingDataSource;
import com.maven.znly.entity.NewDataSource;
import org.apache.commons.dbcp.BasicDataSource;

import javax.sql.DataSource;
import java.
 
sql.*;
import java.util.*;

/**
 * @ClassName DBUtil
 * @Description 為了方便建立資料庫連結 只為查詢封裝
 * @Author asus
 * @Date Created by asus on 2018/11/1917:22
 * @Version 1.0
 **/
public class DBUtil {
    public static  Page getPage(List<NewDataSource> dataSourceList, String sql,PageRequest pageRequest){
        ResultSet rs=null;
        Connection conn=null;
        List<Map<String, Object>> list = new ArrayList<>();
        Integer pageNo=pageRequest.getPageNumber();//第幾頁
        Integer pageSize=pageRequest.getPageSize();//一頁幾條
        Integer count=0;
        try {
            Map<String, DataSource> dataSourceMap = createDataSourceMap(dataSourceList);
            DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap);
            TableRule[] tableRules=new TableRule[dataSourceList.size()];
            for (int i = 0; i <dataSourceList.size() ; i++) {
                TableRule tableRule = TableRule.builder("device_log").actualTables(Arrays.asList("device_log")).dataSourceRule(dataSourceRule).build();
                tableRules[i]=tableRule;
            }
            List<TableRule> newTableRule=Arrays.asList(tableRules);
            //TableRule orderTableRule = TableRule.builder("device_log").actualTables(Arrays.asList("device_log")).dataSourceRule(dataSourceRule).build();
            ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(dataSourceRule).tableRules(newTableRule)
                    .databaseShardingStrategy(new DatabaseShardingStrategy("create_time", new ModuloDatabaseShardingAlgorithm()))
                    .tableShardingStrategy(new TableShardingStrategy("create_time", new ModuloTableShardingAlgorithm())).build();
            DataSource dataSource = new ShardingDataSource(shardingRule);
            //2.獲得資料庫的連線
            conn=dataSource.getConnection();
            //構造一個statement物件來執行sql語句：主要有Statement，PreparedStatement，CallableStatement三種例項來實現
//            stmt=conn.createStatement();
            //獲得總個數
            String countSql = "select count(*) totalCount from (" + sql + " ) cout";
            PreparedStatement pstmt = conn.prepareStatement(countSql);
            rs=pstmt.executeQuery();
            count=rs.getInt("totalCount");
            StringBuilder sb = new StringBuilder("SELECT * FROM ");
            sb.append("( ");
            sb.append(sql);
            sb.append(") A limit " + ( pageNo* pageSize) + "," +  pageSize + "");
            PreparedStatement pstmts = conn.prepareStatement(sb.toString());
            rs=pstmts.executeQuery();
            //PreparedStatement pstmt = conn.prepareStatement(sql);
            //執行sql並返還結束 ；

            ResultSetMetaData md = rs.getMetaData(); //獲得結果集結構資訊,元資料
            int columnCount = md.getColumnCount();   //獲得列數
            while (rs.next()) {
                Map<String,Object> rowData = new HashMap<>();
                for (int i = 1; i <= columnCount; i++) {
                    rowData.put(md.getColumnName(i), rs.getObject(i));
                }
                list.add(rowData);
            }
            if(rs !=null){//11.關閉記錄集
                try{
                    rs.close();
                } catch (SQLException e){
                    e.printStackTrace();
                }
            }
            if(conn !=null){//13.關閉連線 （記住一定要先關閉前面的11.12.然後在關閉連線，就像關門一樣，先關裡面的，最後關最外面的）
                try{
                    conn.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return new MyPage(pageRequest, list, count);
    }
    //將獲得的資料庫與java的連結返回（返回的型別為Connection）
    public static List<Map<String,Object>> getConnection(List<NewDataSource> dataSourceList, String sql){
        ResultSet rs=null;
        Connection conn=null;
        List<Map<String, Object>> list = new ArrayList<>();
        Integer count=0;
        try {
            Map<String, DataSource> dataSourceMap = createDataSourceMap(dataSourceList);
            DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap);
            TableRule[] tableRules=new TableRule[dataSourceList.size()];
            for (int i = 0; i <dataSourceList.size() ; i++) {
                TableRule tableRule = TableRule.builder("device_log").actualTables(Arrays.asList("device_log")).dataSourceRule(dataSourceRule).build();
                tableRules[i]=tableRule;
            }
            List<TableRule> newTableRule=Arrays.asList(tableRules);
            //TableRule orderTableRule = TableRule.builder("device_log").actualTables(Arrays.asList("device_log")).dataSourceRule(dataSourceRule).build();
            ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(dataSourceRule).tableRules(newTableRule)
                    .databaseShardingStrategy(new DatabaseShardingStrategy("create_time", new ModuloDatabaseShardingAlgorithm()))
                    .tableShardingStrategy(new TableShardingStrategy("create_time", new ModuloTableShardingAlgorithm())).build();
            DataSource dataSource = new ShardingDataSource(shardingRule);
            //2.獲得資料庫的連線
            conn=dataSource.getConnection();
            PreparedStatement pstmt = conn.prepareStatement(sql);
            rs=pstmt.executeQuery();
            ResultSetMetaData md = rs.getMetaData(); //獲得結果集結構資訊,元資料
            int columnCount = md.getColumnCount();   //獲得列數
            while (rs.next()) {
                Map<String,Object> rowData = new HashMap<>();
                for (int i = 1; i <= columnCount; i++) {
                    rowData.put(md.getColumnName(i), rs.getObject(i));
                }
                list.add(rowData);
            }
            if(rs !=null){//11.關閉記錄集
                try{
                    rs.close();
                } catch (SQLException e){
                    e.printStackTrace();
                }
            }
            if(conn !=null){//13.關閉連線 （記住一定要先關閉前面的11.12.然後在關閉連線，就像關門一樣，先關裡面的，最後關最外面的）
                try{
                    conn.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return list;
    }
    private static DataSource createDataSource(NewDataSource dataSource) {
        BasicDataSource result = new BasicDataSource();
        result.setDriverClassName("com.mysql.jdbc.Driver");
        String URL="jdbc:mysql://"+dataSource.getDataIp()+":"+dataSource.getDataCode()+"/"+dataSource.getDataDbName()+"?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8";
        result.setUrl(URL);
        result.setUsername(dataSource.getDataUserName());
        result.setPassword(dataSource.getDataUserPassword());
        return result;
    }
    private static Map<String, DataSource> createDataSourceMap(List<NewDataSource> dataSourceList) {
        Map<String, DataSource> mapList = new HashMap<>();
        for (int i = 0; i < dataSourceList.size(); i++) {
            NewDataSource dataSource=dataSourceList.get(i);
            DataSource dataSource1=createDataSource(dataSource);
            mapList.put(dataSource.getDataDbName(),dataSource1);
        }
        return mapList;
    }
    static class MyPage implements Page {
        private PageRequest pageRequest;
        private List<Map<String, Object>> objectList;

        private int total;

        public MyPage(PageRequest pageRequest, List<Map<String,Object>> objectList, int total) {
            this.pageRequest = pageRequest;
            this.objectList = objectList;
            this.total = total;
        }

        @Override
        public int getNumber() {
            return pageRequest.getPageNumber();
        }

        @Override
        public int getSize() {
            return pageRequest.getPageSize();
        }

        @Override
        public int getTotalPages() {

            if (total % pageRequest.getPageSize() == 0) {
                return total/pageRequest.getPageSize();
            } else {
                return total/pageRequest.getPageSize()+1;
            }


        }

        @Override
        public int getNumberOfElements() {
            return 0;
        }

        @Override
        public long getTotalElements() {
            return this.total;
        }

        @Override
        public Page map(Converter converter) {
            return null;
        }


        @Override
        public Iterator<Map<String,Object>> iterator() {
            return objectList.iterator();
        }

        @Override
        public List<Map<String,Object>> getContent() {
            return objectList;
        }



        @Override
        public boolean hasContent() {
            return objectList!=null&&objectList.size()>0;
        }

        @Override
        public Sort getSort() {
            return null;
        }

        @Override
        public boolean isFirst() {
            return pageRequest.getPageNumber() == 0;
        }

        @Override
        public boolean isLast() {
            return pageRequest.getPageNumber()==getTotalPages()-1;
        }

        @Override
        public boolean hasNext() {
            return pageRequest.getPageNumber()<getTotalPages()-1;
        }

        @Override
        public boolean hasPrevious() {
            return pageRequest.getPageNumber() >0;
        }

        @Override
        public Pageable nextPageable() {
            return null;
        }

        @Override
        public Pageable previousPageable() {
            return null;
        }
    }

}

因為我需要分頁所以這裡就再次封裝一個

ModuloDatabaseShardingAlgorithm

import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;
import com.google.common.collect.Range;

import java.util.Collection;
import java.util.LinkedHashSet;

/**
 * @ClassName ModuloDatabaseShardingAlgorithm
 * @Description TODO
 * @Author asus
 * @Date Created by asus on 2018/12/1012:10
 * @Version 1.0
 **/
public class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Integer>{
    @Override
    public String doEqualSharding(Collection<String> collection, ShardingValue<Integer> shardingValue) {
        for (String each : collection) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public Collection<String> doInSharding(Collection<String> collection, ShardingValue<Integer> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(collection.size( 
 

            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
dangdang的擴充套件 sharding-jdbc實現動態資料來源分庫分表分頁查詢

     
  
 
  
  
 
 
  dangdang的擴充套件 sharding-jdbc實現動態資料來源分庫分表分頁查詢
  
   dangdang的分庫分表擴充套件 sharding-jdbc
   封裝的DBUtil
   ModuloDatabaseShardingAlgorithm
   Modulo 



  
 

    


    
    
sharding-JDBC 實現分庫

     
 names   core   pub   doc   odata   需求   object   blog   lib   需求
按照業務線Id分庫，每個業務線一個庫。
sql
-- 建立112業務線庫
create database sharding_112 ;

-- 在112業務庫裏建立 t_order 



  
 

    


    
    
Spring Boot入門教程(四十四): Sharding-JDBC+JPA|MyBatis+Druid分庫分表實現

     
 
							
							
							一：資料庫分片方案


客戶端代理： 分片邏輯在應用端，封裝在jar包中，通過修改或者封裝JDBC層來實現。 噹噹網的 Sharding-JDBC 、阿里的TDDL是兩種比較常用的實現。
中介軟體代理： 在應用和資料中間加了一個代理層。分片邏輯統一維護在中介軟體 



  
 

    


    
    
應對sharding-jdbc結合mybatis實現分庫分表功能  分表的聯合查詢採用將mysql的資料同步到elasticsearch進行篩選

     
 
                應對sharding-jdbc結合mybatis實現分庫分表功能  分表的聯合查詢採用將mysql的資料同步到elasticsearch進行篩選



安裝操作指南：（1）、（2）

其中windows目錄展示如下：

版本控制：1. 需要jdk:1.8（1.8.0_60）
 



  
 

    


    
    
【十七】Spring Boot 之 多資料來源（擴充套件AbstractRoutingDataSource類，實現動態資料來源。使用AOP註解動態切換資料來源）

     
 
                在一個專案中操作多個不同的資料來源時，需要用到多資料來源的配置。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0 



  
 

    


    
    
springboot + mybatis + mysql + sharding-jdbc 實現分庫分表

     
 
                                        
                                                
配置檔案 
mybatis.config-locations=classpath:mybatis/mybatis-config. 



  
 

    


    
    
sharding-JDBC 實現讀寫分離

     
 aso   engine   lec   bus   manage   均衡   map   如果   use   需求

一主兩從，做讀寫分離。
多個從庫之間實現負載均衡。
可手動強制部分讀請求到主庫上。(因為主從同步有延遲，對實時性要求高的系統，可以將部分讀請求也走主庫)

本次不討論 MySQL如何配置 



  
 

    


    
    
利用Sharding-Jdbc實現分表

     
  
 
 利用Sharding-Jdbc實現分表 
 由 匿名 (未驗證) 提交於 2018-07-25 15:50:57 
 
  132 次瀏覽 
 
 閒來無事，喜歡研究一些自己未接觸過的技術~ 
 看到了噹噹開源的Sharding-JDBC元件，它可以在幾乎不修改程式碼的情況下完成 



  
 

    


    
    
解析配置檔案自動裝配 DataSource + AbstractRoutingDataSource + AOP 實現動態資料來源 上：原理解析，解析資料來源

     
  
 
  
  
 spring boot 自動裝配會通過 spring.datasource.*為我們自動裝配資料來源，所以想要動態的切換資料來源，第一件事是配置資料來源，其次是怎麼切換？最後何時切換？ 
 原理解析（使用 AbstractRoutingDataSource 實現） 
 spring-jd 



  
 

    


    
    
解析配置檔案自動裝配 DataSource + AbstractRoutingDataSource + AOP 實現動態資料來源 下：配置動態資料來源，AOP 進行使用

     
  
 
  
  
 上篇文章中已經藉助 DynamicDataSourceBuilder 類從配置檔案中解析得到了預設資料來源和動態資料來源，接下來需要配置動態資料來源的“本體”，並藉助 AOP 動態的切換資料來源。 
 配置動態資料來源 
 AbstractRoutingDataSource 實現了 In 



  
 

    


    
    
Spring Boot + Mybatis 實現動態資料來源

     
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" 



  
 

    


    
    
藉助sharding-jdbc實現資料分片

     
  
  
  
 1、引入依賴： 
 <!-- 引入sharding-jdbc -->
        <dependency>
            <groupId>com.dangdang</groupId>
            <artifa 



  
 

    


    
    
Springboot中利用aop和註解實現動態資料來源

     
 
							
							
							本篇文章將介紹如何使用AOP和註解來實現動態資料來源． 




使用ThreadLocal儲存當前執行緒使用的資料來源的key



import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 



  
 

    


    
    
使用Spring AOP結合自定義Java註解實現動態資料來源設定

     
 
                
1、定義Java註解

@Retention(RetentionPolicy.RUNTIME)
// 註解將要寫到型別（Class/Interface）還是其它元素（Method等）上，支援package、type、method、field等，一般只會配置一個@Target 



  
 

    


    
    
利用AbstractRoutingDataSource實現動態資料來源切換 （一、Spring+Hibernate）

     
 
package com.hoo.framework.spring.interceptor;

import java.lang.reflect.Proxy;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalli 



  
 

    


    
    
springboot2.x 整合mybatis-plus sharding-jdbc實現讀寫分離

     
 
							
							
							首先，匯入依賴，下面只展示核心依賴

     <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>my 



  
 

    


    
    
Spring實現動態資料來源，支援動態新增、刪除和設定權重及讀寫分離

     
 
                

當專案慢慢變大，訪問量也慢慢變大的時候，就難免的要使用多個數據源和設定讀寫分離了。

在開題之前先說明下，因為專案多是使用Spring，因此以下說到某些操作可能會依賴於Spring。

在我經歷過的專案中，見過比較多的讀寫分離處理方式，主要分為兩步：
1、對於開發人員，要 



  
 

    


    
    
AOP切面實現動態資料來源（含程式碼）

     
 
							
							
							在service同級目錄增加一個folder ,將以下三個官方提供的類添至其中： 
1  DatasourceAspect.java 



import org.apache.commons.lang3.StringUtils;
import org.aspe 



  
 

    


    
    
spring動態資料來源分庫

     
 
                
web專案的瓶頸：服務端（伺服器壓力+資料庫壓力）
伺服器解決辦法：程式優化，提高程式碼執行率
資料庫壓力：快取、分表、分庫
1，分表：適合針對單個的表資料量比較大的情況，分成多張表儲存，比如系統日誌
例如：
系統日誌表以這樣的形式儲存，每個月一張表。logs_2012_1 



  
 

    


    
    
SSH實現動態資料來源切換

     
 
                
目錄：

SSH的整合：
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns