2. 程式人生 > >Springboot使用sharding進行分庫分表

Springboot使用sharding進行分庫分表

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

pom.xml檔案加入sharing引用和druid引用

<dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>1.5.4</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.12</version>
        </dependency>

application-data.properties中配置資料庫資訊

spring.jpa.show-sql=true
spring.jpa.generate-ddl=false

other.datasource.driver-class-name = com.mysql.jdbc.Driver
other.datasource.url= jdbc:mysql://192.168.12.12:3306/business?useUnicode=yes&characterEncoding=UTF-8&useSSL=false
other.datasource.username = root
other.datasource.password = root

TradeStationYear.datasource.driver-class-name = com.mysql.jdbc.Driver
TradeStationYear.datasource.url= jdbc:mysql://192.168.12.12:3306/suqirong?useUnicode=yes&characterEncoding=UTF-8&useSSL=false
TradeStationYear.datasource.username = root
TradeStationYear.datasource.password = root
TradeStationYear.tables = yl_2_trade_2017,yl_2_trade_2018

在application.properties中加data的配置

spring.profiles.active=data

建domain

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

import io.swagger.annotations.ApiModelProperty;

@Entity
@Table(name = "trade_station_year”)
public class TradeStationYear implements Serializable {

    /**
     * 
     */
    private static final long serialVersionUID = 6891164356262972567L;

    @Id
    @Column(name = "trade_sn", length = 24)
    @ApiModelProperty(value = "裝置交易流水號")
    private String tradeSN;

    @Column(name = "card_id", length = 20)
    @ApiModelProperty(value = "卡號")
    private String cardId;

    @Column(name = "trade_address", length = 10)
    @ApiModelProperty(value = "運營點")
    private String stationAddress;

    @Column(name = "trade_date")
    @ApiModelProperty(value = "交易時間")
    private Date tradeDate;

    public TradeStationYear() {
        super();
    }

    public String getTradeSN() {
        return tradeSN;
    }

    public void setTradeSN(String tradeSN) {
        this.tradeSN = tradeSN;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public String getStationAddress() {
        return stationAddress;
    }

    public void setStationAddress(String stationAddress) {
        this.stationAddress = stationAddress;
    }

    public Date getTradeDate() {
        return tradeDate;
    }

    public void setTradeDate(Date tradeDate) {
        this.tradeDate = tradeDate;
    }

}
 

repository類

public interface DataEntryRepositoryStationYear extends JpaRepository<TradeStationYear, Long> {

    Page<TradeStationYear> findAll(Specification<TradeStationYear> specification, Pageable pageable);

 }

分庫分表的配置

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = TSSUtil.ENTITY_MANAGER_FACTORY_1, transactionManagerRef = TSSUtil.TRANSACTION_MANAGER_1, basePackages = {
        TSSUtil.BASE_PACKAGES_1 })
public class DataSourceConfigTradeStationYear {

    // 資料庫配置
    @Value("${" + TSSUtil.LABEL_1 + ".datasource.driver-class-name}")
    private String driver;
    @Value("${" + TSSUtil.LABEL_1 + ".datasource.url}")
    private String url;
    @Value("${" + TSSUtil.LABEL_1 + ".datasource.username}")
    private String username;
    @Value("${" + TSSUtil.LABEL_1 + ".datasource.password}")
    private String password;
    @Value("${" + TSSUtil.LABEL_1 + ".tables}")
    private String tables;// 分表名列表，用英文逗號分隔

    @Autowired
    private JpaProperties jpaProperties;

    @Bean(TSSUtil.TRANSACTION_MANAGER_1)
    public PlatformTransactionManager otherTransactionManager(
            @Qualifier(TSSUtil.ENTITY_MANAGER_FACTORY_1) EntityManagerFactory otherEntityManagerFactory) {
        return new JpaTransactionManager(otherEntityManagerFactory);
    }

    @Bean(TSSUtil.ENTITY_MANAGER_FACTORY_1)
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(EntityManagerFactoryBuilder builder,
            @Qualifier(TSSUtil.DATA_SOURCE_1) DataSource dataSource) {
        return builder.dataSource(dataSource).packages(TSSUtil.PACKAGES_1)
                .properties(jpaProperties.getHibernateProperties(dataSource)).persistenceUnit(TSSUtil.LOGICAL_TABLE_1)
                .build();
    }

    @Bean(TSSUtil.DATA_SOURCE_1)
    public DataSource getDataSource() {

     // 設定分庫對映
        Map<String, DataSource> dataSourceMap = new HashMap<>(2);
        dataSourceMap.put("ds_0", createDataSource());

        //如果是兩個資料庫

        /**

        dataSourceMap.put("ds_0", createDataSource());
        dataSourceMap.put("ds_1", createDataSource();

       */

        //設定預設資料庫
        DataSourceRule dataSourceRule = new DataSourceRule(dataSourceMap);

        // 設定分表對映
        TableRule orderTableRule = TableRule.builder(TSSUtil.LOGICAL_TABLE_1) //邏輯表名。實體類的表名
                .actualTables(Arrays.asList(tables.trim().split(","))).dataSourceRule(dataSourceRule) //tables.trim().split(","))資料庫的表名
                .build();

        /*

        // 設定分表對映
        TableRule orderTableRule = TableRule.builder(“trade_station_year”)  
                .actualTables(Arrays.asList(“yl_2_trade_2017”,"yl_2trade_2018")).dataSourceRule(dataSourceRule) 
                .build();

          */

        // 設定分表策略，按什麼規則來分
        ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(dataSourceRule)
                .tableRules(Arrays.asList(orderTableRule))
                .tableShardingStrategy(new TableShardingStrategy(

         //按這兩個欄位來分TSSUtil.COLUMN_OF_TABLE_SHARDING_1_1, TSSUtil.COLUMN_OF_TABLE_SHARDING_1_2
                        Arrays.asList(TSSUtil.COLUMN_OF_TABLE_SHARDING_1_1, TSSUtil.COLUMN_OF_TABLE_SHARDING_1_2),
                        new StationAndYearTableShardingAlgorithm(TSSUtil.COLUMN_OF_TABLE_SHARDING_1_1,
                                TSSUtil.COLUMN_OF_TABLE_SHARDING_1_2)))
                .build();

        DataSource dataSource = null;
        try {
            dataSource = ShardingDataSourceFactory.createDataSource(shardingRule);
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return dataSource;
    }

    private DataSource createDataSource() {
        // 使用druid連線資料庫
        DruidDataSource result = new DruidDataSource();
        result.setDriverClassName(driver);
        result.setUrl(url);
        result.setUsername(username);
        result.setPassword(password);
        return result;
    }
}

兩個條件的具體策略演算法

import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.LinkedHashSet;

import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.MultipleKeysTableShardingAlgorithm;
import com.google.common.collect.Range;

public final class StationAndYearTableShardingAlgorithm implements MultipleKeysTableShardingAlgorithm {

    private String column_1 = "tradeaddress";// 欄位1名，預設為tradeaddress，即交易地點
    private String column_2 = "tradedate";// 欄位2名，預設為tradedate，即交易時間
    private String prefix = "yl_";
    private String suffix = "_trade_";

    /**
     * 表名形如YL_xxxxxx_Trade_yyyy（不區分大小寫）（xxxxxx為colum_1處理後的值，yyyy為colum_2處理後的值）
     * 
     * @param column_1
     *            欄位1名稱，預設tradeaddress
     * @param column_2
     *            欄位2名稱，預設tradedate
     */
    public StationAndYearTableShardingAlgorithm(String column_1, String column_2) {
        super();
        if (null != column_1)
            this.column_1 = column_1.toLowerCase();
        if (null != column_2)
            this.column_2 = column_2.toLowerCase();
    }

    @Override
    public Collection<String> doSharding(Collection<String> tableNames, Collection<ShardingValue<?>> shardingValues) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());

        Collection<String> result_1 = null;
        Collection<String> result_2 = null;
        for (ShardingValue<?> shardingValue : shardingValues) {
            if(null == shardingValue){
                continue;
            }
            if (shardingValue.getColumnName().equals(column_1)) {
                result_1 = doSharding(shardingValue);
            }
            if (shardingValue.getColumnName().equals(column_2)) {
                result_2 = doSharding(shardingValue);
            }
        }
        
        if (!CommonUtil.isEmtpy(result_1) && !CommonUtil.isEmtpy(result_2)) {
            for(String str_1 : result_1){
                for(String str_2 :result_2){
                    result.add(new StringBuffer(prefix).append(str_1).append(suffix).append(str_2).toString());
                }
            }
        } else if (!CommonUtil.isEmtpy(result_2)) {
            for (String tableName : tableNames) {
                String name = tableName.toLowerCase();
                for(String str_2 :result_2){
                    if (name.endsWith(new StringBuffer(suffix).append(str_2).toString()) && name.startsWith(prefix)) {
                        result.add(name);
                    }
                }
            }
        } else if (!CommonUtil.isEmtpy(result_1)) {
            for (String tableName : tableNames) {
                String name = tableName.toLowerCase();
                for(String str_1 : result_1){
                    if (name.startsWith(prefix + str_1 + suffix)) {
                        result.add(name);
                    }
                }
            }
        }
        return result;
    }

    private Collection<String> doSharding(final ShardingValue<?> shardingValue){
        Object value = shardingValue.getValue();
        Collection<?> values = shardingValue.getValues();
        Range<?> range = shardingValue.getValueRange();
        if(!CommonUtil.isEmtpy(value)){
            return doEqualSharding(value);
        }else if(!CommonUtil.isEmtpy(values)){
            return doInSharding(values);
        }else if(!CommonUtil.isEmtpy(range)){
            return doBetweenSharding(range);
        }else{
            return Collections.emptySet();
        }
    }

    
    private Collection<String> doEqualSharding(Object value) {
        if(value instanceof String){
            return doEqualSharding4String((String)value);
        }else if(value instanceof Date){
            return doEqualSharding4Date((Date)value);
        }else{
            throw new IllegalArgumentException("分表字段型別必須為java.lang.String或java.util.Date");
        }
    }
    
    private Collection<String> doEqualSharding4String(String value) {
        Collection<String> result = new LinkedHashSet<>(1);
        result.add(value);
        return result;
    }

    private Collection<String> doEqualSharding4Date(Date value) {
        Collection<String> result = new LinkedHashSet<>(1);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(value);
        result.add(String.valueOf(calendar.get(Calendar.YEAR)));
        return result;
    }

    @SuppressWarnings("unchecked")
    private Collection<String> doInSharding(Collection<?> values) {
        for(Object value : values){
            if(null == value){
                continue;
            }
            if(value instanceof String){
                return doInSharding4String((Collection<String>) values);
            }else if(value instanceof Date){
                return doInSharding4Date((Collection<Date>) values);
            }else{
                throw new IllegalArgumentException("分表字段型別必須為java.lang.String或java.util.Date");
            }
        }
        throw new IllegalArgumentException();// in引數全為null
    }
    
    private Collection<String> doInSharding4String(Collection<String> values) {
        Collection<String> result = new LinkedHashSet<>(values.size());
        for (String value : values) {
            result.add(value);
        }
        return result;
    }

    private Collection<String> doInSharding4Date(Collection<Date> values) {
        Calendar calendar = Calendar.getInstance();
        Collection<String> result = new LinkedHashSet<>(values.size());
        for (Date value : values) {
            calendar.setTime(value);
            String year = String.valueOf(calendar.get(Calendar.YEAR));
            result.add(year);
        }
        return result;
    }

    @SuppressWarnings("unchecked")
    private Collection<String> doBetweenSharding(Range<?> range) {
        Object value = range.lowerEndpoint();
        if(null == value){
            throw new IllegalArgumentException();// between引數不能為null
        }else{
            if(value instanceof String){
                return doBetweenSharding4String((Range<String>) range);
            }else if(value instanceof Date){
                return doBetweenSharding4Date((Range<Date>) range);
            }else{
                throw new IllegalArgumentException("分表字段型別必須為java.lang.String或java.util.Date");
            }
        }
    }
    
    private Collection<String> doBetweenSharding4String(Range<String> range) {
        Collection<String> result = new LinkedHashSet<>();
        long lowerEndpoint;
        long upperEndpoint;
        try {
            lowerEndpoint = Long.valueOf(range.lowerEndpoint());
            upperEndpoint = Long.valueOf(range.upperEndpoint());
        } catch (NumberFormatException e) {
            return result;// 值不是數字字串，無法使用between，直接返回空集合
        }
        for (long i = lowerEndpoint; i <= upperEndpoint; i++) {
            result.add(String.valueOf(i));
        }
        return result;
    }

    private Collection<String> doBetweenSharding4Date(Range<Date> range) {
        Calendar calendar = Calendar.getInstance();
        Collection<String> result = new LinkedHashSet<>();
        calendar.setTime(range.lowerEndpoint());
        int lowerEndpoint = calendar.get(Calendar.YEAR);
        calendar.setTime(range.upperEndpoint());
        int upperEndpoint = calendar.get(Calendar.YEAR);
        for (int i = lowerEndpoint; i <= upperEndpoint; i++) {
            result.add(String.valueOf(i));
        }
        return result;
    }
}

