說明

• 要排除DataSourceAutoConfiguration，否則多資料來源無法配置

@SpringBootApplication
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
    
}

• 配置的多個數據源交給sharding-jdbc管理，sharding-jdbc建立一個DataSource資料來源提供給mybatis使用

步驟

• 配置多個數據源，資料來源的名稱最好要有一定的規則，方便配置分庫的計算規則

@Bean(initMethod="init", destroyMethod="close", name="dataSource0")
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource0(){
    return new DruidDataSource();
}

@Bean(initMethod="init", destroyMethod="close", name="dataSource1")
@ConfigurationProperties(prefix = "spring.datasource2")
public DataSource dataSource1(){
    return new DruidDataSource();
}
 

• 配置資料來源規則，即將多個數據源交給sharding-jdbc管理，並且可以設定預設的資料來源，當表沒有配置分庫規則時會使用預設的資料來源

@Bean
public DataSourceRule dataSourceRule(@Qualifier("dataSource0") DataSource dataSource0, 
        @Qualifier("dataSource1") DataSource dataSource1){
    Map<String, DataSource> dataSourceMap = new HashMap<>();
    dataSourceMap.put("dataSource0", dataSource0);
    dataSourceMap.put("dataSource1", dataSource1);
    return new DataSourceRule(dataSourceMap, "dataSource0");
}
 

• 配置資料來源策略和表策略，具體策略需要自己實現

@Bean
public ShardingRule shardingRule(DataSourceRule dataSourceRule){
    //表策略
    TableRule orderTableRule = TableRule.builder("t_order")
            .actualTables(Arrays.asList("t_order_0", "t_order_1"))
            .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
            .dataSourceRule(dataSourceRule)
            .build();
    TableRule orderItemTableRule = TableRule.builder("t_order_item")
            .actualTables(Arrays.asList("t_order_item_0", "t_order_item_1"))
            .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
            .dataSourceRule(dataSourceRule)
            .build();
    //繫結表策略，在查詢時會使用主表策略計算路由的資料來源，因此需要約定繫結表策略的表的規則需要一致，可以一定程度提高效率
    List<BindingTableRule> bindingTableRules = new ArrayList<BindingTableRule>();
    bindingTableRules.add(new BindingTableRule(Arrays.asList(orderTableRule, orderItemTableRule)));
    return ShardingRule.builder()
            .dataSourceRule(dataSourceRule)
            .tableRules(Arrays.asList(orderTableRule, orderItemTableRule))
            .bindingTableRules(bindingTableRules)
            .databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()))
            .tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
            .build();
}

• 建立sharding-jdbc的資料來源DataSource，MybatisAutoConfiguration會使用此資料來源

@Bean("dataSource")
public DataSource shardingDataSource(ShardingRule shardingRule){
    return ShardingDataSourceFactory.createDataSource(shardingRule);
}

• 需要手動配置事務管理器（原因未知）

//需要手動宣告配置事務
@Bean
public DataSourceTransactionManager transactitonManager(@Qualifier("dataSource") DataSource dataSource){
    return new DataSourceTransactionManager(dataSource);
}

• 分庫策略的簡單實現，介面：DatabaseShardingAlgorithm

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

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

/**
 * Created by fuwei.deng on 2017年5月11日.
 */
public class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> {

    @Override
    public String doEqualSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
        for (String each : databaseNames) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }
    
    @Override
    public Collection<String> doInSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(databaseNames.size());
        for (Long value : shardingValue.getValues()) {
            for (String tableName : databaseNames) {
                if (tableName.endsWith(value % 2 + "")) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }
    
    @Override
    public Collection<String> doBetweenSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(databaseNames.size());
        Range<Long> range = (Range<Long>) shardingValue.getValueRange();
        for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
            for (String each : databaseNames) {
                if (each.endsWith(i % 2 + "")) {
                    result.add(each);
                }
            }
        }
        return result;
    }

}

• 分表策略的基本實現，介面：TableShardingAlgorithm

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;

/**
 * Created by fuwei.deng on 2017年5月11日.
 */
public class ModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {

    @Override
    public String doEqualSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
        for (String each : tableNames) {
            if (each.endsWith(shardingValue.getValue() % 2 + "")) {
                return each;
            }
        }
        throw new IllegalArgumentException();
    }
    
    @Override
    public Collection<String> doInSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());
        for (Long value : shardingValue.getValues()) {
            for (String tableName : tableNames) {
                if (tableName.endsWith(value % 2 + "")) {
                    result.add(tableName);
                }
            }
        }
        return result;
    }
    
    @Override
    public Collection<String> doBetweenSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
        Collection<String> result = new LinkedHashSet<>(tableNames.size());
        Range<Long> range = (Range<Long>) shardingValue.getValueRange();
        for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
            for (String each : tableNames) {
                if (each.endsWith(i % 2 + "")) {
                    result.add(each);
                }
            }
        }
        return result;
    }

}

• 至此，分庫分表的功能已經實現

讀寫分離

• 讀寫分離需在建立DataSourceRule之前加一層主從資料來源的建立

// 構建讀寫分離資料來源, 讀寫分離資料來源實現了DataSource介面, 可直接當做資料來源處理. 
// masterDataSource0, slaveDataSource00, slaveDataSource01等為使用DBCP等連線池配置的真實資料來源
DataSource masterSlaveDs0 = MasterSlaveDataSourceFactory.createDataSource("ms_0", 
                    masterDataSource0, slaveDataSource00, slaveDataSource01);
DataSource masterSlaveDs1 = MasterSlaveDataSourceFactory.createDataSource("ms_1", 
                    masterDataSource1, slaveDataSource11, slaveDataSource11);

// 構建分庫分表資料來源
Map<String, DataSource> dataSourceMap = new HashMap<>(2);
dataSourceMap.put("ms_0", masterSlaveDs0);
dataSourceMap.put("ms_1", masterSlaveDs1);

// 通過ShardingDataSourceFactory繼續建立ShardingDataSource

• 強制使用主庫時

HintManager hintManager = HintManager.getInstance();
hintManager.setMasterRouteOnly();
// 繼續JDBC操作

強制路由

• 使用ThreadLocal機制實現，在執行資料庫操作之前通過HintManager改變用於計算路由的值
• 設定HintManager的時候分庫和分表的策略必須同時設定，並且設定後需要路由的表都需要設定用於計算路由的值。比如強制路由後需要操作t_order和t_order_item兩個表，那麼兩個表的分庫和分表的策略都需要設定

HintManager hintManager = HintManager.getInstance();
hintManager.addDatabaseShardingValue("t_order", "user_id", 1L);
hintManager.addTableShardingValue("t_order", "order_id", order.getOrderId());
hintManager.addDatabaseShardingValue("t_order_item", "user_id", 1L);
hintManager.addTableShardingValue("t_order_item", "order_id", order.getOrderId());

事務

• sharding-jdbc-transaction實現柔性事務（預設提供了基於記憶體的事務日誌儲存器和內嵌非同步作業），可結合elastic-job（sharding-jdbc-transaction-async-job）實現非同步柔性事務
• 沒有與spring結合使用的方式，需要自己封裝