分库分表之MyCat应用

目录

 

1、分库分表介绍

1.1 垂直切分

1.2 水平切分

2、MyCAT介绍

3、MyCAT架构

4、MyCAT的关键特性

5、MyCAT分片策略

6、实战演练

6.1 创建数据库：

6.2 安装MyCAT

6.3 配置文件介绍

6.3 启动MyCAT测试

7、Java测试

7.1 pom依赖

7.2 spring配置

7.3 单元测试

8、Mycat自定义分片机制

8.1 Mycat的源码包

8.2 自定义分片类

8.3 打包替换

9、拓展

---

1、分库分表介绍

分库分表就是为了解决由于数据量过大而导致数据库性能降低的问题，将原来独立的数据库拆分成若干数据库组成，将数据大表分成若干数据表组成，使得单一数据库、单一数据表的数据量变小，从而达到提升数据库性能的目的。而且随着微服务这种架构的兴起，我们应用从一个完整的大的应用，切分为很多可以独立提供服务的小应用。每个应用都有独立的数据库。

数据的切分分为两种：

l 垂直切分：按照业务模块进行切分，将不同模块的表切分到不同的数据库中。

l 水平切分：将一张大表按照一定的切分规则，按照行切分到不同的表或者不同的库中。

1.1 垂直切分

垂直分库是指按照业务将表进行分类，分布到不同的数据库上面，每个库可以放不同的服务器上，

垂直分表定义 ：将一个表按照字段分成多表，每个表存储其中一部分字段。

• 带来的性能提升是 ： 为了避免IO争抢并减少锁表的几率，查看详情的用户与商品信息浏览互不影响。 充分发挥热门数据的操作效率，商品信息的操作的高效率不会被商品描述的低效率所拖累。

• 带来的业务提升是 ：

  解决业务层面的耦合，业务清晰

  能对不同业务的数据进行分级管理、维护、监控、扩展等

 

1.2 水平切分

水平分表是在同一个数据库内，把同一个表的数据按一定规则拆到多个表中。它带来的提升是 ：

1.优化单一表数据量过大而产生的性能问题

2.避免IO争抢并减少锁表的几率

PS: 库内的水平分表，解决来自单一表数据量过大的问题，分出来的小表中只包含一部分数据，从而使得单个表的数据量变小，提高检索性能。

水平分库是把同一个表的数据按一定规则拆分到不同的数据库中，每个库可以放不同的服务器上。

1.解决来自单库大数据，高并发的性能瓶颈。

2.提高系统的稳定性及可用性。 ​ PS: 稳定性体现在IO冲突减少，锁定减少，可用性指某个库出问题，部分可用。

 

总结：

2、MyCAT介绍

简单的说，MyCAT就是：

• 一个彻底开源的，面向企业应用开发的“大数据库集群”

• 支持事务、ACID、可以“替代”MySQL的加强版数据库

• 一个可以视为“MySQL”集群的企业级数据库，用来替代昂贵的Oracle集群

• 一个融合内存缓存技术、NoSQL技术、HDFS大数据的新型SQL Server

• 结合传统数据库和新型分布式数据仓库的新一代企业级数据库产品

• 一个新颖的数据库中间件产品

MyCAT的目标是：低成本的将现有的单机数据库和应用平滑迁移到“云”端，解决数据存储和业务规模迅速增长情况下的数据瓶颈问题。

3、MyCAT架构

4、MyCAT的关键特性

支持 SQL 92标准

支持MySQL集群，可以作为Proxy使用

支持JDBC连接ORACLE、DB2、SQL Server，将其模拟为MySQL Server使用

支持galera for mysql集群，percona-cluster或者mariadb cluster，提供高可用性数据分片集群

自动故障切换，高可用性

支持读写分离，支持MySQL一主多从，以及多主多从的模式

支持全局表，数据自动分片到多个节点，用于高效表关联查询

支持独有的基于E-R 关系的分片策略，实现了高效的表关联查询

多平台支持，部署和实施简单

5、MyCAT分片策略

MyCAT支持水平分片与垂直分片：

