# Sharding-JDBC从入门到精通（6）-- Sharding-JDBC 水平分库 和 垂直分库。

news2024/7/6 20:47:43

Sharding-JDBC从入门到精通（6）-- Sharding-JDBC 水平分库 和 垂直分库。

一、Sharding-JDBC 水平分库-分片策略配置

1、分库策略定义方式如下

# 分库策略，如何将一个逻辑表映射到多个数据源
spring.shardingsphere.sharding.tables.<逻辑表名称>.qatabase-strategy.<分片策略>.<分片策略属性名>= #分片策略属性值

# 分表策略，如何将一个逻辑表映射为多个实际表
spring.shardingsphere.sharding.tables.<逻辑表名称>.table-strategy.<分片策略>.<分片策略属性名>= #分片策略属性值


# 分库策略：以 user_id 为分片键，分片策略为 user_id % 2 + 1，user_id 为偶数操作 m1 数据源，否则操作 m2
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}

2、分片规则修改：

由于数据库需要拆分了两个，这里需要配置两个数据源。
分库需要配置分库的策略，和分表策略的意义类似，通过分库策略实现数据操作针对分库的数据库进行操作。

# 配置 sharding-jdbc 分片规则（2024-6-29 分片规则修改）
# 定义数据源(定义 多个 数据源名为 m1, m2)
spring.shardingsphere.datasource.names = m1,m2

spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 12311

spring.shardingsphere.datasource.m2.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = 12311

3、在 sharding_jdbc_simple 子工程（子模块）中，修改 application.properties 配置文件，添加配置分库策略。

#  dbsharding\sharding_jdbc_simple\src\main\resources\application.properties

server.port = 56081

spring.application.name = sharding-jdbc-simple-demo

server.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = true

spring.main.allow-bean-definition-overriding = true
mybatis.configuration.map-underscore-to-camel-case = true

# 配置 sharding-jdbc 分片规则（2024-6-29 分片规则修改）
# 定义数据源(定义 多个 数据源名为 m1, m2)
spring.shardingsphere.datasource.names = m1,m2

spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 12311

spring.shardingsphere.datasource.m2.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = 12311

# 分库策略：以 user_id 为分片键，分片策略为 user_id % 2 + 1，user_id 为偶数操作 m1 数据源，否则操作 m2
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}


# 指定 t_order 表的数据分布情况，配置数据节点(t_order 映射到 t_order_1 或者 t_order_2)
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m1.t_order_$->{1..2}

# 指定 t_order 表的主键生成策略为 SNOWFLAKE（雪花算法）
spring.shardingsphere.sharding.tables.t_order.key-generator.column = order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type = SNOWFLAKE

# 指定 t_order 表的分片策略，分片策略包括分片键和分片算法
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 + 1}

# 打开 sql 输出日志
spring.shardingsphere.props.sql.show = true

swagger.enable = true

logging.level.root = info
logging.level.org.springframework.web = info
logging.level.djh.it.dbsharding = debug
logging.level.druid.sql = debug

4、Sharding-JDBC 支持以下几种分片策略:

不管理分库还是分表，策略基本一样。

  • standard: 标准分片策略，对应 Standardshardingstrategy。提供对 SQL 语句中的 =,IN 和 BETWEEN AND 的分片操作支持。StandardShardingStrategy 只支持单分片键，提供 PreciseShardingAlgorithm 和 RangeShardingAlgorithm 两个分片算法。PreciseShardingAlgorithm 是必选的,用于处理 = 和 IN 的分片。RangeShardingAlgorithm 是可选的，用于处理 BETWEEN AND 分片，如果不配置 RangeshardingAlgorithm，SQL 中的 BETWEEN AND 将按照全库路由处理。

  • complex: 符合分片策略，对应 ComplexshardingStrategy。复合分片策略。提供对 SQL 语句中的 =,IN 和 BETWEEN AND 的分片操作支持。ComplexshardingStrategy 支持多分片键，由于多分片键之间的关系复杂因此并未进行过多的封装，而是直接将分片键值组合以及分片操作符透传至分片算法，完全由应用开发者实现，提供最大的灵活度。

  • inline: 行表达式分片策略，对应 InlineshardingStrategy。使用 Groovy 的表达式，提供对 SQL 语句中的 = 和 IN 的分片操作支持，只支持单分片键。对于简单的分片算法，可以通过简单的配置使用,从而避免繁琐的 Java 代码开发，如:t_user_$->{u id % 8} 表示 t_user 表根据u_id 模8,而分成8张表,表名称为 t_user_0 到 t_user_7。

  • hint: Hint 分片策略，对应 HintShardingStrategy。通过 Hint 而非 SQL 解析的方式分片的策略。对于分片字段非 SQL决 定，而由其他外置条件决定的场景，可使用 SQLHint 灵活的注入分片字段。例:内部系统，按照员工登录主键分库，而数据库中并无此字段。SQL Hint 支持通过 Java API 和 SQL 注释(待实现)两种方式使用。

  • none : 不分片策略，对应 NoneShardingStrategy。不分片的策略。

