shading-jdbc 4.1.1 + tk.mybatis + pagehelper 1.3.x +spring boot 2.x 使用注意事项

shading-jdbc 4.1.1 + tk.mybatis + pagehelper 1.3.x + spring boot 2.x  是一个很常用的组合，但在使用过程中可能会遇到一些小问题，记录于此：

一、pom依赖

主要有以下几个：

<properties>
        <java.version>1.8</java.version>
        <sharding-sphere.version>4.1.1</sharding-sphere.version>
        <tk.mybatis.version>2.1.5</tk.mybatis.version>
        <mybatis.starter.version>2.1.3</mybatis.starter.version>
        <pagehelper.version>1.3.0</pagehelper.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- spring-boot-->
            <dependency>
                <groupId>org.apache.shardingsphere</groupId>
                <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
                <version>${sharding-sphere.version}</version>
            </dependency>

            <!--tk.mybatis-->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>${tk.mybatis.version}</version>
            </dependency>

            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.starter.version}</version>
            </dependency>

            <!--pagehelper-->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>${pagehelper.version}</version>
            </dependency>

        </dependencies>
    </dependencyManagement>

二、application.properties

#数据源
spring.shardingsphere.datasource.names=ds0
spring.shardingsphere.sharding.default-data-source-name=ds0
spring.shardingsphere.datasource.ds0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds0.jdbc-url=jdbc:mysql://127.0.0.1:3306/testdb?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=***
#分表
spring.shardingsphere.sharding.tables.t_order_logic.actual-data-nodes=ds0.t_order_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_logic.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_logic.table-strategy.inline.algorithm-expression=t_order_$->{order_id % 2}
spring.shardingsphere.props.sql.show=true
#精确路由
spring.shardingsphere.sharding.tables.t_order_logic_0.actual-data-nodes=ds0.t_order_0
spring.shardingsphere.sharding.tables.t_order_logic_1.actual-data-nodes=ds0.t_order_1
#mybatis
mybatis.mapper-locations=classpath*:mapper/*.xml

注：

* 这里只演示了单库分表的最小配置

* 注意里面有一个“精确路由”的配置，有时候我们明确知道数据就在某个具体分表上，但是sql的where条件中又不包含sharding-key，就可以参考上述配置，当查询t_order_logic_0时，直接路由到ds0.t_order_0这张表 

t_order_0/t_order_1表结构如下：

CREATE TABLE `t_order_0` (
  `order_id` bigint(20) unsigned NOT NULL,
  `order_name` varchar(255) NOT NULL,
  `order_date` varchar(255) NOT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

CREATE TABLE `t_order_1` (
  `order_id` bigint(20) unsigned NOT NULL,
  `order_name` varchar(255) NOT NULL,
  `order_date` varchar(255) NOT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

三、mybatis自动生成tk.mybatis风格的代码

3.1 先配置plugin

<plugin>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-maven-plugin</artifactId>
    <version>1.3.7</version>
    <configuration>
        <configurationFile>src/main/resources/generator/generatorConfig.xml</configurationFile>
        <overwrite>true</overwrite>
        <verbose>true</verbose>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.1.5</version>
        </dependency>
    </dependencies>
</plugin>

3.2 再配置generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>

    <context id="Mysql" targetRuntime="MyBatis3" defaultModelType="flat">
        <property name="beginningDelimiter" value="`"/>
        <property name="endingDelimiter" value="`"/>

        <plugin type="tk.mybatis.mapper.generator.MapperPlugin">
            <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
            <property name="caseSensitive" value="true"/>
            <property name="useActualColumnNames" value="true"/>
            <property name="beginningDelimiter" value="`"/>
            <property name="endingDelimiter" value="`"/>
        </plugin>


        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://127.0.0.1:3306/testdb"
                        userId="root"
                        password="***"/>

        <javaModelGenerator
                targetPackage="test.entity"
                targetProject="src/test/java"/>

        <sqlMapGenerator targetPackage="mapper" targetProject="src/test/resources"/>

        <javaClientGenerator targetPackage="test.mapper"
                             targetProject="src/test/java"
                             type="XMLMAPPER">
            <property name="enableSubPackages" value="true"/>
        </javaClientGenerator>

        <!--        注：生成的OrderEntity，实际对应的表名为t_order_0，并非逻辑表t_order_logic-->
        <!--        解决办法有2个：-->
        <!--        1. 生成后，手动修改@Table(name = "`t_order_0`")为@Table(name = "`t_order_logic`")-->
        <!--        2. 直接在db中创建一个t_order_logic的表，仅用于生成代码-->
        <table tableName="t_order_0" domainObjectName="OrderEntity"
               enableCountByExample="false" enableUpdateByExample="false"
               enableDeleteByExample="false" enableSelectByExample="false"
               selectByExampleQueryId="false">
            <generatedKey column="order_id" sqlStatement="MYSQL" identity="true"/>
        </table>
        
    </context>
</generatorConfiguration>

四、分布式id的问题

sharding-jdbc内置了snowflake算法，但是集成tk.mybatis生成记录后，并不能马上返回自动生成的id值，如下图：

从输出的sql语句上看，sharding-jdbc改写了sql语句，附加了order_id字段，并用snowflake算法生成了新id，但是insert成功后，entity的orderId仍为null。

tips: 要开启sharding-jdbc的snowflake功能，需要修改下面2点

1. application.properties中必须指定snowflake

spring.shardingsphere.sharding.tables.t_order_logic.key-generator.column=order_id
spring.shardingsphere.sharding.tables.t_order_logic.key-generator.type=SNOWFLAKE

2. 表结构上的自增主键id，需要把entity类的自动生成主键注释掉

如果insert成功后，要拿到新的id值，建议id字段在insert前就手动赋值，参考下面的做法，直接调用内置的snowflake生成器：

创建一个IdService服务：

package com.cnblogs.yjmyzz.sharding.jdbc.demo.service;

import com.cnblogs.yjmyzz.sharding.jdbc.demo.utils.NetworkUtils;
import org.apache.shardingsphere.core.strategy.keygen.SnowflakeShardingKeyGenerator;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Service;

import java.math.BigInteger;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicInteger;

@Service("idService")
public class IdService implements InitializingBean {
    private AtomicInteger serverIndex = new AtomicInteger(0);

    private static final SnowflakeShardingKeyGenerator keyGenerator = new SnowflakeShardingKeyGenerator();

    public long nextId() {
        return (Long) keyGenerator.generateKey();
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        BigInteger ipAddrBigInt = NetworkUtils.ipAddressToBigInt(NetworkUtils.getLocalHostAddress());
        //假设服务器最多512台
        BigInteger base = new BigInteger("512");
        serverIndex.set(ipAddrBigInt.mod(base).intValue());
        synchronized (this) {
            Properties prop = keyGenerator.getProperties();
            prop.setProperty("worker.id", serverIndex.toString());
            keyGenerator.setProperties(prop);
        }
    }
}

注：snowflake算法要求设置1个唯一的worker.id，防止多个服务器生成相同的id，这里我们取服务器的ip地址，转换成数字，再对集群节点数取模，保证整个集群内唯一。

这里有一个小工具类，用于取服务器ip地址：

package com.cnblogs.yjmyzz.sharding.jdbc.demo.utils;


import java.math.BigInteger;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.UnknownHostException;
import java.util.Enumeration;

public final class NetworkUtils {
    public NetworkUtils() {
    }

    public static String getLocalHostAddress() {
        InetAddress addr = null;

        try {
            addr = getLocalHostLANAddress();
        } catch (UnknownHostException var2) {
            return "";
        }

        return addr != null ? addr.getHostAddress() : "";
    }

    public static InetAddress getLocalHostLANAddress() throws UnknownHostException {
        try {
            InetAddress candidateAddress = null;
            Enumeration ifaces = NetworkInterface.getNetworkInterfaces();

            while (ifaces.hasMoreElements()) {
                NetworkInterface iface = (NetworkInterface) ifaces.nextElement();
                Enumeration inetAddrs = iface.getInetAddresses();

                while (inetAddrs.hasMoreElements()) {
                    InetAddress inetAddr = (InetAddress) inetAddrs.nextElement();
                    if (!inetAddr.isLoopbackAddress()) {
                        if (inetAddr.isSiteLocalAddress()) {
                            return inetAddr;
                        }

                        if (candidateAddress == null) {
                            candidateAddress = inetAddr;
                        }
                    }
                }
            }

            if (candidateAddress != null) {
                return candidateAddress;
            } else {
                InetAddress jdkSuppliedAddress = InetAddress.getLocalHost();
                if (jdkSuppliedAddress == null) {
                    throw new UnknownHostException("The JDK InetAddress.getLocalHost() method unexpectedly returned null.");
                } else {
                    return jdkSuppliedAddress;
                }
            }
        } catch (Exception var5) {
            UnknownHostException unknownHostException = new UnknownHostException("Failed to determine LAN address: " + var5);
            unknownHostException.initCause(var5);
            throw unknownHostException;
        }
    }

    public static BigInteger ipAddressToBigInt(String ipInString) {
        ipInString = ipInString.replace(" ", "");
        byte[] bytes;
        if (ipInString.contains(":")) {
            bytes = ipv6ToBytes(ipInString);
        } else {
            bytes = ipv4ToBytes(ipInString);
        }

        return new BigInteger(bytes);
    }

    public static String bigIntToIpAddress(BigInteger ipInBigInt) {
        byte[] bytes = ipInBigInt.toByteArray();
        byte[] unsignedBytes = bytes;

        try {
            String ip = InetAddress.getByAddress(unsignedBytes).toString();
            return ip.substring(ip.indexOf(47) + 1).trim();
        } catch (UnknownHostException var4) {
            throw new RuntimeException(var4);
        }
    }

    private static byte[] ipv6ToBytes(String ipv6) {
        byte[] ret = new byte[17];
        ret[0] = 0;
        int ib = 16;
        boolean comFlag = false;
        if (ipv6.startsWith(":")) {
            ipv6 = ipv6.substring(1);
        }

        String[] groups = ipv6.split(":");

        for (int ig = groups.length - 1; ig > -1; --ig) {
            if (groups[ig].contains(".")) {
                byte[] temp = ipv4ToBytes(groups[ig]);
                ret[ib--] = temp[4];
                ret[ib--] = temp[3];
                ret[ib--] = temp[2];
                ret[ib--] = temp[1];
                comFlag = true;
            } else {
                int temp;
                if ("".equals(groups[ig])) {
                    for (temp = 9 - (groups.length + (comFlag ? 1 : 0)); temp-- > 0; ret[ib--] = 0) {
                        ret[ib--] = 0;
                    }
                } else {
                    temp = Integer.parseInt(groups[ig], 16);
                    ret[ib--] = (byte) temp;
                    ret[ib--] = (byte) (temp >> 8);
                }
            }
        }

        return ret;
    }

    private static byte[] ipv4ToBytes(String ipv4) {
        byte[] ret = new byte[5];
        ret[0] = 0;
        int position1 = ipv4.indexOf(".");
        int position2 = ipv4.indexOf(".", position1 + 1);
        int position3 = ipv4.indexOf(".", position2 + 1);
        ret[1] = (byte) Integer.parseInt(ipv4.substring(0, position1));
        ret[2] = (byte) Integer.parseInt(ipv4.substring(position1 + 1, position2));
        ret[3] = (byte) Integer.parseInt(ipv4.substring(position2 + 1, position3));
        ret[4] = (byte) Integer.parseInt(ipv4.substring(position3 + 1));
        return ret;
    }

    public static boolean ipCheck(String tip, String[][] myRange) {
        boolean flag = false;
        BigInteger tbig = ipAddressToBigInt(tip);
        int rangeLength = myRange.length;

        for (int i = 0; i < rangeLength; ++i) {
            for (int j = 0; j < myRange[i].length; ++j) {
                BigInteger sbig = ipAddressToBigInt(myRange[i][j]);
                ++j;
                BigInteger ebig = ipAddressToBigInt(myRange[i][j]);
                if (tbig.compareTo(sbig) == 0) {
                    flag = true;
                    break;
                }

                if (tbig.compareTo(sbig) == 1 && tbig.compareTo(ebig) == -1) {
                    flag = true;
                    break;
                }
            }
        }

        return flag;
    }

    class IpRange {
        private String[][] ipRange;

        public IpRange(String[][] ip) {
            this.ipRange = ip;
        }

        public String getIpAt(int row, int column) {
            return this.ipRange[row][column];
        }
    }
}

有了IdService后，在insert前，调用nextId()生成新id，直接赋值给entity即可。

五、MapperScan包名问题

MapperScan有2个，1个是mybatis自带的，1个是tk.mybatis的，集成tk.mybatis时，注意要使用tk.mybatis的MapperScan

六、PageHelper的count问题

PageHelper为了算总记录条数，会改写原始sql，做1次count，比如：

select order_id, order_name, order_date from t_order_logic_0 where order_date='2020-09-06';

 会首先被改写为：

select count(0) from t_order_logic_0 where order_date='2020-09-06';

然后再由sharding-jdbc改写成:(精确路由)

select count(0) from t_order_0 where order_date='2020-09-06';

对于简单语句，这样没什么问题。但是如果原始语句上，有一些聚合函数或group by，比如下面这样：　

如上图，加了group by 后，下面的语句

SELECT count(0) FROM (SELECT order_id FROM t_order_logic WHERE order_date = ? GROUP BY order_id) table_count

sharding-jdbc并不能正确解析为t_order_0，仍然还是t_order_logic

SELECT count(0) FROM (SELECT order_id FROM t_order_logic WHERE order_date = ? GROUP BY order_id) table_count ::: [2020-09-06]

解决办法：pagehelper对于count语句，允许用户自定义，只要在原来的语句id，加上“_COUNT”

    <select id="selectList2" resultMap="BaseResultMap">
        select order_id from t_order_logic${tableIndex} where order_date=#{orderDate} group by order_id
    </select>

    <select id="selectList2_COUNT" resultType="long">
        select count(1) from t_order_logic${tableIndex} where order_date=#{orderDate} group by order_id
    </select>

再运行一下：

现在就正常了。　　

示例代码已经上传到github，地址：https://github.com/yjmyzz/shardingjdbc-mybatis-pagehelper-springboot-demo