通过ShardingAlgorithm的实现，可以进一步发现分片策略的灵活和强大；可以实现一致性hash算法、按时间分片算法、以及mod算法等；

更进一步，可以对同一个表按业务需求实现不同的分片算法，比如原来按年分片的业务表，比如随着业务量的扩展，需要提高分片频率，

可是又不想进行大量历史数据迁移，可以在某一时刻开始按月或者按日分片；当然前提是要维护一个相对复杂的分片算法；

下面展示一个自定义分片算法原型，留作业务扩展；

 

业务模型和上一篇的inline表达式一样，下面进行核心代码说明：

1）核心pom文件内容

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>io.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

 

2）核心yml内容：

sharding:
  jdbc:
    datasource:
      names: master0,master0salve0,master0slave1,master1,master1slave0,master1slave1
      master0:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mcspcsharding0?useUnicode=true&character_set_server=utf8mb4&useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root
      master0salve0:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mcspcsharding0s0?useUnicode=true&character_set_server=utf8mb4&useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root
      master0slave1:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mcspcsharding0s1?useUnicode=true&character_set_server=utf8mb4&useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root
      master1:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mcspcsharding1?useUnicode=true&character_set_server=utf8mb4&useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root
      master1slave0:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mcspcsharding1s0?useUnicode=true&character_set_server=utf8mb4&useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root
      master1slave1:
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://localhost:3306/mcspcsharding1s1?useUnicode=true&character_set_server=utf8mb4&useSSL=false&serverTimezone=GMT%2B8
        username: root
        password: root
    config:
      sharding:
        tables:
          mc_member:
            actual-nodes: mcspcsharding$->{0..1}.mc_member$->{0..1}
            database-strategy:
              standard:
                sharding-column: gender
                precise-algorithm-class-name: com.chong.mcspcshardingdbtable.sharding.DbShardingAlgorithm
            table-strategy:
              complex:
                sharding-columns: id
                algorithm-class-name: com.chong.mcspcshardingdbtable.sharding.MemberTblComplexKeySharding
        binding-tables: mc_member  # 多个时逗号隔开
        broadcast-tables: mc_master
        master-slave-rules:
          ms0:
            master-data-source-name: master0
            slave-data-source-names: master0salve0,master0slave1
          ms1:
            master-data-source-name: master1
            slave-data-source-names: master1slave0,master1slave1
      props:
        sql:
          show: true

 

3）database数据源的sharding算法，实现了PreciseShardingAlgorithm

 

package com.chong.mcspcshardingdbtable.sharding;

import io.shardingsphere.api.algorithm.sharding.PreciseShardingValue;
import io.shardingsphere.api.algorithm.sharding.standard.PreciseShardingAlgorithm;
import org.springframework.stereotype.Component;

import java.util.Collection;

@Component
public class DbShardingAlgorithm implements PreciseShardingAlgorithm<Integer> {

    @Override
    public String doSharding(Collection<String> collection, PreciseShardingValue<Integer> preciseShardingValue) {

        Integer index = preciseShardingValue.getValue() % 2;
        for (String dataSourceName : collection) {
            if (dataSourceName.endsWith(index + "")) {
                return dataSourceName;
            }
        }
        throw new UnsupportedOperationException();
    }
}

 

 

4）table的sharding算法，实现了ComplexKeysShardingAlgorithm

package com.chong.mcspcshardingdbtable.sharding;

import com.google.common.collect.Range;
import io.shardingsphere.api.algorithm.sharding.ListShardingValue;
import io.shardingsphere.api.algorithm.sharding.PreciseShardingValue;
import io.shardingsphere.api.algorithm.sharding.RangeShardingValue;
import io.shardingsphere.api.algorithm.sharding.ShardingValue;
import io.shardingsphere.api.algorithm.sharding.complex.ComplexKeysShardingAlgorithm;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * 通过复合分片键进行演示，覆盖Precise，Range，List三种类型的ShardingValue。
 * 项目中应根据实际情况实现：
 * 1精确分片PreciseShardingAlgorithm、
 * 2范围分片RangeShardingAlgorithm
 * 3复合分片ComplexKeysShardingAlgorithm
 * 4非SQL解析分片HintShardingAlgorithm
 */
@Component
public class MemberTblComplexKeySharding implements ComplexKeysShardingAlgorithm {

    private static String shardingColumn1 = "id"; // todo: 业务扩展 shardingcolumn2...n
    private static String targetLogicTable = "mc_member";

    @Override
    public Collection<String> doSharding(Collection<String> logicTables, Collection<ShardingValue> shardingValues) {
        // 当设置多个shardingcolumn时，重写下面逻辑，根据shardingValues参数和实际分表业务规则计算出实际的actualTable
        List<Long> ids = new ArrayList<>(); // todo: 业务扩展 sharding-cloumn-parame-value-List2...n
        ShardingValue shardingValue = getShardingValue(shardingValues, shardingColumn1); // todo: 业务扩展 shardingValue2..n
        if (shardingValue instanceof PreciseShardingValue) {
            PreciseShardingValue<Long> preciseShardingValue = (PreciseShardingValue<Long>) shardingValue;
            Long id = preciseShardingValue.getValue();
            ids.add(id);
        } else if (shardingValue instanceof RangeShardingValue) {
            RangeShardingValue<Long> rangeShardingValue = (RangeShardingValue<Long>) shardingValue;
            Range<Long> range = rangeShardingValue.getValueRange();
            for (Long index = range.lowerEndpoint(); index <= range.upperEndpoint(); index++) {
                ids.add(index);
            }
        } else if (shardingValue instanceof ListShardingValue) {
            ListShardingValue<Long> listShardingValue = (ListShardingValue<Long>) shardingValue;
            ids.addAll(listShardingValue.getValues());
        }
        return getActualTables(logicTables, ids, targetLogicTable);  // todo:业务扩展 传参 sharding-cloumn-parame-value-List2...n
    }

    /**
     * 根据sql语句中的id值，和logicTable进行拼接，获取实际要查询的表.
     * 实际业务中遇到多个分片列时，除了ids还需要考虑其他key值，合并计算对逻辑表进行组装
     */
    private List<String> getActualTables(Collection<String> logicTables, List<Long> ids, String targetLogicTable) {
        List<String> actualTables = new ArrayList<>();
        if (logicTables.contains(targetLogicTable)) {
            for (Long id : ids) {
                // 作为演示，仅对id%2作为表后缀的匹配规则，今后应根据实际情况重置分片列和匹配规则。
                String actualTableName = targetLogicTable + id%2;
                if(!actualTables.contains(actualTableName)) {
                    actualTables.add(targetLogicTable + (id % 2));
                }
            }
        }
        if (actualTables.size() == 0) {
            throw new UnsupportedOperationException();
        }
        return actualTables;
    }

    /**
     * 根据预知的分拆列获取到对应的shardingvalue对象
     */
    private ShardingValue getShardingValue(Collection<ShardingValue> shardingValues, String column) {
        for (ShardingValue sv : shardingValues) {
            if (sv.getColumnName().equals(column)) {
                return sv;
            }
        }
        throw new UnsupportedOperationException();
    }
}

 

5）启动类

package com.chong.mcspcshardingdbtable;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication(exclude = {DruidDataSourceAutoConfigure.class})
@EnableDiscoveryClient
@EnableTransactionManagement
@ComponentScan(basePackages = {"com.chong.common","com.chong.mcspcshardingdbtable"})
public class McSpcShardingDbTableApplication {

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

}