【ShardingSphere】ShardingSphere-JDBC 集成SpringBoot

一、 快速入门

　　【ShardingSphere】ShardingSphere-JDBC 快速入门

二、集成SpringBoot

　　数据库表，使用快速入门的项目表

　　1、新建SpringBoot项目，引入相关依赖

<!-- sharding-jdbc -->
<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>4.1.1</version>
</dependency>

 　　完整pom文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>test-springboot-sharding-jdbc</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- sharding-jdbc -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>

    </dependencies>


    <!-- SpringBoot打包插件，可以将代码打包成一个可执行的jar包 -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.5.RELEASE</version>
            </plugin>
        </plugins>
    </build>
</project>

 

 　　2、编辑SpringBoot启动文件

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

 　　3、编辑application.properties文件

数据分片功能配置

# 更多参考：https://shardingsphere.apache.org/document/4.1.1/cn/manual/sharding-jdbc/configuration/config-spring-boot/

# Spring数据源 被shardingsphere数据源替代
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?allowPublicKeyRetrieval=true&useSSL=true
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=123456


# ==========数据源配置==========
# 配置真实数据源名称
spring.shardingsphere.datasource.names=ds0,ds1
# 指定默认数据源，不指定时,轮询获取各个数据源的值
spring.shardingsphere.sharding.default-data-source-name=ds0
# 显示shardingsphere执行的sql
spring.shardingsphere.props.sql.show=true

# 配置第 1 个数据源
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://192.168.0.1:3306/test-shardingjdbc1?allowPublicKeyRetrieval=true&useSSL=true
spring.shardingsphere.datasource.ds0.username=root
spring.shardingsphere.datasource.ds0.password=123456

# 配置第 2 个数据源
spring.shardingsphere.datasource.ds1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.ds1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.ds1.jdbc-url=jdbc:mysql://192.168.0.1:3306/test-shardingjdbc2?allowPublicKeyRetrieval=true&useSSL=true
spring.shardingsphere.datasource.ds1.username=root
spring.shardingsphere.datasource.ds1.password=123456


## ==========数据分片默认配置==========

# 默认行表达式 数据库分片策略
# 默认行表达式 数据库分片策略 列
spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
# 默认数据库分片策略 算法表达式
spring.shardingsphere.sharding.default-database-strategy.inline.algorithm-expression=ds${user_id % 2}

# 默认行表达式 分片策略
# 默认行表达式 分片策略 列
spring.shardingsphere.sharding.default-table-strategy.inline.sharding-column=order_id
# 默认行表达式分片策略 算法表达式
spring.shardingsphere.sharding.default-table-strategy.inline.algorithm-expression=t_order_${order_id % 2}

## 默认自增列名称，缺省表示不使用自增主键生成器
#spring.shardingsphere.sharding.default-key-generate-strategy.xxx=
## 默认自增列值生成器类型，缺省表示使用默认自增列值生成器。可使用用户自定义的列值生成器或选择内置类型：SNOWFLAKE/UUID
#spring.shardingsphere.sharding.default-sharding-column=

## 用于单分片键的标准分片场景
#spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-column= # 分片列名称
#spring.shardingsphere.rules.sharding.tables.t_order.database-strategy.standard.sharding-algorithm-name= # 分片算法名称


## ==========数据分片具体配置==========
# 分片表配置
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds${0..1}.t_order_${0..1}
# 行表达式 数据库分片策略,可覆盖默认配置
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression=ds${user_id % 2}
# 行表达式 分片策略,可覆盖默认配置
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_${order_id % 2}
# 自增列名称，缺省表示不使用自增主键生成器
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
# 自增列值生成器类型，缺省表示使用默认自增列值生成器。可使用用户自定义的列值生成器或选择内置类型：SNOWFLAKE/UUID
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE

#用于单分片键的标准分片场景
#分片列名称
#spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.sharding-column=order_id
# 精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
#spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.precise-algorithm-class-name=com.test.springboot.sharding.algorithm.CustomShardingAlgorithm
# 范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
#spring.shardingsphere.sharding.tables.<logic-table-name>.database-strategy.standard.range-algorithm-class-name=


spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds$->{0..1}.t_order_item_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE

# 绑定表-关联查询时有效
# 指分片规则一致的主表和子表。例如： t_order 表和 t_order_item 表，均按照 order_id 分片,绑定表之间的分区键完全相同，则此两张表互为绑定表关系
spring.shardingsphere.sharding.binding-tables[0]=t_order,t_order_item
# 广播表
spring.shardingsphere.sharding.broadcast-tables=t_config