水平分片：一个表格的数据分割到多个节点上，按照行分隔。

垂直分片：一个数据库中多个表格A，B，C，A存储到节点1上，B存储到节点2上，C存储到节点3上。

MyCAT通过定义表的分片规则来实现分片，每个表格可以捆绑一个分片规则，每个分片规则指定一个分片字段并绑定一个函数，来实现动态分片算法。

1. Schema：逻辑库，与MySQL中的Database（数据库）对应，一个逻辑库中定义了所包括的Table。

2. Table：表，即物理数据库中存储的某一张表，与传统数据库不同，这里的表格需要声明其所存储的逻辑数据节点DataNode。在此可以指定表的分片规则。

3. DataNode：MyCAT的逻辑数据节点，是存放table的具体物理节点，也称之为分片节点，通过DataSource来关联到后端某个具体数据库上

4. DataSource：定义某个物理库的访问地址，用于捆绑到DataNode上

6、实战演练

6.1 创建数据库：

有两个表单：users和item。三个数据库：db01、db02、db03（三个库中的数据都在同一个实例中）

users表在db01数据库中

item数据分别存放在db02、db03数据库中

6.2 安装MyCAT

JDK和MySQL在我提供的虚拟机镜像文件中已安装，现在我们只需要安装MyCat了(课件已提供安装压缩文件),当然你高兴可以自己下载：

github官方地址：https://github.com/MyCATApache

源码下载地址：https://github.com/MyCATApache/Mycat-Server

安装包下载地址：https://github.com/MyCATApache/Mycat-download

#注意注意注意！！！！！！下载安装包（当前官网http://www.mycat.io已经打不开，只能上github下载其他版本，如下：）
wget https://github.com/MyCATApache/Mycat-download/blob/master/1.6.5-DEV/Mycat-server-1.6.5-DEV-20161231120132-linux.tar.gz
----------------------------------------------------------
#解压
tar -zxvf Mycat-server-1.6.7.5-release-20200422133810-linux.tar.gz #可以看到生成了一个mycat目录
#配置环境变量
vi /etc/profile
#在文件末尾添加一行：
export MYCAT_HOME=/usr/local/mycat
#使修改生效：
source /etc/profile
#测试是否生效：
echo $MYCAT_HOME

6.3 配置文件介绍

conf目录下service.xml，rule.xml，schema.xml三个文件:

• service.xml主要配置MyCat服务的参数，比如端口号，MyCat用户名和密码使用的逻辑数据库等

• rule.xml主要配置路由策略，主要有分片的片键，拆分的策略（取模还是按区间划分等）

• schema.xml文件主要配置数据库的信息，例如逻辑数据库名称，物理上真实的数据源以及表和数据源之间的对应关系和路由策略等。

三个文件配置如下：

service.xml

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE mycat:server SYSTEM "server.dtd"> 
<mycat:server xmlns:mycat="http://io.mycat/"> 
        <!-- 任意设置登陆 mycat 的用户名,密码,数据库  --> 
        <user name="test"> 
                <property name="password">test</property> 
                <property name="schemas">TESTDB</property> 
        </user> 
 
        <user name="user"> 
                <property name="password">user</property> 
                <property name="schemas">TESTDB</property> 
                <property name="readOnly">true</property> 
        </user> 
</mycat:server> 

rule.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- - - Licensed under the Apache License, Version 2.0 (the "License");
    - you may not use this file except in compliance with the License. - You
    may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0
    - - Unless required by applicable law or agreed to in writing, software -
    distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT
    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the
    License for the specific language governing permissions and - limitations
    under the License. -->
<!DOCTYPE mycat:rule SYSTEM "rule.dtd">
<mycat:rule xmlns:mycat="http://io.mycat/">
 
    <tableRule name="role1">
        <rule>
             <!--路由规则》》Id取模后均匀的分布-->
            <columns>id</columns>
            <algorithm>mod-long</algorithm>
        </rule>
    </tableRule>
 
    <function name="mod-long" class="io.mycat.route.function.PartitionByMod">
        <!-- 数据源节点个数，使用者切分节点数 -->
        <property name="count">2</property>
    </function>
