0
0

spring-boot 整合 shardingsphere-jdbc、mybatis-plus 数据分片（文末有彩蛋）

1.什么是 ShardingSphere？

Apache ShardingSphere 是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。

Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。

它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。 它站在数据库的上层视角，关注它们之间的协作多于数据库自身。

ShardingSphere官网

ShardingSphere-JDBC

ShardingSphere-JDBC 定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。

ShardingSphere-Proxy

ShardingSphere-Proxy 定位为透明化的数据库代理端，通过实现数据库二进制协议，对异构语言提供支持。
特性定义数据分片数据分片，是应对海量数据存储与计算的有效手段。ShardingSphere 基于底层数据库提供分布式数据库解决方案，可以水平扩展计算和存储。分布式事务事务能力，是保障数据库完整、安全的关键技术，也是数据库的核心技术。基于 XA 和 BASE 的混合事务引擎，ShardingSphere 提供在独立数据库上的分布式事务功能，保证跨数据源的数据安全。读写分离读写分离，是应对高压力业务访问的手段。基于对 SQL 语义理解及对底层数据库拓扑感知能力，ShardingSphere 提供灵活的读写流量拆分和读流量负载均衡。数据迁移数据迁移，是打通数据生态的关键能力。ShardingSphere 提供跨数据源的数据迁移能力，并可支持重分片扩展。联邦查询联邦查询，是面对复杂数据环境下利用数据的有效手段。ShardingSphere 提供跨数据源的复杂查询分析能力，实现跨源的数据关联与聚合。数据加密数据加密，是保证数据安全的基本手段。ShardingSphere 提供完整、透明、安全、低成本的数据加密解决方案。影子库在全链路压测场景下，ShardingSphere 支持不同工作负载下的数据隔离，避免测试数据污染生产环境。

2.整合 shardingsphere-jdbc

为方便演示，示例（水平分片-分表）使用 H2 内存数据库，直接启动项目即可，其余示例需要自行配置数据库

2.1 引入依赖

示例使用最新版本 5.4.1（后期同步更新）

  1. <dependency>
  2.     <groupId>org.apache.shardingsphere</groupId>
  3.     <artifactId>shardingsphere-jdbc-core</artifactId>
  4.     <version>${sharding.version}</version>
  5. </dependency>

这里有两个坑，网上搜一堆都是老版本整合，差距较大，问题较多；

坑一、需要引入额外依赖：

  1. <!-- 高版本中已独立，需要单独添加依赖，否则启动报错 -->
  2. <dependency>
  3.     <groupId>javax.xml.bind</groupId>
  4.     <artifactId>jaxb-api</artifactId>
  5.     <version>${jaxb.version}</version>
  6. </dependency>
  7. <dependency>
  8.     <groupId>com.sun.xml.bind</groupId>
  9.     <artifactId>jaxb-impl</artifactId>
  10.     <version>${jaxb.version}</version>
  11. </dependency>
  12. <dependency>
  13.     <groupId>org.glassfish.jaxb</groupId>
  14.     <artifactId>jaxb-runtime</artifactId>
  15.     <version>${jaxb.version}</version>
  16. </dependency>