單個條件的具體分表策略

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

import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;
import com.google.common.collect.Range;

public final class StationTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<String> {

    private String prefix = "";
    private String suffix = "";
    
    /**
     * 表名形如YL_xxxxxx_Trade（不區分大小寫）
     * @param prefix 字首，如YL_
     * @param suffix 字尾，如_Trade
     */
    public StationTableShardingAlgorithm(String prefix, String suffix) {
        super();
        if(null != prefix)
            this.prefix = prefix.toLowerCase();
        if(null != suffix)
            this.suffix = suffix.toLowerCase();
    }

    @Override
    public String doEqualSharding(final Collection<String> tableNames, final ShardingValue<String> shardingValue) {
        String value = shardingValue.getValue();
        for (String tableName : tableNames) {
            if (tableName.toLowerCase().equals(getTableName(value))) {
                return tableName;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public Collection<String> doInSharding(final Collection<String> tableNames,
            final ShardingValue<String> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());
        for (String value : shardingValue.getValues()) {
            for (String tableName : tableNames) {
                if (tableName.toLowerCase().equals(getTableName(value))) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }

    @Override
    public Collection<String> doBetweenSharding(final Collection<String> tableNames,
            final ShardingValue<String> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());
        Range<String> range = shardingValue.getValueRange();
        long lowerEndpoint;
        long upperEndpoint;
        try {
            lowerEndpoint = Long.valueOf(range.lowerEndpoint());
            upperEndpoint = Long.valueOf(range.upperEndpoint());
        } catch (NumberFormatException e) {
            return result;// 值不是數字字串，無法使用between，直接返回空集合
        }
        for (long i = lowerEndpoint; i <= upperEndpoint; i++) {
            for (String tableName : tableNames) {
                if (tableName.toLowerCase().equals(getTableName(String.valueOf(i)))) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }
    
    private String getTableName(String str){
        return prefix + str + suffix;
    }
}

分表符串工具類


/**
 * 分表符串工具類 TableShardingStringUtil
 * 
 */
public class TSSUtil {

    public static final String DATA_SOURCE_PREFIX = "dataSource";
    public static final String TRANSACTION_MANAGER_PREFIX = "transactionManager";
    public static final String ENTITY_MANAGER_FACTORY_PREFIX = "entityManagerFactory";

    // ***********************************第一個資料來源*********************************************************

    public static final String LABEL_1 = "TradeStationYear";// 標籤
    public static final String TRANSACTION_MANAGER_1 = TRANSACTION_MANAGER_PREFIX + LABEL_1;
    public static final String ENTITY_MANAGER_FACTORY_1 = ENTITY_MANAGER_FACTORY_PREFIX + LABEL_1;
    public static final String DATA_SOURCE_1 = DATA_SOURCE_PREFIX + LABEL_1;
    /** Repository所在包名 */
    public static final String BASE_PACKAGES_1 = "com.gxmis.afc.moduletradedata.entitytradestationyear";
    /** 實體所在包名 */
    public static final String PACKAGES_1 = "com.gxmis.afc.moduletradedata.entitytradestationyear";
    /** 邏輯表名 */
    public static final String LOGICAL_TABLE_1 = "trade_station_year";
    /** 分表字段名1 */
    public static final String COLUMN_OF_TABLE_SHARDING_1_1 = "trade_address";
    /** 分表字段名2 */
    public static final String COLUMN_OF_TABLE_SHARDING_1_2 = "trade_date";

}

分表要自己建立表

相關推薦

MyCat：對MySQL數據庫進行分庫分表

文件 res names sel reg l數據庫 esp chan 規則 本篇前提： mycat配置正確，且能正常啟動。1、schema.xml<table>

【分庫分表】sharding-jdbc + spring boot對大表進行分庫分表

一、前言       最近小編跳槽了，剛好入職了一家移動網際網路公司。非常的幸運。來新公司後的第一個專案就是對通知服務進行優化改進，其中，一個業務就是當用戶登入的時候，就會登入訪問通知表，根據使用者id載入通知資訊。由於通知量已經上億了，在查詢的時候是非常慢的。

使用Sharding-Proxy進行分庫分表

Sharding-Proxy的使用 1、官網下載 sharding-jdbc的官網http://shardingsphere.io/document/current/cn/manual/sharding-proxy/usage/ 下載完進入conf檔案如下：      

MyCat：對MySQL資料庫進行分庫分表

本篇前提： mycat配置正確，且能正常啟動。 1、schema.xml <table>標籤： dataNode -- 分片節點指定（取值：dataNode中的name屬性值） rule ------ 分片規則選擇（取值：rule標籤中的

42、如何進行分庫分表？

1、面試題 為什麼要分庫分表（設計高併發系統的時候，資料庫層面該如何設計）？用過哪些分庫分表中介軟體？不同的分庫分表中介軟體都有什麼優點和缺點？你們具體是如何對資料庫如何進行垂直拆分或水平拆分的？ 2、面試官心裡分析 其實這塊肯定是扯到高併發了，因為分庫分表一定是為了支撐高併發、資料量大

Springboot使用sharding進行分庫分表

pom.xml檔案加入sharing引用和druid引用 <dependency>             <groupId>com.dangdang</groupId>             <artifactId&

sharding-jdbc 使用，進行分庫分表以及多資料庫間的事物驗證

新建Maven專案 pom.xml <projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   xs

MySQL優化分庫分表，為什麼要分表，分表以後如何進行排序查詢，業務如何設計？

MySQL優化分庫分表，為什麼要分表，分表以後如何進行排序查詢，業務如何設計？ 昨天面試新人的時候，遇到了這麼一個問題，按照自己的想法大體聊了一些，但大多是感性的，並沒有完整的瞭解why and how. 今天查了一些相關的資料，包括《MySQL效能調優與架構設計》、《高效能Mysql》，慢慢的整

MySQL分庫分表備份腳本

數據庫備份數據庫腳本[[email protected]/* */ script]# cat store_backup.sh #!/bin/shMYUSER=rootMYPASS=qwe123SOCKET=/data/3306/mysql.sockMYLOGIN="mysql -u$MYUSER

數據庫（分庫分表）中間件對比

系統瓶頸 地址 ring 缺點 無需 網絡io 數據遷移 用戶 osql 轉自：http://www.cnblogs.com/cangqiongbingchen/p/7094822.html 分區：對業務透明，分區只不過把存放數據的文件分成了許多小塊，例如mysql中的一張

架構師速成8.3-可用性之分庫分表

路由 運行 進行 一鍵 常量 popu 同步 width track 有狀態分布式，涉及的知識就比較多了，只是我們能夠拿幾個現實的樣例由淺入深的來理解。 數據庫的分庫分表 如果你是一個開發負責人，開始使用單機的數據庫，突然一天數據庫硬盤掛掉了。你沒有

16、MySQL數據庫分庫分表備份腳本

mysql數據庫分庫分表備份腳本MySQL數據庫分庫分表備份腳本===================學員分享分庫分表==========================腳本單雙引號的區別：單引號是強引用，強制輸出是所見即所得。雙引號是解析變量 和 多個字符串、數字等連接一個字符串條件1 || 條件2

MyBatis實現Mysql數據庫分庫分表操作和總結

用戶表 設計 行數 百萬 出現問題 網絡 自增 .html tro 閱讀目錄 前言 MyBatis實現分表最簡單步驟 分離的方式 分離的策略 分離的問題 分離的原則 實現分離的方式 總結 前言 作為一個數據庫，作為數據庫中的一張表，隨著用戶的增多隨著時間的推移，總有一

記錄一次經歷的數據庫從單庫到分庫分表的過程

人力 per 靠譜 img center 沒有 tdd 推出 數據 前言 目前所在的的項目組，由於項目正在處於一個業務爆發期，每天數據的增長量已經給我們數據庫乃至系統造成了很多不確定的因數，前期依靠優化業務和SQL等方式暫時還能夠支撐住。但是最近發現某些表數據達到50

MySQL 高可用：mysql+mycat實現數據庫分片（分庫分表）

native 分布 for 成功 img 問題 represent apache 新一代 本文引用於http://blog.csdn.net/kk185800961/article/details/51147029 MySQL 高可用：mysql+mycat實現數據庫分片（

數據庫分庫分表

事務管理 mys cal 為什麽 分配 slaver 資源問題 時間流 1.7 1. 數據庫分庫分表 1.1. 前言 1.1.1. 名詞解釋 1.2. 數據庫架構演變 1.3. 分庫分表前的問題 1.3.1. 用戶請求量太大 1.3.2. 單庫太大 1.3.3

MySQL分庫分表方案

人員 有趣的 而不是 其他 代理 延時 分片 -o 得到 1. MySQL分庫分表方案 1.1. 問題： 1.2. 回答： 1.2.1. 最好的切分MySQL的方式就是：除非萬不得已，否則不要去幹它。 1.2.2. 你的SQL語句不再是聲明式的（declarativ

數據庫分庫分表中間件 Sharding-JDBC 源碼分析 —— SQL 解析（六）之刪除SQL

java 後端 架構 數據庫 中間件關註微信公眾號：【芋道源碼】有福利：RocketMQ / MyCAT / Sharding-JDBC 所有源碼分析文章列表RocketMQ / MyCAT / Sharding-JDBC 中文註釋源碼 GitHub 地址您對於源碼的疑問每條留言都將得到認真回復。甚至不知道如

數據庫分庫分表中間件 Sharding-JDBC 源碼分析 —— 分布式主鍵

java 後端 架構 數據庫 中間件關註**微信公眾號：【芋道源碼】**有福利：RocketMQ / MyCAT / Sharding-JDBC 所有源碼分析文章列表RocketMQ / MyCAT / Sharding-JDBC 中文註釋源碼 GitHub 地址您對於源碼的疑問每條留言都將得到認真回復。甚至

mycat初次簡單配置分庫分表

join p12 tor 建立 total rac help show version 先規劃下數據庫的基礎架構，先來個最簡單基礎的。 三臺虛機，各安裝了mysql5.7 用mycat建立邏輯數據庫，建立5個表格，其中一個表格分庫，一個表格做全局表，剩余三個表格每個虛機的