　　测试：

package com.test.springboot.sharding;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestApplication {

    @Autowired
    private DataSource dataSource;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Test
    public void context() throws SQLException {
        System.out.println("========");
        System.out.println("dataSource ====" + dataSource);

        Connection connection = dataSource.getConnection();
        System.out.println("connecttion ====" + connection);

        Connection connection1 = jdbcTemplate.getDataSource().getConnection();
        System.out.println("connection1 = " + connection1);

        List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from t_config");
        System.out.println(maps);
//        jdbcTemplate.execute("insert into t_config values(5, 'finish')");
    }

    @Test
    public void test02() throws SQLException {

        List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from t_order where user_id = 10 and order_id = 1000");
        System.out.println(maps);
    }

    @Test
    public void test03() throws SQLException {
        System.out.println("\"668421745522245632\".length() = " + "668421745522245632".length());
        jdbcTemplate.execute("insert into t_order(`user_id`, `status`) values(10, 'init')");

    }


    @Test
    public void test04() throws SQLException {
        String sql = "SELECT i.* FROM  t_order o, t_order_item i WHERE o.order_id = i.order_id AND o.order_id = 100 AND o.user_id = 10";
        List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
        System.out.println("maps = " + maps);

    }

}

自定义分片策略类

CustomShardingAlgorithm，用法请查看配置

package com.test.springboot.sharding.algorithm;

import org.apache.shardingsphere.api.sharding.standard.PreciseShardingAlgorithm;
import org.apache.shardingsphere.api.sharding.standard.PreciseShardingValue;

import java.util.Collection;


public class CustomShardingAlgorithm implements PreciseShardingAlgorithm<Integer> {

    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Integer> shardingValue) {
        String value = shardingValue.getValue().toString();
        for (String targetName : availableTargetNames) {
            Integer i = Integer.parseInt(value) % 2;
            if (targetName.contains(i.toString())) {
                return targetName;
            }
        }
        throw new IllegalArgumentException();
    }
}

数据分片+读写分离功能配置

## ==========数据分片具体配置==========
# 分片表配置
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes=ds${0..1}.t_order_${0..1}
# 行表达式 数据库分片策略,可覆盖默认配置
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column=user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression=ds${user_id % 2}
# 行表达式 分片策略,可覆盖默认配置
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression=t_order_${order_id % 2}
# 自增列名称，缺省表示不使用自增主键生成器
spring.shardingsphere.sharding.tables.t_order.key-generator.column=order_id
# 自增列值生成器类型，缺省表示使用默认自增列值生成器。可使用用户自定义的列值生成器或选择内置类型：SNOWFLAKE/UUID
spring.shardingsphere.sharding.tables.t_order.key-generator.type=SNOWFLAKE

#用于单分片键的标准分片场景
#分片列名称
#spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.sharding-column=order_id
# 精确分片算法类名称，用于=和IN。该类需实现PreciseShardingAlgorithm接口并提供无参数的构造器
#spring.shardingsphere.sharding.tables.t_order.table-strategy.standard.precise-algorithm-class-name=com.test.springboot.sharding.algorithm.CustomShardingAlgorithm
# 范围分片算法类名称，用于BETWEEN，可选。该类需实现RangeShardingAlgorithm接口并提供无参数的构造器
#spring.shardingsphere.sharding.tables.<logic-table-name>.database-strategy.standard.range-algorithm-class-name=


spring.shardingsphere.sharding.tables.t_order_item.actual-data-nodes=ds$->{0..1}.t_order_item_$->{0..1}
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.sharding-column=order_id
spring.shardingsphere.sharding.tables.t_order_item.table-strategy.inline.algorithm-expression=t_order_item_$->{order_id % 2}
spring.shardingsphere.sharding.tables.t_order_item.key-generator.column=item_id
spring.shardingsphere.sharding.tables.t_order_item.key-generator.type=SNOWFLAKE

# 绑定表-关联查询时有效
# 指分片规则一致的主表和子表。例如： t_order 表和 t_order_item 表，均按照 order_id 分片,绑定表之间的分区键完全相同，则此两张表互为绑定表关系
spring.shardingsphere.sharding.binding-tables[0]=t_order,t_order_item
# 广播表
spring.shardingsphere.sharding.broadcast-tables=t_config

## ==========读写分离配置==========
# 配置真实数据源名称
spring.shardingsphere.datasource.names=master0,slave0,master1,slave1
# 指定默认数据源，不指定时,轮询获取各个数据源的值
spring.shardingsphere.sharding.default-data-source-name=ds0
# 显示shardingsphere执行的sql
spring.shardingsphere.props.sql.show=true