坑二、覆盖原路径重写 snakeyaml 中的类

  1. /**
  2.  * 高版本 snakeyaml 在 spring-boot-autoconfigure 加载配置文件时报错
  3.  * java.lang.NoSuchMethodError: org.yaml.snakeyaml.***.***: method <init>()V not found
  4.  * 覆盖源码，添加无参构造函数
  5.  * <p>
  6.  * public Representer() {
  7.  * super(new DumperOptions());
  8.  * this.representers.put(null, new RepresentJavaBean());
  9.  * }
  10.  * </p>
  11.  */
  12. public class Representer extends SafeRepresenter {
  14.     protected Map<Class<? extends Object>, TypeDescription> typeDefinitions = Collections.emptyMap();
  16.     public Representer() {
  17.         super(new DumperOptions());
  18.         this.representers.put(null, new RepresentJavaBean());
  19.     }
  21.     public Representer(DumperOptions options) {
  22.         super(options);
  23.         this.representers.put(null, new RepresentJavaBean());
  24.     }
  26.     public TypeDescription addTypeDescription(TypeDescription td) {
  27.         if (Collections.EMPTY_MAP == typeDefinitions) {
  28.             typeDefinitions = new HashMap<Class<? extends Object>, TypeDescription>();
  29.         }
  30.         if (td.getTag() != null) {
  31.             addClassTag(td.getType(), td.getTag());
  32.         }
  33.         td.setPropertyUtils(getPropertyUtils());
  34.         return typeDefinitions.put(td.getType(), td);
  35.     }
  37.     @Override
  38.     public void setPropertyUtils(PropertyUtils propertyUtils) {
  39.         super.setPropertyUtils(propertyUtils);
  40.         Collection<TypeDescription> tds = typeDefinitions.values();
  41.         for (TypeDescription typeDescription : tds) {
  42.             typeDescription.setPropertyUtils(propertyUtils);
  43.         }
  44.     }
  46.     protected class RepresentJavaBean implements Represent {
  48.         public Node representData(Object data) {
  49.             return representJavaBean(getProperties(data.getClass()), data);
  50.         }
  51.     }
  53.     /**
  54.      * Tag logic: - explicit root tag is set in serializer - if there is a predefined class tag it is
  55.      * used - a global tag with class name is always used as tag. The JavaBean parent of the specified
  56.      * JavaBean may set another tag (tag:yaml.org,2002:map) when the property class is the same as
  57.      * runtime class
  58.      *
  59.      * @param properties JavaBean getters
  60.      * @param javaBean   instance for Node
  61.      * @return Node to get serialized
  62.      */
  63.     protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {
  64.         List<NodeTuple> value = new ArrayList<NodeTuple>(properties.size());
  65.         Tag tag;
  66.         Tag customTag = classTags.get(javaBean.getClass());
  67.         tag = customTag != null ? customTag : new Tag(javaBean.getClass());
  68.         // flow style will be chosen by BaseRepresenter
  69.         MappingNode node = new MappingNode(tag, value, FlowStyle.AUTO);
  70.         representedObjects.put(javaBean, node);
  71.         FlowStyle bestStyle = FlowStyle.FLOW;
  72.         for (Property property : properties) {
  73.             Object memberValue = property.get(javaBean);
  74.             Tag customPropertyTag = memberValue == null ? null : classTags.get(memberValue.getClass());
  75.             NodeTuple tuple = representJavaBeanProperty(javaBean, property, memberValue, customPropertyTag);
  76.             if (tuple == null) {
  77.                 continue;
  78.             }
  79.             if (!((ScalarNode) tuple.getKeyNode()).isPlain()) {
  80.                 bestStyle = FlowStyle.BLOCK;
  81.             }
  82.             Node nodeValue = tuple.getValueNode();
  83.             if (!(nodeValue instanceof ScalarNode && ((ScalarNode) nodeValue).isPlain())) {
  84.                 bestStyle = FlowStyle.BLOCK;
  85.             }
  86.             value.add(tuple);
  87.         }
  88.         if (defaultFlowStyle != FlowStyle.AUTO) {
  89.             node.setFlowStyle(defaultFlowStyle);
  90.         } else {
  91.             node.setFlowStyle(bestStyle);
  92.         }
  93.         return node;
  94.     }
  96.     /**
  97.      * Represent one JavaBean property.
  98.      *
  99.      * @param javaBean      - the instance to be represented
  100.      * @param property      - the property of the instance
  101.      * @param propertyValue - value to be represented
  102.      * @param customTag     - user defined Tag
  103.      * @return NodeTuple to be used in a MappingNode. Return null to skip the property
  104.      */
  105.     protected NodeTuple representJavaBeanProperty(Object javaBean, Property property, Object propertyValue, Tag customTag) {
  106.         ScalarNode nodeKey = (ScalarNode) representData(property.getName());
  107.         // the first occurrence of the node must keep the tag
  108.         boolean hasAlias = this.representedObjects.containsKey(propertyValue);
  110.         Node nodeValue = representData(propertyValue);
  112.         if (propertyValue != null && !hasAlias) {
  113.             NodeId nodeId = nodeValue.getNodeId();
  114.             if (customTag == null) {
  115.                 if (nodeId == NodeId.scalar) {
  116.                     // generic Enum requires the full tag
  117.                     if (property.getType() != Enum.class) {
  118.                         if (propertyValue instanceof Enum<?>) {
  119.                             nodeValue.setTag(Tag.STR);
  120.                         }
  121.                     }
  122.                 } else {
  123.                     if (nodeId == NodeId.mapping) {
  124.                         if (property.getType() == propertyValue.getClass()) {
  125.                             if (!(propertyValue instanceof Map<?, ?>)) {
  126.                                 if (!nodeValue.getTag().equals(Tag.SET)) {
  127.                                     nodeValue.setTag(Tag.MAP);
  128.                                 }
  129.                             }
  130.                         }
  131.                     }
  132.                     checkGlobalTag(property, nodeValue, propertyValue);
  133.                 }
  134.             }
  135.         }
  137.         return new NodeTuple(nodeKey, nodeValue);
  138.     }
  140.     /**
  141.      * Remove redundant global tag for a type safe (generic) collection if it is the same as defined
  142.      * by the JavaBean property
  143.      *
  144.      * @param property - JavaBean property
  145.      * @param node     - representation of the property
  146.      * @param object   - instance represented by the node
  147.      */
  148.     @SuppressWarnings("unchecked")
  149.     protected void checkGlobalTag(Property property, Node node, Object object) {
  150.         // Skip primitive arrays.
  151.         if (object.getClass().isArray() && object.getClass().getComponentType().isPrimitive()) {
  152.             return;
  153.         }
  155.         Class<?>[] arguments = property.getActualTypeArguments();
  156.         if (arguments != null) {
  157.             if (node.getNodeId() == NodeId.sequence) {
  158.                 // apply map tag where class is the same
  159.                 Class<? extends Object> t = arguments[0];
  160.                 SequenceNode snode = (SequenceNode) node;
  161.                 Iterable<Object> memberList = Collections.emptyList();
  162.                 if (object.getClass().isArray()) {
  163.                     memberList = Arrays.asList((Object[]) object);
  164.                 } else if (object instanceof Iterable<?>) {
  165.                     // list
  166.                     memberList = (Iterable<Object>) object;
  167.                 }
  168.                 Iterator<Object> iter = memberList.iterator();
  169.                 if (iter.hasNext()) {
  170.                     for (Node childNode : snode.getValue()) {
  171.                         Object member = iter.next();
  172.                         if (member != null) {
  173.                             if (t.equals(member.getClass())) {
  174.                                 if (childNode.getNodeId() == NodeId.mapping) {
  175.                                     childNode.setTag(Tag.MAP);
  176.                                 }
  177.                             }
  178.                         }
  179.                     }
  180.                 }
  181.             } else if (object instanceof Set) {
  182.                 Class<?> t = arguments[0];
  183.                 MappingNode mnode = (MappingNode) node;
  184.                 Iterator<NodeTuple> iter = mnode.getValue().iterator();
  185.                 Set<?> set = (Set<?>) object;
  186.                 for (Object member : set) {
  187.                     NodeTuple tuple = iter.next();
  188.                     Node keyNode = tuple.getKeyNode();
  189.                     if (t.equals(member.getClass())) {
  190.                         if (keyNode.getNodeId() == NodeId.mapping) {
  191.                             keyNode.setTag(Tag.MAP);
  192.                         }
  193.                     }
  194.                 }
  195.             } else if (object instanceof Map) { // NodeId.mapping ends-up here
  196.                 Class<?> keyType = arguments[0];
  197.                 Class<?> valueType = arguments[1];
  198.                 MappingNode mnode = (MappingNode) node;
  199.                 for (NodeTuple tuple : mnode.getValue()) {
  200.                     resetTag(keyType, tuple.getKeyNode());
  201.                     resetTag(valueType, tuple.getValueNode());
  202.                 }
  203.             } else {
  204.                 // the type for collection entries cannot be
  205.                 // detected
  206.             }
  207.         }
  208.     }
  210.     private void resetTag(Class<? extends Object> type, Node node) {
  211.         Tag tag = node.getTag();
  212.         if (tag.matches(type)) {
  213.             if (Enum.class.isAssignableFrom(type)) {
  214.                 node.setTag(Tag.STR);
  215.             } else {
  216.                 node.setTag(Tag.MAP);
  217.             }
  218.         }
  219.     }
  221.     /**
  222.      * Get JavaBean properties to be serialised. The order is respected. This method may be overridden
  223.      * to provide custom property selection or order.
  224.      *
  225.      * @param type - JavaBean to inspect the properties
  226.      * @return properties to serialise
  227.      */
  228.     protected Set<Property> getProperties(Class<? extends Object> type) {
  229.         if (typeDefinitions.containsKey(type)) {
  230.             return typeDefinitions.get(type).getProperties();
  231.         }
  232.         return getPropertyUtils().getProperties(type);
  233.     }
  234. }