</mycat:rule>
​
<!--MYCAT常用的分片规则如下，另外还有一些其他分片方式这里不全部列举：
​
　　　　（1）分片枚举：     　　 sharding-by-intfile
​
　　　　（2）主键范围约定：　   auto-sharding-long    此分片适用于，提前规划好分片字段某个范围属于哪个分片
​
　　　　（3）一致性hash：  　　sharding-by-murmur
​
　　　　（4）字符串hash解析：  sharding-by-stringhash
​
　　　　（5）按日期（天）分片：sharding-by-date
​
　　　　（6）按小时拆分：   sharding-by-hour
​
　　　　（7）自然月分片：         sharding-by-month
​
　　　　（8）取模：　　　　　　mod-long  此规则为对分片字段求摸运算
​
　　　　（9）取模范围约束：      sharding-by-pattern 此种规则是取模运算与范围约束的结合，主要为了后续数据迁移做准备，即可以自主决定取模后数据的节点分布
-->

schema.xml

<?xml version="1.0"?> 
<!DOCTYPE mycat:schema SYSTEM "schema.dtd"> 
<mycat:schema xmlns:mycat="http://io.mycat/"> 
 
    <!-- 设置表的存储方式.schema name="TESTDB" 与 server.xml中的 TESTDB 设置一致  --> 
    <schema name="TESTDB" checkSQLschema="false" sqlMaxLimit="100"> 
        <table name="users" primaryKey="id"  dataNode="node_db01" /> 
        <table name="item" primaryKey="id" dataNode="node_db02,node_db03" rule="role1" /> 
    </schema> 
 
    <!-- 设置dataNode 对应的数据库,及 mycat 连接的地址dataHost --> 
    <dataNode name="node_db01" dataHost="dataHost01" database="db01" /> 
    <dataNode name="node_db02" dataHost="dataHost01" database="db02" /> 
    <dataNode name="node_db03" dataHost="dataHost01" database="db03" /> 
 
    <!-- mycat 逻辑主机dataHost对应的物理主机.其中也设置对应的mysql登陆信息 
        balance属性
            balance=”0”, 不开启读写分离机制，所有读操作都发送到当前可用的 writeHost 上
            balance=”1”，全部的 readHost 与 stand by writeHost 参与 select 语句的负载均衡
            balance=”2”，所有读操作都随机的在 writeHost、 readhost 上分发。
            balance=”3”， 所有读请求随机的分发到 wiriterHost 对应的 readhost 执行,writerHost 不负担读压力
    --> 
    <dataHost name="dataHost01" maxCon="1000" minCon="10" balance="0" writeType="0" dbType="mysql" dbDriver="native"> 
            <heartbeat>select user()</heartbeat> 
            <writeHost host="server1" url="127.0.0.1:3306" user="root" password="123456"></writeHost>
    </dataHost> 
</mycat:schema>

6.3 启动MyCAT测试

cd /usr/local/mycat/bin
./startup_nowrap.sh
​
# PS:
# 1、如果启动报错如下：
    -bash: ./startup_nowrap.sh: /bin/sh^M: 坏的解释器: 没有那个文件或目录
    # 说明执行脚本格式有问题，执行如下命令修复
    sed -i 's/\r$//' startup_nowrap.sh
# 2、如果报错如下：
    Error: JAVA_HOME environment variable is not set.
    # 说明JAVA_HOME没设置好，
    vim /etc/profile
    # 增加如下配置，当然，要跟你java安装目录一致
    export JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.232.b09-0.el7_7.x86_64
    
​

访问Mycat逻辑数据库：命令：mysql -utest -ptest -h127.0.0.1 -P8066 -DTESTDB

通过以上可以看出连接Mycat逻辑数据库成功，命令：show databases；查询所有的数据库，发现只有TESTDB一个数据库，并没有我们之前创建的db01、db02、db03数据库的存在。

现在在访问Mycat在数据库中插入数据，看数据能否按照前面配置的路由规则进行分表。

执行插入数据命令（在当前命令框）：