# 配置第 1 个数据源
spring.shardingsphere.datasource.master0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.master0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.master0.jdbc-url=jdbc:mysql://192.168.0.1:3306/test-shardingjdbc1?allowPublicKeyRetrieval=true&useSSL=true
spring.shardingsphere.datasource.master0.username=hd
spring.shardingsphere.datasource.master0.password=hd123456

# 配置第 2 个数据源
spring.shardingsphere.datasource.master1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.master1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.master1.jdbc-url=jdbc:mysql://192.168.0.1:3306/test-shardingjdbc2?allowPublicKeyRetrieval=true&useSSL=true
spring.shardingsphere.datasource.master1.username=hd
spring.shardingsphere.datasource.master1.password=hd123456
# 配置第 3 个数据源
spring.shardingsphere.datasource.slave0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.slave0.jdbc-url=jdbc:mysql://192.168.0.2:3306/test-shardingjdbc1?allowPublicKeyRetrieval=true&useSSL=true
spring.shardingsphere.datasource.slave0.username=hd
spring.shardingsphere.datasource.slave0.password=hd123456

# 配置第 4 个数据源
spring.shardingsphere.datasource.slave1.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.slave1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.slave1.jdbc-url=jdbc:mysql://192.168.0.2:3306/test-shardingjdbc2?allowPublicKeyRetrieval=true&useSSL=true
spring.shardingsphere.datasource.slave1.username=hd
spring.shardingsphere.datasource.slave1.password=hd123456

# 主从数据源规则配置
spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-source-name=master0
spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-source-names=slave0
spring.shardingsphere.sharding.master-slave-rules.ds1.master-data-source-name=master1
spring.shardingsphere.sharding.master-slave-rules.ds1.slave-data-source-names=slave1 

 测试

　　同上

数据脱敏功能配置

sql文件

CREATE TABLE `user` (
  `id` bigint(20) NOT NULL,
  `username` varchar(255) DEFAULT NULL,
  `password` varchar(255) DEFAULT NULL,
  `md5_password` varchar(255) DEFAULT NULL,
  `aes_password` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

配置

## ==========数据脱敏==========
#加解密器类型，可自定义或选择内置类型：MD5/AES
spring.shardingsphere.sharding.encrypt-rule.encryptors.encryptor_aes.type=aes
#属性配置, 注意：使用AES加密器，需要配置AES加密器的KEY属性：aes.key.value
spring.shardingsphere.sharding.encrypt-rule.encryptors.encryptor_aes.props.aes.key.value=123456

#加解密器2
spring.shardingsphere.sharding.encrypt-rule.encryptors.encryptor_md5.type=md5

#加解密器3
spring.shardingsphere.sharding.encrypt-rule.encryptors.encryptor_cust.type=cust

#存储明文的字段
#spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd.plainColumn=password
#存储密文的字段
spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd.cipherColumn=md5_password
#加密器名字
spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd.encryptor=encryptor_aes
#spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd.encryptor=encryptor_cust

#spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd2.plainColumn=password
spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd2.cipherColumn=aes_password
spring.shardingsphere.sharding.encrypt-rule.tables.user.columns.pwd2.encryptor=encryptor_aes

测试

    @Test
    public void test05() throws SQLException {
        jdbcTemplate.update("insert into user(`id`, password, pwd, pwd2) values(?, ?, ?, ?)", new Object[]{5, "abc", "abc", "abc"});

    }

 

自定义脱敏策略

编辑策略类

public final class CustomShardingEncryptor implements Encryptor {
    @Override
    public void init() {
        System.out.println("CustomShardingEncryptor#init()...");
    }

    @Override
    public String encrypt(Object plaintext) {
        return "abc" + plaintext.toString();
    }

    @Override
    public Object decrypt(String ciphertext) {
        return ciphertext.substring(2);
    }

    @Override
    public String getType() {
        return "CUST";
    }

    @Override
    public Properties getProperties() {
        return null;
    }

    @Override
    public void setProperties(Properties properties) {
        AESEncryptor aesEncryptor = new AESEncryptor();
    }
}

由于shardingsphere用到了spi技术，在resources/META-INF/services下的文件，新建文件 org.apache.shardingsphere.encrypt.strategy.spi.Encryptor

内容如下：

com.test.springboot.sharding.encrypt.CustomShardingEncryptor

 这样既能使自定义的脱敏策略生效