注意：实体类ID生成算法使用分布式雪花算法，mapper层、service层照旧即可。

  1. @Getter
  2. @Setter
  3. @ToString
  4. @Accessors(chain = true)
  5. @TableName("tb_user")
  6. @Schema(description = "用户")
  7. public class User implements Serializable {
  9.     @Serial
  10.     private static final long serialVersionUID = 1129496589110730436L;
  12.     @TableId(value = "id", type = IdType.ASSIGN_ID)
  13.     @Schema(description = "主键ID")
  14.     private Long id;
  16.     @TableField("create_time")
  17.     @Schema(description = "创建时间")
  18.     private Long createTime;
  20.     @TableField("name")
  21.     @Schema(description = "姓名")
  22.     private String name;
  24. }

示例表结构（此处以水平分片-分表为例）

  1. DROP TABLE IF EXISTS tb_user;
  2. CREATE TABLE `tb_user`
  3. (
  4.     `id`          BIGINT PRIMARY KEY NOT NULL COMMENT '主键ID',
  5.     `create_time` BIGINT      DEFAULT NULL COMMENT '创建时间',
  6.     `name`        VARCHAR(32) DEFAULT NULL COMMENT '姓名'
  7. );
  9. DROP TABLE IF EXISTS tb_user0;
  10. CREATE TABLE `tb_user0`
  11. (
  12.     `id`          BIGINT PRIMARY KEY NOT NULL COMMENT '主键ID',
  13.     `create_time` BIGINT      DEFAULT NULL COMMENT '创建时间',
  14.     `name`        VARCHAR(32) DEFAULT NULL COMMENT '姓名'
  15. );
  17. DROP TABLE IF EXISTS tb_user1;
  18. CREATE TABLE `tb_user1`
  19. (
  20.     `id`          BIGINT PRIMARY KEY NOT NULL COMMENT '主键ID',
  21.     `create_time` BIGINT      DEFAULT NULL COMMENT '创建时间',
  22.     `name`        VARCHAR(32) DEFAULT NULL COMMENT '姓名'
  23. )