5、创建两个数据库：order_db_1, order_db_2

CREATE DATABASE `order_db_1` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';
CREATE DATABASE `order_db_2` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

6、在 order_db_1, order_db_2 中分别 创建 t_order_1 和 t_order_2 两个表：


# 在 数据库 order_db_1 中，创建两张表。

USE `order_db_1`;

# 创建  t_order_1 表

DROP TABLE IF EXISTS `t_order_1`;

CREATE TABLE `t_order_1` (
`order_id` BIGINT(20) NOT NULL COMMENT '订单id',
`price` DECIMAL(10,2) NOT NULL COMMENT '订单价格',
`user_id` BIGINT(20) NOT NULL COMMENT '下单用户id', 
`status` VARCHAR(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
PRIMARY KEY(`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;


# 创建  t_order_2 表

DROP TABLE IF EXISTS `t_order_2`;

CREATE TABLE `t_order_2` (
`order_id` BIGINT(20) NOT NULL COMMENT '订单id',
`price` DECIMAL(10,2) NOT NULL COMMENT '订单价格',
`user_id` BIGINT(20) NOT NULL COMMENT '下单用户id', 
`status` VARCHAR(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
PRIMARY KEY(`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;



# 在 数据库 order_db_2 中，创建两张表。

USE `order_db_2`;

# 创建  t_order_1 表

DROP TABLE IF EXISTS `t_order_1`;

CREATE TABLE `t_order_1` (
`order_id` BIGINT(20) NOT NULL COMMENT '订单id',
`price` DECIMAL(10,2) NOT NULL COMMENT '订单价格',
`user_id` BIGINT(20) NOT NULL COMMENT '下单用户id', 
`status` VARCHAR(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
PRIMARY KEY(`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;


# 创建  t_order_2 表

DROP TABLE IF EXISTS `t_order_2`;

CREATE TABLE `t_order_2` (
`order_id` BIGINT(20) NOT NULL COMMENT '订单id',
`price` DECIMAL(10,2) NOT NULL COMMENT '订单价格',
`user_id` BIGINT(20) NOT NULL COMMENT '下单用户id', 
`status` VARCHAR(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '订单状态',
PRIMARY KEY(`order_id`) USING BTREE
) ENGINE = INNODB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

二、Sharding-JDBC 水平分库-插入订单

1、在 sharding_jdbc_simple 子工程（子模块）中，修改 application.properties 配置文件，添加配置分库策略。

#  dbsharding\sharding_jdbc_simple\src\main\resources\application.properties

server.port = 56081

spring.application.name = sharding-jdbc-simple-demo

server.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = true

spring.main.allow-bean-definition-overriding = true
mybatis.configuration.map-underscore-to-camel-case = true

# 配置 sharding-jdbc 分片规则（2024-6-29 分片规则修改）
# 定义数据源(定义 多个 数据源名为 m1, m2)
spring.shardingsphere.datasource.names = m1,m2

spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 12311

spring.shardingsphere.datasource.m2.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = 12311

# 分库策略：以 user_id 为分片键，分片策略为 user_id % 2 + 1，user_id 为偶数操作 m1 数据源，否则操作 m2
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}


# 指定 t_order 表的数据分布情况，配置数据节点(t_order 映射到 t_order_1 或者 t_order_2)
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m1.t_order_$->{1..2}

# 指定 t_order 表的主键生成策略为 SNOWFLAKE（雪花算法）
spring.shardingsphere.sharding.tables.t_order.key-generator.column = order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type = SNOWFLAKE

# 指定 t_order 表的分片策略，分片策略包括分片键和分片算法
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 + 1}

# 打开 sql 输出日志
spring.shardingsphere.props.sql.show = true

swagger.enable = true

logging.level.root = info
logging.level.org.springframework.web = info
logging.level.djh.it.dbsharding = debug
logging.level.druid.sql = debug

2、在 sharding_jdbc_simple 子工程（子模块）中，测试类 OrderDao 的测试类 OrderDaoTest.java 进行测试

/**
 *   dbsharding\sharding_jdbc_simple\src\test\java\djh\it\dbsharding\simple\dao\OrderDaoTest.java
 *
 *   2024-6-28 创建 接口 OrderDao 的测试类 OrderDaoTest.java 进行测试
 *
 *   快速生成 接口 OrderDao 类的测试类：
 *   1）右键 接口 OrderDao 选择 【Generate...】
 *   2）选择【Test..】
 *   3）Testing library : JUnit4
 *      Class name : OrderDaoTest
 *      SUPERCLASS : 空
 *      Destination package : djh.it.dbsharding.simple.dao
 *   4）点击 OK。
 */
package djh.it.dbsharding.simple.dao;

import djh.it.dbsharding.simple.ShardingJdbcSimpleBootstrap;
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.test.context.junit4.SpringRunner;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ShardingJdbcSimpleBootstrap.class})
public class OrderDaoTest {

    @Autowired
    OrderDao orderDao;

    @Test  //查询
    public void testSelectOrderByIds(){
        List<Long> ids = new ArrayList<>();
        ids.add(1013467489922711552L);  //此order_id 在 mysql 数据库的 t_order_1 表中，
        ids.add(1013465458055053313L);  //此order_id 在 mysql 数据库的 t_order_2 表中，
        List<Map> maps = orderDao.selectOrderByIds(ids);
        System.out.println(maps);
    }

    @Test  //插入数据
    public void testInsertOrder(){
//            // 1）此数据会插入到 m1 数据库： 1L % 2 + 1 = 2 得到 M2，由此可得 向 order_db_2 数据库中插入 20 条数据。
//            orderDao.insertOrder(new BigDecimal(i ),1L, "success2");

            // 2）此数据会插入到 m1 数据库： 4L % 2 + 1 = 1 得到 M1，由此可得 向 order_db_1 数据库中插入 20 条数据。
        for(int i=1; i<20; i++){
            orderDao.insertOrder(new BigDecimal(i ),4L, "success2");
        }
    }
}

3、运行测试类 OrderDaoTest.java 插入数据 testInsertOrder 方法，进行测试。

1）1L % 2 + 1 = 2 得到 M2，由此可得 向 t_order_2 数据库中插入 20 条数据。
2）此数据会插入到 m1 数据库： 4L % 2 + 1 = 1 得到 M1，由此可得 向 order_db_1 数据库中插入 10 条数据。

插入数据.png

三、Sharding-JDBC 水平分库-查询订单

1、在 sharding_jdbc_simple 子工程（子模块）中，修改 application.properties 配置文件，添加配置分库策略。

#  dbsharding\sharding_jdbc_simple\src\main\resources\application.properties

server.port = 56081

spring.application.name = sharding-jdbc-simple-demo

server.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = true

spring.main.allow-bean-definition-overriding = true
mybatis.configuration.map-underscore-to-camel-case = true

# 配置 sharding-jdbc 分片规则（2024-6-29 分片规则修改）
# 定义数据源(定义 多个 数据源名为 m1, m2)
spring.shardingsphere.datasource.names = m1,m2

spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 12311

spring.shardingsphere.datasource.m2.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = 12311

# 分库策略：以 user_id 为分片键，分片策略为 user_id % 2 + 1，user_id 为偶数操作 m1 数据源，否则操作 m2
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}


# 指定 t_order 表的数据分布情况，配置数据节点(t_order 映射到 t_order_1 或者 t_order_2): 只能路由到 m1 数据库
#spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m1.t_order_$->{1..2}
# 指定 t_order 表的数据分布情况，配置数据节点(t_order 映射到 t_order_1 或者 t_order_2): 动态路由到 m1 数据库 或 m2 数据库。
 spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m$->{1..2}.t_order_$->{1..2}

# 指定 t_order 表的主键生成策略为 SNOWFLAKE（雪花算法）
spring.shardingsphere.sharding.tables.t_order.key-generator.column = order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type = SNOWFLAKE

# 指定 t_order 表的分片策略，分片策略包括分片键和分片算法
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 + 1}

# 打开 sql 输出日志
spring.shardingsphere.props.sql.show = true

swagger.enable = true

logging.level.root = info
logging.level.org.springframework.web = info
logging.level.djh.it.dbsharding = debug
logging.level.druid.sql = debug

2、在 sharding_jdbc_simple 子工程（子模块）中，修改 dao 接口类 OrderDao.java 添加 //查询数据：根据订单ID 和 用户 id 查询订单 方法。

/**
 *   dbsharding\sharding_jdbc_simple\src\main\java\djh\it\dbsharding\simple\dao\OrderDao.java
 *
 *   2024-5-28 创建 dao 接口类 OrderDao.java
 */
package djh.it.dbsharding.simple.dao;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

@Mapper
@Component
public interface OrderDao {

    //查询数据：根据订单ID 和 用户 id 查询订单
    // ( SELECT * FROM t_order_1 WHERE user_id = 4 AND order_id IN (1014650592712196096, 1014650593467170816); )
    @Select( "<script>" +
            "select" +
            " * " +
            " from t_order t " +
            " where t.order_id in " +
            " <foreach collection=' orderIds' open='(' separator=',' close=')' item='id'>" +
            " #{id} " +
            " </foreach>" +
            " and user_id = ${userId}" +
            "</script>" )
    List<Map> selectOrderByIdsAndUserId(@Param("userId") Long userId, @Param("orderIds") List<Long> orderIds);

    //查询数据：根据订单ID ( SQL 语句：SELECT * FROM t_order_1 WHERE order_id IN (1013467489922711552, 1013467489960460288); )
    @Select( "<script>" +
            "select" +
            " * " +
            " from t_order t " +
            " where t.order_id in " +
            " <foreach collection=' orderIds' open='(' separator=',' close=')' item='id'>" +
            " #{id} " +
            " </foreach>" +
            "</script>" )
    List<Map> selectOrderByIds(@Param("orderIds") List<Long> orderIds);

    //插入数据
    @Insert("insert into t_order(price, user_id, status) values(#{price}, #{userId}, #{status})")
    int insertOrder(@Param("price") BigDecimal price, @Param("userId")Long userId, @Param("status")String status);
}

3、在 sharding_jdbc_simple 子工程（子模块）中，修改 测试类 OrderDao 的测试类 查询方法，进行多次查询测试。添加 根据订单ID 和 用户 id 查询订单 的方法。

/**
 *   dbsharding\sharding_jdbc_simple\src\test\java\djh\it\dbsharding\simple\dao\OrderDaoTest.java
 *
 *   2024-6-28 创建 接口 OrderDao 的测试类 OrderDaoTest.java 进行测试
 *
 *   快速生成 接口 OrderDao 类的测试类：
 *   1）右键 接口 OrderDao 选择 【Generate...】
 *   2）选择【Test..】
 *   3）Testing library : JUnit4
 *      Class name : OrderDaoTest
 *      SUPERCLASS : 空
 *      Destination package : djh.it.dbsharding.simple.dao
 *   4）点击 OK。
 */
package djh.it.dbsharding.simple.dao;

import djh.it.dbsharding.simple.ShardingJdbcSimpleBootstrap;
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.test.context.junit4.SpringRunner;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ShardingJdbcSimpleBootstrap.class})
public class OrderDaoTest {

    @Autowired
    OrderDao orderDao;

    @Test  //查询--根据订单ID 和 用户 id 查询订单
    public void testSelectOrderByIdsAndUserId(){

        List<Long> ids = new ArrayList<>();

        // 水平分库测试如下：
        List<Long> ids2 = new ArrayList<>();

//        //1）查询不存在的 order_id（在 m1 或 m2 中，都不存在），添加了 userId , 会输出真实的2条SQL语句。
//        ids2.add(1013467489922711552L);  //此 order_id 在 mysql 的 m1 和 m2 数据库中 的 t_order_1 表 和 t_order_2 表中 都不存在
//        ids2.add(1013465458055053313L);  //此 order_id 在 mysql 的 m1 和 m2 数据库中 的 t_order_1 表 和 t_order_2 表中 都不存在
//        List<Map> maps = orderDao.selectOrderByIdsAndUserId(4L, ids2);
//        System.out.println(maps);

        //2）查询存在的 order_id（一条在 m1 数据库，一条在 m2 数据库中），添加了 userId , 会输出真实的2条SQL语句。
        ids2.add(1014650592712196096L);  //此 order_id 在 mysql 的 m1 数据库中 t_order_1 表 中。
        ids2.add(1014635737775079425L);  //此 order_id 在 mysql 的 m2 数据库中 t_order_2 表 中。
        List<Map> maps2 = orderDao.selectOrderByIdsAndUserId(4L, ids2);
        System.out.println(maps2);

    }

    @Test  //查询
    public void testSelectOrderByIds(){

        List<Long> ids = new ArrayList<>();

//        //查询数据库 order_db 中的数据 order_id（水平分表）
//        ids.add(1013467489922711552L);  //此order_id 在 mysql 数据库的 t_order_1 表中，
//        ids.add(1013465458055053313L);  //此order_id 在 mysql 数据库的 t_order_2 表中，
//        List<Map> maps = orderDao.selectOrderByIds(ids);
//        System.out.println(maps);

        // 水平分库测试如下：
        List<Long> ids2 = new ArrayList<>();

        //1）查询不存在的 order_id（在 m1 或 m2 中，都不存在），会输出真实的4条SQL语句。
        ids2.add(1013467489922711552L);  //此 order_id 在 mysql 的 m1 和 m2 数据库中 的 t_order_1 表 和 t_order_2 表中 都不存在
        ids2.add(1013465458055053313L);  //此 order_id 在 mysql 的 m1 和 m2 数据库中 的 t_order_1 表 和 t_order_2 表中 都不存在
        List<Map> maps = orderDao.selectOrderByIds(ids2);
        System.out.println(maps);


//        //2）查询存在的 order_id（一条在 m1 数据库，一条在 m2 数据库中），会输出真实的4条SQL语句。
//        ids2.add(1014650592712196096L);  //此 order_id 在 mysql 的 m1 数据库中 t_order_1 表 中。
//        ids2.add(1014635737775079425L);  //此 order_id 在 mysql 的 m2 数据库中 t_order_2 表 中。
//        List<Map> maps2 = orderDao.selectOrderByIds(ids2);
//        System.out.println(maps2);

//        //3）查询存在的 order_id（2条都在 m1 数据库，不同表中），会输出真实的4条SQL语句。
//        ids2.add(1014650592712196096L);  //此 order_id 在 mysql 的 m1 数据库中 t_order_1 表 中。
//        ids2.add(1014635737775079425L);  //此 order_id 在 mysql 的 m1 数据库中 t_order_2 表 中。
//        List<Map> maps2 = orderDao.selectOrderByIds(ids2);
//        System.out.println(maps2);

//        //4）查询存在的 order_id（2条都在 m1 数据库，同一表中），会输出真实的2条SQL语句。
//        ids2.add(1014650592712196096L);  //此 order_id 在 mysql 的 m1 数据库中 t_order_1 表 中。
//        ids2.add(1014635742883741696L);  //此 order_id 在 mysql 的 m1 数据库中 t_order_1 表 中。
//        List<Map> maps2 = orderDao.selectOrderByIds(ids2);
//        System.out.println(maps2);

//        //5）查询存在的 order_id（1条都在 m2 数据库），会输出真实的2条SQL语句。
//        ids2.add(1014635741851942912L);  //此 order_id 在 mysql 的 m2 数据库中 t_order_1 表 中。
//        List<Map> maps2 = orderDao.selectOrderByIds(ids2);
//        System.out.println(maps2);

    }

    @Test  //插入数据
    public void testInsertOrder(){
        //orderDao.insertOrder(new BigDecimal(11 ),1L, "SUCCESS");
        for(int i=1; i<10; i++){
//            // 1）此数据会插入到 m1 数据库： 1L % 2 + 1 = 2 得到 M2，由此可得 向 order_db_2 数据库中插入 20 条数据。
//            orderDao.insertOrder(new BigDecimal(i ),1L, "success2");

            // 2）此数据会插入到 m1 数据库： 4L % 2 + 1 = 1 得到 M1，由此可得 向 order_db_1 数据库中插入 10 条数据。
            orderDao.insertOrder(new BigDecimal(i ),4L, "success3");
        }
    }
}

4、运行测试类 OrderDaoTest.java 查询数据 testSelectOrderByIds 方法，进行测试。

1）查询不存在的 order_id（在 m1 或 m2 中，都不存在），会输出真实的4条SQL语句。

查询数据1.png

2）查询存在的 order_id（一条在 m1 数据库，一条在 m2 数据库中），会输出真实的4条SQL语句。

查询数据2.png

3）查询存在的 order_id（2条都在 m1 数据库，不同表中），会输出真实的4条SQL语句。

查询数据3.png

4）查询存在的 order_id（2条都在 m1 数据库 同一表中），会输出真实的2条SQL语句。

查询数据4.png

5）查询存在的 order_id（1条都在 m2 数据库），会输出真实的2条SQL语句。

查询数据5.png

6）查询不存在的 order_id（在 m1 或 m2 中，都不存在），添加了 userId ,

查询数据6.png

7）查询存在的 order_id（一条在 m1 数据库，一条在 m2 数据库中），添加了 userId , 会输出真实的2条SQL语句。

查询数据7.png

四、Sharding-JDBC 垂直分库-分片策略配置

1、创建数据库：user_db

CREATE DATABASE `user_db` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

2、在 suer_db 中分别 创建 t_user 表：


# 在 数据库 order_db_1 中，创建两张表。

USE `user_db`;

# 创建  t_user 表

DROP TABLE IF EXISTS `t_user`;

CREATE TABLE `t_user` (
`user_id` BIGINT(20) NOT NULL COMMENT '用户id',
`fullname` VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户姓名',
`user_type` char(1) DEFAULT NULL COMMENT '用户类型', 
PRIMARY KEY(`user_id`) USING BTREE
) ENGINE = INNODB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

3、在 application.properties 配置文件中，配置数据源，

spring.shardingsphere.datasource.names = m0,m1,m2

spring.shardingsphere.datasource.m0.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m0.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m0.url = jdbc:mysql://localhost:3306/user_db?useUnicode=true
spring.shardingsphere.datasource.m0.username = root
spring.shardingsphere.datasource.m0.password = 12311

# 分库策略：以 user_id 为分片键，分片策略为 user_id % 2 + 1，user_id 为偶数操作 m1 数据源，否则操作 m2
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}

# 配置 user_db 数据节点
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes = m0.t_user

# 指定 t_user 表的分片策略，分片策略包括分片键和分片算法（未分库分表也需要配置）
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression = t_user

五、Sharding-JDBC 垂直分库-插入和查询测试

1、在 sharding_jdbc_simple 子工程（子模块）中，修改 application.properties 配置文件，添加 user_db 数据库的 配置分库分表策略。

#  dbsharding\sharding_jdbc_simple\src\main\resources\application.properties

server.port = 56081

spring.application.name = sharding-jdbc-simple-demo

server.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = true

spring.main.allow-bean-definition-overriding = true
mybatis.configuration.map-underscore-to-camel-case = true

# 配置 sharding-jdbc 分片规则（2024-6-29 分片规则修改）
# 定义数据源(定义 多个 数据源名为 m1, m2)
spring.shardingsphere.datasource.names = m0,m1,m2

spring.shardingsphere.datasource.m0.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m0.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m0.url = jdbc:mysql://localhost:3306/user_db?useUnicode=true
spring.shardingsphere.datasource.m0.username = root
spring.shardingsphere.datasource.m0.password = 12311

spring.shardingsphere.datasource.m1.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m1.url = jdbc:mysql://localhost:3306/order_db_1?useUnicode=true
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 12311

spring.shardingsphere.datasource.m2.type = com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name = com.mysql.jdbc.Driver
spring.shardingsphere.datasource.m2.url = jdbc:mysql://localhost:3306/order_db_2?useUnicode=true
spring.shardingsphere.datasource.m2.username = root
spring.shardingsphere.datasource.m2.password = 12311

# 分库策略：以 user_id 为分片键，分片策略为 user_id % 2 + 1，user_id 为偶数操作 m1 数据源，否则操作 m2
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_order.database-strategy.inline.algorithm-expression = m$->{user_id % 2 + 1}


# 指定 t_order 表的数据分布情况，配置数据节点(t_order 映射到 t_order_1 或者 t_order_2): 只能路由到 m1 数据库
#spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m1.t_order_$->{1..2}
# 指定 t_order 表的数据分布情况，配置数据节点(t_order 映射到 t_order_1 或者 t_order_2): 动态路由到 m1 数据库 或 m2 数据库。
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m$->{1..2}.t_order_$->{1..2}
# 配置 user_db 数据节点
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes = m$->{0}.t_user


# 指定 t_order 表的主键生成策略为 SNOWFLAKE（雪花算法）
spring.shardingsphere.sharding.tables.t_order.key-generator.column = order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type = SNOWFLAKE

# 指定 t_order 表的分片策略，分片策略包括分片键和分片算法
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 + 1}

# 指定 t_user 表的分片策略，分片策略包括分片键和分片算法（未分库分表也需要配置）
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.sharding-column = user_id
spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithm-expression = t_user

# 打开 sql 输出日志
spring.shardingsphere.props.sql.show = true

swagger.enable = true

logging.level.root = info
logging.level.org.springframework.web = info
logging.level.djh.it.dbsharding = debug
logging.level.druid.sql = debug

2、在 sharding_jdbc_simple 子工程（子模块）中，创建 接口类 UserDao.java

/**
 *   dbsharding\sharding_jdbc_simple\src\main\java\djh\it\dbsharding\simple\dao\UserDao.java
 *
 *   2024-7-1 创建 接口类 UserDao.java
 */
package djh.it.dbsharding.simple.dao;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;

@Mapper
@Component
public interface UserDao {

    //新增用户
    @Insert("insert into t_user(user_id, fullname) value(#{userId}, #{fullname})")
    int insertUser(@Param("userId") Long userId, @Param("fullname") String fullname);

    //根据id列表查询多个用户
    @Select({ "<script>" ,
            " select" ,
            " * " ,
            " from t_user t " ,
            " where t.user_id in ",
            " <foreach collection=' userIds' open='(' separator=',' close=')' item='id'>" +
            " #{id} " ,
            " </foreach>" ,
            "</script>" })
    List<Map> selectUserId(@Param("userIds") List<Long> userIds);
}

3、在 sharding_jdbc_simple 子工程（子模块）中，创建 接口类 UserDao.java 的测试类 UserDaoTest.java 进行插入数据 和 查询数据测试。

/**
 *   dbsharding\sharding_jdbc_simple\src\test\java\djh\it\dbsharding\simple\dao\UserDaoTest.java
 *
 *   2024-7-1 创建 接口类 UserDao.java 的测试类 UserDaoTest.java 进行插入数据 和 查询数据测试 UserDaoTest.java
 */
package djh.it.dbsharding.simple.dao;

import djh.it.dbsharding.simple.ShardingJdbcSimpleBootstrap;
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.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ShardingJdbcSimpleBootstrap.class})
public class UserDaoTest {

    @Autowired
    UserDao userDao;

    @Test
    public void testInsertUser() {
        for(int i=0; i<10; i++){
            Long id = i + 1L;
            userDao.insertUser(id, "姓名" + id);
        }
    }

    @Test
    public void testSelectUserByIds() {
        List<Long> userIds = new ArrayList<>();
        userIds.add(1L);
        userIds.add(2L);
        List<Map> users = userDao.selectUserId(userIds);
        System.out.println(users);
    }
}

4、运行测试类 UserDaoTest.java，查看结果。

Sharding-JDBC垂直分库-插入和查询测试.png

在这里插入图片描述

上一节关联链接请点击
# Sharding-JDBC从入门到精通（5）-- Sharding-JDBC 执行原理

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1888568.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

法制史学习笔记(个人向) Part.3

法制史学习笔记(个人向) Part.3

5. 三国两晋南北朝法律制度 以下为三国魏晋南北朝直到唐代的历史发展脉络图&#xff1a; #mermaid-svg-6AVVMjllKTBaBbRO {font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-6AVVMjllKTBaBbRO .error-icon{fill:#55222…
阅读更多...
Meta 3D Gen：文生 3D 模型

Meta 3D Gen：文生 3D 模型

是由 Meta 公布的一个利用 Meta AssetGen&#xff08;模型生成&#xff09;和 TextureGen&#xff08;贴图材质生成&#xff09;的组合 AI 系统&#xff0c;可以在分分钟内生成高质量 3D 模型和高分辨率贴图纹理。 视频演示的效果非常好&#xff0c;目前只有论文&#xff0c;期…
阅读更多...
2.（vue3.x+vite）调用iframe的方法（vue编码）

2.（vue3.x+vite）调用iframe的方法（vue编码）

1、效果预览 2.编写代码 （1）主页面 <template><div><button @click="sendMessage">调用iframe，并发送信息
阅读更多...
记录前端发现问题之 mock接口无返回数据导致所有后续接口调用报错：网络异常

记录前端发现问题之 mock接口无返回数据导致所有后续接口调用报错：网络异常

1. 背景 就更新了代码&#xff0c;发现新涉及的页面&#xff0c;切换tab 之后会报错网络异常&#xff0c;再次切换其他没涉及的功能页面&#xff0c;继续报错网络异常 测试环境&#xff1a;纯前端代码&#xff0c;后端是前端mock的数据&#xff0c;仅供demo 2. 问题报错 手动…
阅读更多...
华为 eNSP 模拟器 配置RIP实例 动态路由协议

华为 eNSP 模拟器 配置RIP实例 动态路由协议

1 实验拓扑 2 配置路由器 #R1 Huawei>sys [Huawei]sysname R1 [R1]interface GigabitEthernet 0/0/0 [R1-GigabitEthernet0/0/0]ip address 192.168.1.1 255.255.255.0 [R1-GigabitEthernet0/0/0]qu [R1]rip [R1-rip-1]network 192.168.1.0 [R1-rip-1]version 2 [R1-rip-…
阅读更多...
05 docker 镜像

05 docker 镜像

目录 1. 镜像 2. 联合文件系统 3. docker镜像加载原理 4. 镜像分层 镜像分层的优势 5. 容器层 1. 镜像 镜像是一种轻量级、可执行的独立软件包&#xff0c;它包含运行某个软件所需的所有内容&#xff0c;我们把应用程序和配置依赖打包好行程一个可交付的运行环境&#xf…
阅读更多...
深入浅出：npm常用命令详解与实践【保姆级教程】

深入浅出：npm常用命令详解与实践【保姆级教程】

大家好，我是CodeQi！ 在我刚开始学习前端开发的时候，有一件事情让我特别头疼：管理和安装各种各样的依赖包。 那时候，我还不知道 npm 的存在，手动下载和管理这些库简直是噩梦。 后来，我终于接触到了 npm（Node Package Manager），它不仅帮我解决了依赖管理问题，还让我…
阅读更多...
Apache Ranger 2.4.0 安装部署

Apache Ranger 2.4.0 安装部署

1、安装ranger admin 2、源码编译Ranger wget https://www.apache.org/dist/ranger/2.4.0/apache-ranger-2.4.0.tar.gz tar zxvf apache-ranger-2.4.0.tar.gz cd apache-ranger-2.4.0 mvn -Pall clean mvn clean package -DskipTests maven settting可以设置阿里云进行资源下载…
阅读更多...
北斗/GPS模块输出的NMEA语句详解

北斗/GPS模块输出的NMEA语句详解

NMEA协议采用 ASCII 码来传递 GPS 定位信息&#xff0c;我们称之为帧。 帧格式形如&#xff1a;$aaccc,ddd,ddd,…,ddd*hh(CR)(LF) 1、“$”&#xff1a;帧命令起始位 2、aaccc&#xff1a;地址域&#xff0c;前两位为识别符&#xff08;aa&#xff09;&#xff0c;后三位为…
阅读更多...
Email OTP验证认证接口和API发送邮件平台？

Email OTP验证认证接口和API发送邮件平台？

Email OTP验证认证接口如何设计&#xff1f;邮件发送平台怎么选&#xff1f; Email OTP验证认证接口和API发送邮件平台为实现这一目标提供了有效的解决方案。AokSend将深入探讨Email OTP验证认证接口及API发送邮件平台的关键功能和优势。 Email OTP&#xff1a;工作原理 用户…
阅读更多...
vue3 在el-input的光标处插入文本

vue3 在el-input的光标处插入文本

点击文本框下方的按钮&#xff0c;将相应的文本插入光标处的实现&#xff1a; <el-input type"textarea" rows"4" v-model"formula" blur"handleBlur" clearable></el-input><el-button-group class"short_btn&q…
阅读更多...
解决“Undefined control sequence. \hline”

解决“Undefined control sequence. \hline”

解决“Undefined control sequence. \hline” Q:创建表格时显示错误“Undefined control sequence. \Xhline”A:解决方法C介绍\usepackage{makecell}作用使用方法示例其他功能总结 Q:创建表格时显示错误“Undefined control sequence. \Xhline” MTMAGVDPP.tex: 错误: 211: Un…
阅读更多...
R语言学习与笔记2-RRStudio环境配置（Windows版）

R语言学习与笔记2-RRStudio环境配置（Windows版）

R语言学习与笔记2-R&RStudio环境配置&#xff08;Windows版&#xff09; 安装 R安装RStudio修改默认工作目录修改镜像验证镜像源修改文件编码 环境测试 安装 R R下载地址&#xff1a; https://mirrors.tuna.tsinghua.edu.cn/CRAN/bin/windows/base/ 点击下载链接并运行安装…
阅读更多...
互联网医院系统源码解析：如何打造智能数字药店APP？

互联网医院系统源码解析：如何打造智能数字药店APP？

在互联网技术飞速发展的今天&#xff0c;医疗行业也在不断与之融合&#xff0c;互联网医院系统应运而生。特别是智能数字药店APP的兴起&#xff0c;使得医疗服务变得更加便捷、高效。本文将深入解析互联网医院系统源码&#xff0c;探讨如何打造一个智能的数字药店APP。 一、互…
阅读更多...
聚焦 Navicat 17 新特性 | 让用户界面交互更丝滑

聚焦 Navicat 17 新特性 | 让用户界面交互更丝滑

随着 Navicat 17 的发布&#xff0c;引起业界热烈反响和深入讨论。早前&#xff0c;我们介绍了 Navicat 17 《模型设计创新与优化​​​​​​​》与《查询与配置》的新特性。此外&#xff0c;Navicat 在用户界面交互方面进行了显著优化&#xff0c;新增了一系列实用的功能&…
阅读更多...
springboot高校在线健康咨询服务APP-计算机毕业设计源码86100

springboot高校在线健康咨询服务APP-计算机毕业设计源码86100

摘要 随着信息技术的快速发展和智能手机的普及&#xff0c;移动互联网已经成为现代人生活中不可或缺的一部分。在这一背景下&#xff0c;高校在线健康咨询服务APP应运而生&#xff0c;旨在为广大高校师生提供更加便捷、高效、个性化的健康咨询服务。 高校作为人才培养的摇篮&am…
阅读更多...
【硬件模块】SGP30气体传感器

【硬件模块】SGP30气体传感器

SGP30 这是SGP30官方文档里开头的介绍&#xff0c;简单来说就是SGP30是一个数字多像素气体传感器&#xff0c;然后具有长期稳定性和低漂移。 这些我们都不用管&#xff0c;我们只需要知道SGP30是通过I2C来通信的&#xff0c;并且可以采集的数据有CO2和TVOC的含量。TVOC是“To…
阅读更多...
记一次android打包，因路由规则设置不合理而导致pom文件无法访问的错误

记一次android打包，因路由规则设置不合理而导致pom文件无法访问的错误

一、错误详情 FAILURE: Build failed with an exception.* What went wrong: Could not determine the dependencies of task :mediaplayer:compileReleaseAidl. > Could not resolve all task dependencies for configuration :mediaplayer:releaseCompileClasspath.> C…
阅读更多...
编译原理必考大题:构造项目集规范族,构造LR(0)分析表

编译原理必考大题:构造项目集规范族,构造LR(0)分析表

在学习项目集规范族的构造之前,要先知道什么是项目?什么是项目集的闭包运算? 文章目录 前置知识LR(0)项目项目集的闭包运算项目转换函数GO 构造项目集规范族解决方法 构造LR(0)分析表真题实战: 前置知识 LR(0)项目 项目就是规则加上’’ 例如一条规则,A→abc 它对应的项目就…
阅读更多...
【C++】开源：命令行解析库CLI11配置与使用

【C++】开源：命令行解析库CLI11配置与使用

&#x1f60f;★,:.☆(&#xffe3;▽&#xffe3;)/$:.★ &#x1f60f; 这篇文章主要介绍命令行解析库CLI11配置与使用。 无专精则不能成&#xff0c;无涉猎则不能通。——梁启超 欢迎来到我的博客&#xff0c;一起学习&#xff0c;共同进步。 喜欢的朋友可以关注一下&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023