insert into users(name,indate) values('kk',now());
insert into users(name,indate) values('ss',now());
insert into item(id,value,indate) values(1,100,now());
insert into item(id,value,indate) values(2,100,now());

db01数据库中的users表中的数据

db02数据库中的item表中的数据

db03数据库中的item表中的数据

插入的users表中的数据全部在db01中，而item表中的数据通过Id取模后均匀的分布在db02和db03中。这样就根据实际的路由策略进行了分表。

切入第二个只读用户（user），重复操作发现不能插入数据，只能读取：

7、Java测试

7.1 pom依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
​
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
​
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
​
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.22</version>
        </dependency>
​
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.20</version>
        </dependency>
​
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

7.2 spring配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
​
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <!--唯一的区别就在这里，把mycat逻辑库当正常数据库使用即可-->
        <property name="url" value="jdbc:mysql://192.168.223.128:8066/TESTDB?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=true"/>
        <property name="username" value="test"/>
        <property name="password" value="test"/>
    </bean>
</beans>

7.3 单元测试

package com.ydt.mycat;
​
​
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
​
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Date;
​
public class MyCatTest {
​
    @Test
    public void testQuery(){
        ApplicationContext context
                = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) context.getBean("dataSource");
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            //mycat查询和插入时的分片规则一样，怎么进去怎么出来，如：数据入库时分片1，那么查询时也会根据相同的分片机制从对应的分片将数据取出来；没条件或者条件不是分片规则中的分片字段，则全节点扫描，请尽量避免这种情况
            PreparedStatement preparedStatement = connection.prepareStatement("select * from item where id = 2");
            ResultSet resultSet = preparedStatement.executeQuery();
            while (resultSet.next()){
                System.out.println(resultSet.getObject(1));
                System.out.println(resultSet.getObject(2));
                System.out.println(resultSet.getObject(3));
            }
            preparedStatement.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
​
    @Test
    public void testInsert(){
        ApplicationContext context
                = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) context.getBean("dataSource");
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement("insert into item(id,value) values( 3,200)");
            System.out.println(preparedStatement.executeUpdate());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
​
    @Test
    public void testUpdate(){
        ApplicationContext context
                = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) context.getBean("dataSource");
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement("update item set value = 99 where id =1");
            System.out.println(preparedStatement.executeUpdate());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
​
    @Test
    public void testDelete(){
        ApplicationContext context
                = new ClassPathXmlApplicationContext("applicationContext.xml");
        DataSource dataSource = (DataSource) context.getBean("dataSource");
        Connection connection = null;
        try {
            connection = dataSource.getConnection();
            PreparedStatement preparedStatement = connection.prepareStatement("delete from users where id > 3");
            System.out.println(preparedStatement.executeUpdate());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
​

8、Mycat自定义分片机制

8.1 Mycat的源码包

源码地址：https://github.com/MyCATApache/Mycat-Server

获取后解压，如果用idea导入请去掉pom.xml中关于eclipse报错，如果使用eclipse时去掉idea配置报错项

8.2 自定义分片类

package io.mycat.route.function;
​
import io.mycat.config.model.rule.RuleAlgorithm;
​
public class MyPartition extends AbstractPartitionAlgorithm implements RuleAlgorithm {
    @Override
    public Integer calculate(String columnValue) {
        System.out.println("hello mycat");
        return 1;//这里表示分片路由键，从0开始，现在这里的1表示进入dataNode="node_db02,node_db03"中的node_db03
    }
}

8.3 打包替换

maven打包后替换掉mycat/lib目录下的Mycat-server-1.6.7.5-release.jar包，然后mycat的配置中使用自己的定义的分片类即可：

注意要将替换后的jar包赋权：chmod 777 Mycat-server-1.6.7.5-release.jar

修改rule.xml，增加分片方法：

增加分片策略

在schema.xml中使用自定义分片策略

测试是否所有的数据都会进入db03节点即可！

9、拓展

一、枚举法
<tableRule name="sharding-by-intfile">
    <rule>
      <columns>user_id</columns>
      <algorithm>hash-int</algorithm>
    </rule>
  </tableRule>
<function name="hash-int" class="io.mycat.route.function.PartitionByFileMap">
    <property name="mapFile">partition-hash-int.txt</property>
    <property name="type">0</property>
    <property name="defaultNode">0</property>
  </function>
 
partition-hash-int.txt 配置：
10000=0
10010=1
上面columns 标识将要分片的表字段，algorithm 分片函数，
其中分片函数配置中，mapFile标识配置文件名称，type默认值为0，0表示Integer，非零表示String，
所有的节点配置都是从0开始，及0代表节点1
/**
*  defaultNode 默认节点:小于0表示不设置默认节点，大于等于0表示设置默认节点,结点为指定的值
*
默认节点的作用：枚举分片时，如果碰到不识别的枚举值，就让它路由到默认节点
*                如果不配置默认节点（defaultNode值小于0表示不配置默认节点），碰到
*                不识别的枚举值就会报错，
*                like this：can't find datanode for sharding column:column_name val:ffffffff   
*/
 
二、固定分片hash算法
<tableRule name="rule1">
    <rule>
      <columns>user_id</columns>
      <algorithm>func1</algorithm>
    </rule>
</tableRule>
 
  <function name="func1" class="io.mycat.route.function.PartitionByLong">
    <property name="partitionCount">2,1</property>
    <property name="partitionLength">256,512</property>
  </function>
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数，
partitionCount 分片个数列表，partitionLength 分片范围列表
分区长度:默认为最大2^n=1024 ,即最大支持1024分区
约束 :
count,length两个数组的长度必须是一致的。
1024 = sum((count[i]*length[i])). count和length两个向量的点积恒等于1024
用法例子：
@Test
public void testPartition() {
// 本例的分区策略：希望将数据水平分成3份，前两份各占25%，第三份占50%。（故本例非均匀分区）
// |<---------------------1024------------------------>|
// |<----256--->|<----256--->|<----------512---------->|
// | partition0 | partition1 | partition2 |
// | 共2份,故count[0]=2 | 共1份，故count[1]=1 |
int[] count = new int[] { 2, 1 };
int[] length = new int[] { 256, 512 };
PartitionUtil pu = new PartitionUtil(count, length);
​
// 下面代码演示分别以offerId字段或memberId字段根据上述分区策略拆分的分配结果
int DEFAULT_STR_HEAD_LEN = 8; // cobar默认会配置为此值
long offerId = 12345;
String memberId = "qiushuo";
​
// 若根据offerId分配，partNo1将等于0，即按照上述分区策略，offerId为12345时将会被分配到partition0中
int partNo1 = pu.partition(offerId);
​
// 若根据memberId分配，partNo2将等于2，即按照上述分区策略，memberId为qiushuo时将会被分到partition2中
int partNo2 = pu.partition(memberId, 0, DEFAULT_STR_HEAD_LEN);
​
Assert.assertEquals(0, partNo1);
Assert.assertEquals(2, partNo2);
}
 
如果需要平均分配设置：平均分为4分片，partitionCount*partitionLength=1024
<function name="func1" class="org.opencloudb.route.function.PartitionByLong">
    <property name="partitionCount">4</property>
    <property name="partitionLength">256</property>
  </function>
 
三、范围约定
<tableRule name="auto-sharding-long">
    <rule>
      <columns>user_id</columns>
      <algorithm>rang-long</algorithm>
    </rule>
  </tableRule>
<function name="rang-long" class="io.mycat.route.function.AutoPartitionByLong">
    <property name="mapFile">autopartition-long.txt</property>
  </function>
# range start-end ,data node index
# K=1000,M=10000.
0-500M=0
500M-1000M=1
1000M-1500M=2
或
0-10000000=0
10000001-20000000=1
 
 
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数，
rang-long 函数中mapFile代表配置文件路径
所有的节点配置都是从0开始，及0代表节点1，此配置非常简单，即预先制定可能的id范围到某个分片
 
四、求模法
<tableRule name="mod-long">
    <rule>
      <columns>user_id</columns>
      <algorithm>mod-long</algorithm>
    </rule>
  </tableRule>
  <function name="mod-long" class="io.mycat.route.function.PartitionByMod">
   <!-- how many data nodes  -->
    <property name="count">3</property>
  </function>
 
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数，
此种配置非常明确即根据id与count（你的结点数）进行求模预算，相比方式1，此种在批量插入时需要切换数据源，id不连续
 
五、日期列分区法
<tableRule name="sharding-by-date">
      <rule>
        <columns>create_time</columns>
        <algorithm>sharding-by-date</algorithm>
      </rule>
   </tableRule>
<function name="sharding-by-date" class="io.mycat.route.function..PartitionByDate">
   <property name="dateFormat">yyyy-MM-dd</property>
    <property name="sBeginDate">2014-01-01</property>
    <property name="sPartionDay">10</property>
  </function>
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数，
配置中配置了开始日期，分区天数，即默认从开始日期算起，分隔10天一个分区
 
还有一切特性请看源码
 
 
Assert.assertEquals(true, 0 == partition.calculate("2014-01-01"));
Assert.assertEquals(true, 0 == partition.calculate("2014-01-10"));
Assert.assertEquals(true, 1 == partition.calculate("2014-01-11"));
Assert.assertEquals(true, 12 == partition.calculate("2014-05-01"));
 
 
 
六、通配取模
<tableRule name="sharding-by-pattern">
      <rule>
        <columns>user_id</columns>
        <algorithm>sharding-by-pattern</algorithm>
      </rule>
   </tableRule>
<function name="sharding-by-pattern" class="io.mycat.route.function.PartitionByPattern">
    <property name="patternValue">256</property>
    <property name="defaultNode">2</property>
    <property name="mapFile">partition-pattern.txt</property>
 
  </function>
partition-pattern.txt
# id partition range start-end ,data node index
###### first host configuration
1-32=0
33-64=1
65-96=2
97-128=3
######## second host configuration
129-160=4
161-192=5
193-224=6
225-256=7
0-0=7
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数，patternValue 即求模基数，defaoultNode 默认节点，如果不配置了默认，则默认是0即第一个结点
mapFile 配置文件路径
配置文件中，1-32 即代表id%256后分布的范围，如果在1-32则在分区1，其他类推，如果id非数字数据，则会分配在defaoultNode 默认节点
 
 
String idVal = "0";
Assert.assertEquals(true, 7 == autoPartition.calculate(idVal));
idVal = "45a";
Assert.assertEquals(true, 2 == autoPartition.calculate(idVal));
 
七、ASCII码求模通配
<tableRule name="sharding-by-prefixpattern">
      <rule>
        <columns>user_id</columns>
        <algorithm>sharding-by-prefixpattern</algorithm>
      </rule>
   </tableRule>
<function name="sharding-by-pattern" class="io.mycat.route.function.PartitionByPrefixPattern">
    <property name="patternValue">256</property>
    <property name="prefixLength">5</property>
    <property name="mapFile">partition-pattern.txt</property>
 
  </function>
 
partition-pattern.txt
 
# range start-end ,data node index
# ASCII
# 48-57=0-9
# 64、65-90=@、A-Z
# 97-122=a-z
###### first host configuration
1-4=0
5-8=1
9-12=2
13-16=3
###### second host configuration
17-20=4
21-24=5
25-28=6
29-32=7
0-0=7
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数，patternValue 即求模基数，prefixLength ASCII 截取的位数
mapFile 配置文件路径
配置文件中，1-32 即代表id%256后分布的范围，如果在1-32则在分区1，其他类推
 
此种方式类似方式6只不过采取的是将列种获取前prefixLength位列所有ASCII码的和进行求模sum%patternValue ,获取的值，在通配范围内的
即 分片数，
/**
* ASCII编码：
* 48-57=0-9阿拉伯数字
* 64、65-90=@、A-Z
* 97-122=a-z
*
*/
如
 
String idVal="gf89f9a";
Assert.assertEquals(true, 0==autoPartition.calculate(idVal));
​
idVal="8df99a";
Assert.assertEquals(true, 4==autoPartition.calculate(idVal));
​
idVal="8dhdf99a";
Assert.assertEquals(true, 3==autoPartition.calculate(idVal));
 
八、编程指定
<tableRule name="sharding-by-substring">
      <rule>
        <columns>user_id</columns>
        <algorithm>sharding-by-substring</algorithm>
      </rule>
   </tableRule>
<function name="sharding-by-substring" class="io.mycat.route.function.PartitionDirectBySubString">
    <property name="startIndex">0</property> <!-- zero-based -->
    <property name="size">2</property>
    <property name="partitionCount">8</property>
    <property name="defaultPartition">0</property>
  </function>
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数
此方法为直接根据字符子串（必须是数字）计算分区号（由应用传递参数，显式指定分区号）。
例如id=05-100000002
在此配置中代表根据id中从startIndex=0，开始，截取siz=2位数字即05，05就是获取的分区，如果没传默认分配到defaultPartition
 
九、字符串拆分hash解析
<tableRule name="sharding-by-stringhash">
      <rule>
        <columns>user_id</columns>
        <algorithm>sharding-by-stringhash</algorithm>
      </rule>
   </tableRule>
<function name="sharding-by-substring" class="io.mycat.route.function.PartitionByString">
    <property name=length>512</property> <!-- zero-based -->
    <property name="count">2</property>
    <property name="hashSlice">0:2</property>
  </function>
配置说明：
上面columns 标识将要分片的表字段，algorithm 分片函数
函数中length代表字符串hash求模基数，count分区数，hashSlice hash预算位
即根据子字符串 hash运算
 
hashSlice ： 0 means str.length(), -1 means str.length()-1
 
/**
     * "2" -&gt; (0,2)<br/>
     * "1:2" -&gt; (1,2)<br/>
     * "1:" -&gt; (1,0)<br/>
     * "-1:" -&gt; (-1,0)<br/>
     * ":-1" -&gt; (0,-1)<br/>
     * ":" -&gt; (0,0)<br/>
     */
public class PartitionByStringTest {
​
@Test
public void test() {
PartitionByString rule = new PartitionByString();
String idVal=null;
rule.setPartitionLength("512");
rule.setPartitionCount("2");
rule.init();
rule.setHashSlice("0:2");
//    idVal = "0";
//    Assert.assertEquals(true, 0 == rule.calculate(idVal));
//    idVal = "45a";
//    Assert.assertEquals(true, 1 == rule.calculate(idVal));
​
​
​
//last 4
rule = new PartitionByString();
rule.setPartitionLength("512");
rule.setPartitionCount("2");
rule.init();
//last 4 characters
rule.setHashSlice("-4:0");
idVal = "aaaabbb0000";
Assert.assertEquals(true, 0 == rule.calculate(idVal));
idVal = "aaaabbb2359";
Assert.assertEquals(true, 0 == rule.calculate(idVal));
}
 
十、一致性hash
<tableRule name="sharding-by-murmur">
      <rule>
        <columns>user_id</columns>
        <algorithm>murmur</algorithm>
      </rule>
   </tableRule>
<function name="murmur" class="io.mycat.route.function.PartitionByMurmurHash">
      <property name="seed">0</property><!-- 默认是0-->
      <property name="count">2</property><!-- 要分片的数据库节点数量，必须指定，否则没法分片—>
      <property name="virtualBucketTimes">160</property><!-- 一个实际的数据库节点被映射为这么多虚拟节点，默认是160倍，也就是虚拟节点数是物理节点数的160倍-->
      <!--
      <property name="weightMapFile">weightMapFile</property>
                     节点的权重，没有指定权重的节点默认是1。以properties文件的格式填写，以从0开始到count-1的整数值也就是节点索引为key，以节点权重值为值。所有权重值必须是正整数，否则以1代替 -->
      <!--
      <property name="bucketMapPath">/etc/mycat/bucketMapPath</property>
                      用于测试时观察各物理节点与虚拟节点的分布情况，如果指定了这个属性，会把虚拟节点的murmur hash值与物理节点的映射按行输出到这个文件，没有默认值，如果不指定，就不会输出任何东西 -->
  </function>