Mycat 数据分片--取模函数源码阅读

Mycat 数据分片--取模函数源码阅读：

package io.mycat.route.function;

import java.math.BigInteger;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import io.mycat.config.model.rule.RuleAlgorithm;

/**

 * number column partion by Mod operator

 * if count is 10 then 0 to 0,21 to 1 (21 % 10 =1)

 * @author wuzhih

 *

 */

public class PartitionByMod extends AbstractPartitionAlgorithm implements RuleAlgorithm  {

private int count;

@Override

public void init() {

}

public void setCount(int count) {

this.count = count;

}

@Override

public Integer calculate(String columnValue)  {

// columnValue = NumberParseUtil.eliminateQoute(columnValue);

try {

BigInteger bigNum = new BigInteger(columnValue).abs();

return (bigNum.mod(BigInteger.valueOf(count))).intValue();

} catch (NumberFormatException e){

throw new IllegalArgumentException(new StringBuilder().append("columnValue:").append(columnValue).append(" Please eliminate any quote and non number within it.").toString(),e);

}

}

@Override

public int getPartitionNum() {

int nPartition = this.count;

return nPartition;

}

private static void hashTest()  {

PartitionByMod hash=new PartitionByMod();

//初始化机器节点的数量为11

hash.setCount(11);

hash.init();//空方法暂无实际意义

//数组用来统计每个节点存储的数据条数,数组下标从0开始编号,刚好和机器编号相同

int[] bucket=new int[hash.count];

//Map存储节点数据的片键,其中key为机器编号0-10,

                // Value为分库分表对应的键值,例如以ID为主键的一系列集合

Map<Integer,List<Integer>> hashed=new HashMap<>();

int total=1000_0000;//数据量

int c=0;

for(int i=100_0000;i<total+100_0000;i++){//假设分片键从100万开始

c++;//计数器统计循环的次数

//核心思想 i%count 取模,取模之后的余数值范围为0-count-1,其值对应的就是机器的节点编号

//键值为0即刚好是count的整数倍

int h=hash.calculate(Integer.toString(i));

 

//计数器,统计落在节点h上的数据量

bucket[h]++;

//从Map中取出节点H中存储的片键集合容器List,第一次肯定为空

List<Integer> list=hashed.get(h);

if(list==null){

list=new ArrayList<>();

hashed.put(h, list);

}

//把落在节点H中的数据扔到集合容器里面

list.add(i);

}

System.out.println(c+"   "+total);

double d=0;

c=0;

int idx=0;

System.out.println("index    bucket   ratio");

//bucket中的值就是数据落在每个节点的数量，下标就是机器编号

for(int i:bucket){

//变量d是一个分布率求和统计,i代表落在节点的数量,total代表数据总数

d+=i/(double)total;

//统计各个节点的数据总和

c+=i;

//输出：机器节点下标   节点上数据总数  节点中数据占总数的比例

System.out.println("机器编号:"+(idx++)+",数据总数:  "+i+" ,占比例:  "+(i/(double)total));

}

System.out.println("分布率求和:"+d+" 各节点数据总数即路由总数: "+c);

System.out.println("****************************************************");

//取出在节点0的数据进行重新分布

rehashTest(hashed.get(0));

}

private static void rehashTest(List<Integer> partition)  {

PartitionByMod hash=new PartitionByMod();

//注意节点0上的数据都是11的整数倍,现在机器节点达到110,

                //所以节点1上的数据重新路由会落在11,22,33,99上面

//机器编号为0---109

hash.count=110;//分片数

hash.init();

//新数组用来统计每个节点存储的数据条数,数组下标从0开始编号,刚好和机器编号相同

int[] bucket=new int[hash.count];

int total=partition.size();//数据量

int c=0;

for(int i:partition){//假设分片键从100万开始

c++;

int h=hash.calculate(Integer.toString(i));

bucket[h]++;

}

System.out.println(c+"   "+total);

c=0;

int idx=0;

System.out.println("index    bucket   ratio");

for(int i:bucket){

c+=i;

System.out.println(idx+++"  "+i+"   "+(i/(double)total));

}

}

public static void main(String[] args)  {

hashTest();

// PartitionByMod partitionByMod = new PartitionByMod();

// partitionByMod.count=8;

// partitionByMod.calculate("\"6\"");

// partitionByMod.calculate("\'6\'");

}

}

结果验证：

疑问：各个节点分布数据的比例总和 为什么不是100%,而是99.9999%是因为机器存储浮点数的误差导致。