ShardingSphere简单实现

已于 2023-01-13 09:07:52 修改
阅读量560 收藏 1
点赞数 1
分类专栏： mysql 数据扩展 java 文章标签： mybatis java spring
于 2023-01-12 16:50:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37808678/article/details/128662204
版权
java 同时被 3 个专栏收录
10 篇文章 0 订阅
订阅专栏
数据扩展
4 篇文章 0 订阅
订阅专栏
mysql
2 篇文章 0 订阅
订阅专栏

一：pom.xml相关引用

<?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">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>lab-18-sharding-datasource-01</artifactId>

    <dependencies>
        <!--web依赖：tomcat,dispatcherServlet,xml..-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!-- 实现对数据库连接池的自动化配置 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency> <!-- 本示例，我们使用 MySQL -->
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>

        <!-- 实现对 MyBatis 的自动化配置 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

        <!-- 实现对 Sharding-JDBC 的自动化配置 -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC2</version>
        </dependency>

        <!-- 保证 Spring AOP 相关的依赖包 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>

        <!-- 方便等会写单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>

二:启动类Application

@SpringBootApplication
@MapperScan(basePackages = "cn.iocoder.springboot.lab18.shardingdatasource.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

三：yaml配置

server:
  port: 8126

spring:
  # ShardingSphere 配置项
  shardingsphere:
    datasource:
      # 所有数据源的名字
      names: ds-orders-0, ds-orders-1
      # 订单 orders 数据源配置 00
      ds-orders-0:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3310/lab18_orders_0?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
      # 订单 orders 数据源配置 01
      ds-orders-1:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3310/lab18_orders_1?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
    # 分片规则
    sharding:
      tables:
        # orders 表配置
        orders:
#          actualDataNodes: ds-orders-$->{0..1}.orders_$->{0..4} # 映射到 ds-orders 数据源的 orders 表
#          actualDataNodes: ds-orders-0.orders_0, ds-orders-0.orders_2, ds-orders-0.orders_4, ds-orders-0.orders_6, ds-orders-1.orders_1, ds-orders-1.orders_3, ds-orders-1.orders_5, ds-orders-1.orders_7
          actualDataNodes: ds-orders-0.orders_$->{[0,2,4,6]}, ds-orders-1.orders_$->{[1,3,5,7]} # 映射到 ds-orders-0 和 ds-orders-1 数据源的 orders 表们
          key-generator: # 主键生成策略
            column: id
            type: SNOWFLAKE
          database-strategy:
            inline:
              algorithm-expression: ds-orders-$->{user_id % 2}
              sharding-column: user_id
          table-strategy:
            inline:
              algorithm-expression: orders_$->{user_id % 8}
              sharding-column: user_id
        # order_config 表配置
        order_config:
          actualDataNodes: ds-orders-0.order_config # 仅映射到 ds-orders-0 数据源的 order_config 表
    # 拓展属性配置
    props:
      sql:
        show: true # 打印 SQL

# mybatis 配置内容
mybatis:
  config-location: classpath:mybatis-config.xml # 配置 MyBatis 配置文件路径
  mapper-locations: classpath:mapper/*.xml # 配置 Mapper XML 地址
  type-aliases-package: cn.iocoder.springboot.lab18.shardingdatasource.dataobject # 配置数据库实体包路径

四：MyBatis配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!-- 使用驼峰命名法转换字段。 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer"/>
        <typeAlias alias="Long" type="java.lang.Long"/>
        <typeAlias alias="HashMap" type="java.util.HashMap"/>
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap"/>
        <typeAlias alias="ArrayList" type="java.util.ArrayList"/>
        <typeAlias alias="LinkedList" type="java.util.LinkedList"/>
    </typeAliases>

</configuration>

五：实体类

五.一:OrderDO

package cn.iocoder.springboot.lab18.shardingdatasource.dataobject;

/**
 * 订单 DO
 */
public class OrderDO {

    /**
     * 订单编号
     */
    private Long id;
    /**
     * 用户编号
     */
    private Integer userId;

    public Long getId() {
        return id;
    }

    public OrderDO setId(Long id) {
        this.id = id;
        return this;
    }

    public Integer getUserId() {
        return userId;
    }

    public OrderDO setUserId(Integer userId) {
        this.userId = userId;
        return this;
    }

    @Override
    public String toString() {
        return "OrderDO{" +
                "id=" + id +
                ", userId=" + userId +
                '}';
    }

}

在 lab18_orders_0 数据库下，创建 orders_0、orders_2、orders_4、orders_6 数据表。SQL 如下：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for orders_0
-- ----------------------------
DROP TABLE IF EXISTS `orders_0`;
CREATE TABLE `orders_0` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

-- ----------------------------
-- Table structure for orders_2
-- ----------------------------
DROP TABLE IF EXISTS `orders_2`;
CREATE TABLE `orders_2` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

-- ----------------------------
-- Table structure for orders_4
-- ----------------------------
DROP TABLE IF EXISTS `orders_4`;
CREATE TABLE `orders_4` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

-- ----------------------------
-- Table structure for orders_6
-- ----------------------------
DROP TABLE IF EXISTS `orders_6`;
CREATE TABLE `orders_6` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

SET FOREIGN_KEY_CHECKS = 1;

在 lab18_orders_1 数据库下，创建 orders_1、orders_3、orders_5、orders_7 数据表。SQL 如下：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for orders_1
-- ----------------------------
DROP TABLE IF EXISTS `orders_1`;
CREATE TABLE `orders_1` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=400675304294580226 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

-- ----------------------------
-- Table structure for orders_3
-- ----------------------------
DROP TABLE IF EXISTS `orders_3`;
CREATE TABLE `orders_3` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

-- ----------------------------
-- Table structure for orders_5
-- ----------------------------
DROP TABLE IF EXISTS `orders_5`;
CREATE TABLE `orders_5` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

-- ----------------------------
-- Table structure for orders_7
-- ----------------------------
DROP TABLE IF EXISTS `orders_7`;
CREATE TABLE `orders_7` (
  `id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT '订单编号',
  `user_id` int(16) DEFAULT NULL COMMENT '用户编号',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单表';

SET FOREIGN_KEY_CHECKS = 1;

五.二：OrderConfigDO

// OrderConfigDO.java

/**
 * 订单配置 DO
 */
public class OrderConfigDO {

    /**
     * 编号
     */
    private Integer id;
    /**
     * 支付超时时间
     *
     * 单位：分钟
     */
    private Integer payTimeout;

    // ... 省略 setting/getting 方法
}

在 lab18_orders_0 数据库下，创建 orders_0 数据表。SQL 如下：

-- ----------------------------
-- Table structure for order_config
-- ----------------------------
DROP TABLE IF EXISTS `order_config`;
CREATE TABLE `order_config` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '编号',
  `pay_timeout` int(11) DEFAULT NULL COMMENT '支付超时时间;单位：分钟',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='订单配置表';

六：Mapper

六.一:OrderMapper

// OrderMapper.java

@Repository
public interface OrderMapper {

    OrderDO selectById(@Param("id") Integer id);

    List<OrderDO> selectListByUserId(@Param("userId") Integer userId);

    void insert(OrderDO order);

}

六.二:OrderMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.springboot.lab18.shardingdatasource.mapper.OrderMapper">

    <sql id="FIELDS">
        id, user_id
    </sql>

    <select id="selectById" parameterType="Integer" resultType="OrderDO">
        SELECT
            <include refid="FIELDS" />
        FROM orders
        WHERE id = #{id}
    </select>

    <select id="selectListByUserId" parameterType="Integer" resultType="OrderDO">
        SELECT
            <include refid="FIELDS" />
        FROM orders
        WHERE user_id = #{userId}
    </select>

    <insert id="insert" parameterType="OrderDO" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO orders (
            user_id
        ) VALUES (
            #{userId}
        )
    </insert>

</mapper>

六.三：OrderConfigMapper

// OrderConfigMapper.java

@Repository
public interface OrderConfigMapper {

    OrderConfigDO selectById(@Param("id") Integer id);

}

六.四OrderConfigMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.springboot.lab18.shardingdatasource.mapper.OrderConfigMapper">

    <sql id="FIELDS">
        id, pay_timeout
    </sql>

    <select id="selectById" parameterType="Integer" resultType="OrderConfigDO">
        SELECT
            <include refid="FIELDS" />
        FROM order_config
        WHERE id = #{id}
    </select>

</mapper>

总结：

  • 在 mybatis 配置项下，设置 mybatis-spring-boot-starter 自动化配置 MyBatis 需要的参数。
  • 在 spring.shardingsphere 配置项下，设置 sharding-jdbc-spring-boot-starter 自动化配置 Sharding-JDBC 需要的参数。比较复杂，我们一个一个来看。

spring.shardingsphere.datasource 配置项，我们配置了 ds-orders-0 和 ds-orders-1 两个数据源，分别对应 lab18_orders_0 和 lab18_orders_1 两个数据库。

spring.shardingsphere.sharding 配置项，我们配置了 orders 和 order_config 逻辑表 。

逻辑表 ：水平拆分的数据库（表）的相同逻辑和数据结构表的总称。例：订单数据根据主键尾数拆分为 10 张表，分别是 t_order_0 到 t_order_9 ，他们的逻辑表名为 t_order 。

真实表 ：在分片的数据库中真实存在的物理表。即上个示例中的 t_order_0 到 t_order_9 。

数据节点 ：数据分片的最小单元。由数据源名称和数据表组成，例：ds_0.t_order_0 。

  • orders 配置项，设置 orders 逻辑表，使用分库分表的规则。
    • actualDataNodes ：对应的数据节点，使用的是行表达式 。这里的意思是，ds-orders-0.orders_0, ds-orders-0.orders_2, ds-orders-0.orders_4, ds-orders-0.orders_6, ds-orders-1.orders_1, ds-orders-1.orders_3, ds-orders-1.orders_5, ds-orders-1.orders_7 。
    • key-generator ：主键生成策略。这里采用分布式主键 SNOWFLAKE 方案。更多可以看 《 ShardingSphere > 概念 & 功能 > 数据分片 > 其他功能 > 分布式主键》 文档。
    • database-strategy ：按照 index = user_id % 2 分库，路由到 ds-orders-${index} 数据源（库）。
    • table-strategy ：index = user_id % 8 分表，路由到 orders_${index} 数据表。
  • order_config 配置项，设置 order_config 逻辑表，不使用分库分表。
    • actualDataNodes ：对应的数据节点，只对应数据源（库）为 ds-orders-0 的 order_config 表。

spring.shardingsphere.props 配置项，设置拓展属性配置。

  • sql.show ：设置打印 SQL 。因为我们编写的 SQL 会被 Sharding-JDBC 进行处理，实际执行的可能不是我们编写的，通过打印，方便我们观察和理解。

整体结构：

跑码者~英子
关注
专栏目录
ShardingSphere-proxy-5.0.0的部署之哈希分片的实现(五十一)
笨鸟不会飞
11-27 514
在ShardingSphere-proxy的部署之哈希分片的实现(二十八)中我们讲解了基于5.0.0-alpha版ShardingSphere-proxy的部署之哈希取模分片的实现，那么在本章我们将为大家讲解5.0.0版本ShardingSphere-proxy的部署之哈希取模分片实现，看下和旧版的有什么区别 在前面的章节我们已经创建好了我们的哈希取模分片的数据了，那么在本章我们直接在我们的config-sharding.yaml中配置我们的哈希取模分片算法即可。 1、配置config-sharding.
Spring Boot集成ShardingSphere实现数据分片（二） | Spring Cloud 41
热门推荐
gmHappy
04-26 1万+
数据分片的拆分方式分为垂直分片和水平分片。而在实际的业务场景中可以分为：垂直分表、垂直分库、水平分表、水平分库。
shardingsphere实现分库分表
u010772230的专栏
01-03 2013
实验环境 springboot版本：2.2.2.RELEASE shardingsphere版本：4.0.0-RC3 实验说明： 数据库：demo_ds_0，demo_ds_1 表user,分别在demo_ds_0，demo_ds_1各自建两张user表，user_1和user_2，两个库共四个表 user表结构如下，自行改表名在两个库各执行一次即可。 CREATE TABLE `...
ShardingSphere实战（2）- 水平分表
最新发布
java_liuyuan的博客
07-30 424
ShardingSphere实战（2）- 水平分表
shardingsphere 分库分表实现
qq_14926283的博客
12-02 4848
这里主要讲讲shardingsphere 的内容 首先要明白数据库的瓶颈 不管是IO瓶颈，还是CPU瓶颈，最终都会导致数据库的活跃连接数增加，进而逼近甚至达到数据库可承载活跃连接数的阈值。在业务Service来看就是，可用数据库连接少甚至无连接可用。接下来就可以想象了吧（并发量、吞吐量、崩溃）。 1. 都知道数据库连接资源有限的吧，想想一个数据库如何在打并发的时候支撑的下来 这也就是IO的概念 也就是IO瓶颈 2. 数据量也会造成瓶颈，数据量...
ShardingSphere 全新示例模块实现原理以及使用说明
ShardingSphere官微
04-24 466
问题分析‍‍‍‍‍‍ShardingSphere 经过几年的迅速发展，核心的功能模块已经有六个，并且支持了不同的注册中心如 ZooKeeper， Nacos、分布式事务以及不同的开发框架，功能是十分强大且完善的。那么如何将这么强大而且完善的功能让用户轻松的上手使用就是一个比较大的难题。由此，我们开发了一个 example 模块，通过对于不同功能特性、注册中心、服务框架的组合以及业务逻辑的抽象，形成...
分布式事务在Sharding-Sphere中的实现
hellozhxy的博客
07-31 663
分布式事务的使用场景 01 ACID 一切从ACID开始说起。ACID是本地事务所具有的四大特征： Atomicity：原子性 事务作为整体来执行，要么全部执行，要么全不执行。 Consistency：一致性 事务应确保数据从一个一致的状态转变为另一个一致的状态。 Isolation：隔离性 多个事务并发执行时，一个事务的执行不应影响其他事务的执行。 Durability：持久性 已提交的事务修改数据会被持久保持。 关系型数据库的本地事务完美的提
shardingsphere-jdbc实现简单的单库分表
06-05
在本文中，我们将深入探讨如何使用ShardingSphere-JDBC来实现简单的单库分表策略，以便更好地管理和优化数据库性能。 首先，我们需要了解什么是数据分片。数据分片是将一个大型数据库拆分成多个较小的部分，每个...
(三)springboot 整合shardingsphere 实现读写分离
qq_35840912的博客
12-01 1734
springboot shardingsphere
ShardingSphere 5.1.2 版源码
08-09
描述"ShardingSphere 5.1.2 版源码"简单明了，表明我们关注的重点是这一特定版本的源代码，意味着我们将深入研究其内部实现，理解其设计思路和工作原理。 **标签解析** "shardingsphere 软件/插件"标签表明...
ShardingSphere 实现数据加密（脱敏）第一篇
m0_38017860的博客
05-26 869
背景 Apache ShardingSphere 通过对用户输入的 SQL 进行解析，并依据用户提供的加密规则对 SQL 进行改写，从而实现对原文数据进行加密，并将原文数据（可选）及密文数据同时存储到底层数据库。 在用户查询数据时，它仅从数据库中取出密文数据，并对其解密，最终将解密后的原始数据返回给用户。 Apache ShardingSphere 自动化 & 透明化了数据加密过程，让用户无需关注数据加密的实现细节，像使用普通数据那样使用加密数据。 此外，无论是已在线业务进行加密改造，还是新上线业务
Java基于ShardingSphere实现分库分表的实例
星火染星野的博客
06-09 1079
Java基于ShardingSphere实现分库分表的实例
ShardingSphere-proxy-5.0.0分布式哈希取模分片实现(四)
tmchongye的专栏
06-22 620
一、说明主要是对字符串的字段进行hash取模二、修改配置文件config-sharding.yaml，并重启服务 # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyrig
maven教程：mvn install本地jar包shardingsphere-jdbc-core-spring-boot-starter到本地Maven仓库
学亮编程手记
01-30 497
【代码】maven教程：mvn install本地jar包shardingsphere-jdbc-core-spring-boot-starter到本地Maven仓库。
ShardingSphere 读写分离配置
scofild950303的博客
12-06 978
Apache ShardingSphere 是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。
ShardingSphere之HiKariCP和Druid
sinat_38247666的博客
06-18 3196
场景 由于需要对人员信息的个别字段进行加密处理，所以我们使用了ShardingSphere相应的加密功能。 在压测人员信息查询的接口时，使用了1000个线程，每个线程请求100次，在10分钟完成。压测开始前几分钟还是好好的，但是后面会报500的错误，并且响应时长都在1s以上，错误原因是服务调用超时(我们使用的微服务架构)，我们尝试的方法如下： 通过扩容会好一点点，但是不能明显减少错误和相应时间； 扩大连接池数，和扩容的效果相似。 解决方法 将原来的数据库链接池由Druid改为了HiKariCP，不仅没有
Spring Boot学习：ShardingSphere-JDBC数据分片配置
qq_36551991的博客
12-14 2597
Spring Boot项目ShardingSphere-JDBC数据分片配置
ShardingSphere学习
weixin_45976114的博客
03-26 2771
ShardingSphere学习一.什么是 ShardingSphere二.什是分库分表三.分库分表的方式1.垂直分表2.垂直分库3.水平分表4.水平分库 一.什么是 ShardingSphere 一套开源的分布式数据库中间件解决方案 有三个产品：Sharding-JDBC 和 Sharding-Proxy 定位为关系型数据库中间件，合理在分布式环境下使用关系型数据库操作 二.什是分库分表 数据库数据量不可控的，随着时间和业务发展，造成表里面数据越来越多，如果再去对数 据库表 curd 操作时候，造成性
springmvc配置shardingsphere，多数据源
weixin_40086375的博客
04-25 1682
网上搜索shardingsphere配置教程，绝大部分都是使用springboot来配置，但是在springmvc架构中配置很少，唯一看到的一个篇章需要收费，便通过官方文档以及查询相关资料，终于完成了该篇文章。注意：在该文章中，使用了多数据源配置，因为不是所有表都需要分表，由于shardingsphere对部分sql语法不支持，为了不影响不分表的sql能正常执行，减少代码修改，在执行sql时切换数据源。该配置文件包含分库分表数据源配置，分库分表策略规则。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值