配置文件（此处以水平分片-分表为例），其他可自行配置数据源进行测试：

  1. # 数据源配置
  2. dataSources:
  3.   dsA:
  4.     dataSourceClassName: com.zaxxer.hikari.HikariDataSource
  5.     driverClassName: org.h2.Driver
  6.     url: jdbc:h2:mem:db_sharding
  7.     username: sa # 用户名，用于控制台登录
  8.     password: 123456 # 密码，用于控制台登录
  9.   dsB0:
  10.     dataSourceClassName: com.zaxxer.hikari.HikariDataSource
  11.     driverClassName: org.h2.Driver
  12.     url: jdbc:h2:mem:db_sharding
  13.     username: sa # 用户名，用于控制台登录
  14.     password: 123456 # 密码，用于控制台登录
  15.   dsB1:
  16.     dataSourceClassName: com.zaxxer.hikari.HikariDataSource
  17.     driverClassName: org.h2.Driver
  18.     url: jdbc:h2:mem:db_sharding
  19.     username: sa # 用户名，用于控制台登录
  20.     password: 123456 # 密码，用于控制台登录
  21. # 规则配置
  22. rules:
  23.   - !SINGLE
  24.     tables:
  25.       - "*.*"
  26.   - !SHARDING
  27.     tables:
  28.       # 逻辑表名
  29.       tb_user:
  30.         actualDataNodes: dsB0.tb_user${0..1}
  31.         # 分库策略
  32.         tableStrategy:
  33.           standard:
  34.             # 分片列名称
  35.             shardingColumn: id
  36.             # 分片算法名称
  37.             shardingAlgorithmName: inline_id
  38.     # 分片算法配置
  39.     shardingAlgorithms:
  40.       # 标准分片算法-行表达式分片算法
  41.       inline_id:
  42.         # 基于行表达式的分片算法
  43.         type: INLINE
  44.         props:
  45.           algorithm-expression: tb_user${id % 2}
  46. # 属性配置
  47. props:
  48.   sql-show: true

最后，启动项目

访问 http://localhost:8080/doc.html 接口文档进行测试

访问 http://localhost:8080/h2 数据库控制台，输入用户名、密码，查看数据库信息

整合DEMO仓库地址

标签： mybatis spring boot spring
本文转载自: https://blog.csdn.net/qq_37220802/article/details/137262023
版权归原作者 ゞ註﹎錠oo 所有， 如有侵权，请联系我们删除。
登录后发布评论

“spring-boot 整合 shardingsphere-jdbc、mybatis-plus 数据分片（文末有彩蛋）”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？