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

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,m2spring.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 = 12311spring.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.propertiesserver.port = 56081spring.application.name = sharding-jdbc-simple-demoserver.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = truespring.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,m2spring.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 = 12311spring.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 = trueswagger.enable = truelogging.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.propertiesserver.port = 56081spring.application.name = sharding-jdbc-simple-demoserver.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = truespring.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,m2spring.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 = 12311spring.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 = trueswagger.enable = truelogging.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 {@AutowiredOrderDao 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.propertiesserver.port = 56081spring.application.name = sharding-jdbc-simple-demoserver.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = truespring.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,m2spring.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 = 12311spring.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 = trueswagger.enable = truelogging.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 {@AutowiredOrderDao 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,m2spring.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.propertiesserver.port = 56081spring.application.name = sharding-jdbc-simple-demoserver.servlet.context-path = /sharding-jdbc-simple-demo
spring.http.encoding.enabled = true
spring.http.encoding.charset = utf-8
spring.http.encoding.force = truespring.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,m2spring.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 = 12311spring.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 = 12311spring.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 = trueswagger.enable = truelogging.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 {@AutowiredUserDao userDao;@Testpublic void testInsertUser() {for(int i=0; i<10; i++){Long id = i + 1L;userDao.insertUser(id, "姓名" + id);}}@Testpublic 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.mzph.cn/web/40553.shtml

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

相关文章

嵌入式linux面试1

嵌入式linux面试1

1. linux 1.1. Window系统和Linux系统的区别 linux区分大小写windows在dos&#xff08;磁盘操作系统&#xff09;界面命令下不区分大小写&#xff1b; 1.2. 文件格式区分 windows用扩展名区分文件&#xff1b;如.exe代表执行文件&#xff0c;.txt代表文本文件&#xff0c;.…
阅读更多...
手动将dingtalk-sdk-java jar包打入maven本地仓库

手动将dingtalk-sdk-java jar包打入maven本地仓库

有时候，中央镜像库不一定有自己需要的jar包，这时候我们就需要用到该方法，将jar打入maven本地仓库，然后项目中，正常使用maven的引入规则。 mvn install:install-file -Dmaven.repo.local=D:\software\maven\apache-maven-3.6.3-bin\apache-maven-3.6.3\repo -DgroupId=ding…
阅读更多...
Caffeinated for Mac v2.0.6 Mac防休眠应用 兼容 M1/M2/M3

Caffeinated for Mac v2.0.6 Mac防休眠应用 兼容 M1/M2/M3

Caffeinated 可以防止您的 Mac 进入休眠状态、屏幕变暗或者启动屏幕保护。 应用介绍 您的屏幕是否总是在您不希望的时候变暗&#xff1f;那么Caffeinated就是您解决这个大麻烦的最好工具啦。Caffeinated是在Caffeine这个非常便捷、有用的工具的基础上开发而来的。Caffeinated…
阅读更多...
215. 数组中的第K个最大元素（中等）

215. 数组中的第K个最大元素（中等）

215. 数组中的第K个最大元素 1. 题目描述2.详细题解3.代码实现3.1 Python3.2 Java 1. 题目描述 题目中转&#xff1a;215. 数组中的第K个最大元素 2.详细题解 快速排序算法在每一轮排序中&#xff0c;随机选择一个数字 x x x&#xff0c;根据与 x x x的大小关系将要排序的数…
阅读更多...
PMP–知识卡片--PDCA循环

PMP–知识卡片--PDCA循环

记忆 PDCA&#xff1a;计划执行检查调整&#xff0c;计划观察动作&#xff1b;plan do check action 定义 PDCA循环的含义是将质量管理分为四个过程&#xff0c;即计划&#xff08;Plan&#xff09;、执行&#xff08;Do&#xff09;、检查&#xff08;Check&#xff09;、处…
阅读更多...
使用 OpenCV 和 Python 进行车道检测和物体检测（YOLO）

使用 OpenCV 和 Python 进行车道检测和物体检测（YOLO）

本项目旨在开发一个集车道检测与物体检测功能于一体的智能视觉分析系统&#xff0c;利用先进的计算机视觉技术和深度学习模型&#xff0c;实现实时的道路场景理解和目标识别。系统主要依托OpenCV这一强大的计算机视觉库&#xff0c;以及Python作为编程语言&#xff0c;融合了车…
阅读更多...
MySQL索引教程（01）：创建索引

MySQL索引教程（01）：创建索引

文章目录 MySQL 创建索引索引介绍MySQL CREATE INDEX 语法MySQL 索引类型MySQL CREATE INDEX 实例结论 MySQL 创建索引 对于一个具有大量数据行的表&#xff0c;如果你根据某个查询条件检索数据时很慢&#xff0c;可能是因为你没有在检索条件相关的列上创建索引。 索引类似于…
阅读更多...
FPC生产工艺全流程详解

FPC生产工艺全流程详解

FPC生产制作繁琐而且难度较大&#xff0c;与普通PCB比较&#xff0c;FPC单位面积电路的造价高很多&#xff0c;但是&#xff0c;由于FPC优异的柔性、轻薄和可靠性等特性&#xff0c;给众多领域的设备和产品提供了更广泛的实现空间和新的设计方案&#xff0c;比如沉金板在电子、…
阅读更多...
Java需要英语基础吗？

Java需要英语基础吗？

Java编程语言本身并不要求必须有很强的英语基础&#xff0c;因为Java的语法和逻辑是独立于任何特定语言的。我收集归类了一份嵌入式学习包&#xff0c;对于新手而言简直不要太棒&#xff0c;里面包括了新手各个时期的学习方向编程教学、问题视频讲解、毕设800套和语言类教学&am…
阅读更多...
Java项目：基于SSM框架实现的共享客栈管理系统分前后台【ssm+B/S架构+源码+数据库+毕业论文】

Java项目：基于SSM框架实现的共享客栈管理系统分前后台【ssm+B/S架构+源码+数据库+毕业论文】

一、项目简介 本项目是一套基于SSM框架实现的共享客栈管理系统 包含&#xff1a;项目源码、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都经过严格调试&#xff0c;eclipse或者idea 确保可以运行&#xff01; 该系统功能完善、界面美观、操作简单、功能…
阅读更多...
使用maven搭建一个SpingBoot项目

使用maven搭建一个SpingBoot项目

1.首先创建一个maven项目 注意选择合适的jdk版本 2.添加依赖 2.在pom.xml中至少添加依赖 spring-boot-starter-web 依赖&#xff0c;目的是引入Tomcat&#xff0c;以及SpringMVC等&#xff0c;使项目具有web功能。 <!-- 引入 包含tomcat&#xff0c;SpringMVC&#xff0c…
阅读更多...
【C++题解】1561. 买木头

【C++题解】1561. 买木头

问题&#xff1a;1561. 买木头 类型&#xff1a;省赛、数组问题、二分答案、贪心、2015江苏省青少年信息学奥林匹克竞赛复赛 题目描述&#xff1a; 有 n 个木材供应商&#xff0c;每个供货商有长度相同一定数量的木头。长木头可以锯短&#xff0c;但短木头不能接长。有一个客…
阅读更多...
14-36 剑和诗人10 - 用LLM构建 AI 代理平台

14-36 剑和诗人10 - 用LLM构建 AI 代理平台

介绍 在当今快速发展的技术环境中&#xff0c;大型语言模型 (LLM) 和 AI 代理正在改变我们与信息交互、实现流程自动化以及应对不同行业复杂挑战的方式。随着这些强大的模型不断发展&#xff0c;对能够无缝集成和协调它们的强大平台的需求变得越来越重要。 让我们深入研究设计…
阅读更多...
android2024 gradle8 Processor和ksp两种编译时注解实现

android2024 gradle8 Processor和ksp两种编译时注解实现

android编译时注解&#xff0c;老生常谈&#xff0c;外面的例子都是bindView&#xff0c;脑壳看疼了&#xff0c;自己学习和编写下。 而且现在已经进化到kotlin2.0&#xff0c;google也逐渐放弃kapt&#xff0c;进入维护状态。所以要好好看看本贴。 参考我的工程&#xff1a; h…
阅读更多...
数据结构之算法的时间复杂度

数据结构之算法的时间复杂度

1.时间复杂度的定义 在计算机科学中&#xff0c;算法的时间复杂度是一个函数&#xff0c;它定量描述了算法的运行时间。一个算法所花费的时间与其中语句的执行次数成正比列&#xff0c;算法中的基本操作的执行次数&#xff0c;为算法的时间复杂度 例1&#xff1a; 计算Func1…
阅读更多...
Linux：ollama大模型部署

Linux：ollama大模型部署

目录 Ollama 是一个能在本地机器上轻松构建和运行大型语言模型的轻量级、可扩展框架&#xff0c;适用于多种场景&#xff0c;具有易于使用、资源占用少、可扩展性强等特点。 1.安装下载ollama 2.为 Ollama 创建一个用户 3.为ollama创建服务文件 4.启动ollama服务 5.拉取语…
阅读更多...
图书馆数据仓库

图书馆数据仓库

目录 1.数据仓库的数据来源为业务数据库&#xff08;mysql&#xff09; 初始化脚本 init_book_result.sql 2.通过sqoop将mysql中的业务数据导入到大数据平台&#xff08;hive&#xff09; 导入mysql数据到hive中 3.通过hive进行数据计算和数据分析 形成数据报表 4.再通过sq…
阅读更多...
【matlab】智能优化算法——求解目标函数

【matlab】智能优化算法——求解目标函数

智能优化算法在求解目标函数方面发挥着重要作用&#xff0c;它通过迭代、筛选等方法来寻找目标函数的最优值&#xff08;极值&#xff09;。以下是关于智能优化算法求解目标函数的详细介绍&#xff1a; 一、智能优化算法概述 智能优化算法是一种搜索算法&#xff0c;旨在通过…
阅读更多...
设置单实例Apache HTTP服务器

设置单实例Apache HTTP服务器

配置仓库 [rootlocalhost ~]# cd /etc/yum.repos.d/ [rootlocalhost yum.repos.d]# vi rpm.repo仓库代码&#xff1a; [BaseOS] nameBaseOS baseurl/mnt/BaseOS enabled1 gpgcheck0[AppStream] nameAppStream baseurl/mnt/AppStream enabled1 gpgcheck0挂载 [rootlocalhost …
阅读更多...
2.4G无线收发芯片 XL2401D，SOP16封装，集成单片机，高性价比

2.4G无线收发芯片 XL2401D，SOP16封装，集成单片机，高性价比

XL2401D 芯片是工作在2.400~2.483GHz世界通用ISM频段&#xff0c;片内集成了九齐 NY8A054E单片机的SOC无线收发芯片。芯片集成射频收发机、频率收生器、晶体振荡器、调制解调器等功能模块&#xff0c;并且支持一对多组网和带ACK的通信模式。发射输出功率、工作频道以及通信数据…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023