Spring整合sharding-jdbc实现分库分表

最新推荐文章于 2024-09-22 21:58:06 发布
最新推荐文章于 2024-09-22 21:58:06 发布
阅读量1.3k 收藏 4
点赞数
分类专栏： MySQL 文章标签： Spring整合sharding-jdbc 分库分表 分布式主键 sharding-jdbc MySQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kangswx/article/details/95225217
版权

  1. 准备两台数据库服务器 192.168.18.179 和 192.168.18.180，如下图

  2. 对于不知道怎么在Linux服务器中安装MySQL的，可以参考 CentOS下安装MySQL5.7(图文)

  3. 在192.168.18.179中新建一个数据库mall_0，如下图

  4. 在192.168.18.180中新建一个数据库mall_1，如下图

  5. 在mall_0和mall_1中分别运行下面的sql脚本(在每个库中新建两张表分别为t_order_0，t_order_1)

    SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

DROP TABLE IF EXISTS `t_order_0`;
CREATE TABLE `t_order_0`  (
  `order_id` bigint(20) NOT NULL,
  `user_id` int(11) NOT NULL,
  `status` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;


DROP TABLE IF EXISTS `t_order_1`;
CREATE TABLE `t_order_1`  (
  `order_id` bigint(20) NOT NULL,
  `user_id` int(11) NOT NULL,
  `status` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci NULL DEFAULT NULL,
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci ROW_FORMAT = Dynamic;


SET FOREIGN_KEY_CHECKS = 1;

  6. 接下来新建一个maven工程 spring-shardingjdbc

  7. 在pom.xml文件中引入依赖

    <dependencies>
    <!-- sharding的核心包 -->
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-core</artifactId>
        <version>4.0.0-RC1</version>
    </dependency>

    <!-- sharding整合spring依赖 -->
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-namespace</artifactId>
        <version>4.0.0-RC1</version>
    </dependency>

    <!--spring的依赖包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>

    <!--jdbc驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>

    <!--HikariCP数据库连接池-->
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
        <version>3.2.0</version>
    </dependency>

    <!-- 单元测试 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

  8. 在 main\resource 下新建一个spring配置文件applicationContext.xml，并配置spring与shardingJDBC整合的配置项

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:sharding="http://shardingsphere.apache.org/schema/shardingsphere/sharding"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://shardingsphere.apache.org/schema/shardingsphere/encrypt http://shardingsphere.apache.org/schema/shardingsphere/encrypt/encrypt.xsd http://shardingsphere.apache.org/schema/shardingsphere/sharding http://shardingsphere.apache.org/schema/shardingsphere/sharding/sharding.xsd">

    <!--数据库0-->
    <bean id="ds0" class="com.zaxxer.hikari.HikariDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.18.179:3306/mall_0?useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--数据库1-->
    <bean id="ds1" class="com.zaxxer.hikari.HikariDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://192.168.18.180:3306/mall_1?useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!-- 数据的分库策略
     sharding-column  基于user_id进行分库
     如果user_id对2取余为0则将数据存放在ds0数据库
     如果user_id对2取余为1则将数据存放在ds1数据库
     -->
    <sharding:inline-strategy id="databaceStrategy" sharding-column="user_id"
                              algorithm-expression="ds$->{user_id % 2}"/>

    <!-- 数据的分表策略
    sharding-column  基于order_id进行分表
    如果order_id对2取余为0则将数据存放在t_order_0表中
    如果order_id对2取余为1则将数据存放在t_order_1表中
    -->
    <sharding:inline-strategy id="orderTableStrategy" sharding-column="order_id"
                              algorithm-expression="t_order_$->{order_id % 2}"/>

    <!-- 分片数据源，对JDBC进行了扩展和增强 -->
    <sharding:data-source id="shardingDataSource">
        <!-- sharding-rule  定义分库分表规则
            data-source-names="ds0,ds1"  说明有几个数据源
            sharding:table-rules  定义数据存储规则
            logic-table="t_order"  代表逻辑表名
            actual-data-nodes说明数据存放在ds0和ds1的t_order_0和t_order_1四张表中
            database-strategy-ref  数据的分库策略
            table-strategy-ref  数据的分表策略

            order_id     user_id
            1            2           ds0.t_order_1
            2            2           ds0.t_order_0
            3            1           ds1.t_order_1
            4            1           ds1.t_order_0
        -->
        <sharding:sharding-rule data-source-names="ds0,ds1"> <!-- 通知shardingJDBC一共有两个数据源 -->
            <sharding:table-rules>
                <sharding:table-rule logic-table="t_order"
                    actual-data-nodes="ds$->{0..1}.t_order_$->{0..1}"
                                     database-strategy-ref="databaceStrategy"
                                     table-strategy-ref="orderTableStrategy"
                />
            </sharding:table-rules>
        </sharding:sharding-rule>
    </sharding:data-source>
</beans>

  9. 编写插入的测试代码

    import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public class ShardingTest {

    @Resource(name = "shardingDataSource")  //此处引入的是配置文件中定义的shardingDataSource
    private DataSource dataSource;

    @Test
    public void testInsert() throws SQLException {
        Connection connection = dataSource.getConnection();
        //t_order为逻辑表
        String sql = "insert into t_order(order_id, user_id, status) values(2, 2, 'N')";  
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.executeUpdate();
        
        preparedStatement.close();
        connection.close();
    }
}

  10. 插入数据测试一

    insert into t_order(order_id, user_id, status) values(1, 2, 'N')

    数据成功插入到了mall0的t_order_1表中

  11. 插入数据测试二

    insert into t_order(order_id, user_id, status) values(2, 2, 'N')

    数据成功插入到了mall0的t_order_0表中

    在这里插入图片描述

  12. 插入数据测试三

    insert into t_order(order_id, user_id, status) values(3, 1, 'N')

    数据成功插入到了mall1的t_order_1表中

  13. 插入数据测试四

    insert into t_order(order_id, user_id, status) values(4, 1, 'N')

    数据成功插入到了mall1的t_order_0表中

  14. 编写查询的测试代码

    @Test
public void testQuery() throws SQLException {
    Connection connection = dataSource.getConnection();
    /**
    * select * from t_order 
    * 分解sql
    * select * from ds0.t_order_0
    * select * from ds0.t_order_1
    * select * from ds1.t_order_0
    * select * from ds1.t_order_1
    * 最后将结果合并
    */
    String sql = "select * from t_order order by order_id";
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    ResultSet resultSet = preparedStatement.executeQuery();
    while (resultSet.next()){
        System.out.println("order_id: "+resultSet.getLong("order_id")
                           +", user_id: "+ resultSet.getLong("user_id")
                           + " status: "+resultSet.getString("status"));
    }
    resultSet.close();
    preparedStatement.close();
    connection.close();
}
/**
	测试结果(一次性将四张表中的数据都查询出来了)
		order_id: 2, user_id: 2 status: N
		order_id: 1, user_id: 2 status: N
		order_id: 4, user_id: 1 status: N
		order_id: 3, user_id: 1 status: N
*/

  15. 分库分表后，不能使用自动生成的主键，否则在查询的结果中会出现大量的重复的主键，所以在分库分表后需要使用分布式主键生成策略。

  16. 分布式主键生成策略为主键生成全局唯一的值，将主键放在任何一台数据库中都是唯一的。

  17. shardingsphere支持多种分布式主键生成策略，包括UUID，SNOWFLAKE(雪花算法,能保证不同进程的主键不重复，以及相同进程的主键的有序性)，时钟回拨，LEAF(借助注册中心生成分布式自增主键)

  18. shardingJDBC整合SNOWFLAKE，在配置文件中加入

    <!-- 分布式主键生成策略(雪花算法) -->
<sharding:key-generator id="orderKeyGenerator" type="SNOWFLAKE" column="order_id"/>

 <sharding:table-rule logic-table="t_order"
     actual-data-nodes="ds$->{0..1}.t_order_$->{0..1}"
     database-strategy-ref="databaceStrategy"
     table-strategy-ref="orderTableStrategy"
     key-generator-ref="orderKeyGenerator"
  />

  19. 新增分布式主键生成测试代码

    /**
* 测试批量插入(分布式主键)
* @throws SQLException
*/
@Test
public void testBatchInsert() throws SQLException {
    Connection connection = dataSource.getConnection();
    for (int i = 0; i < 10; i++) {
        String sql = "insert into t_order(user_id, status) values(?, 'N')";
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setLong(1, i);
        preparedStatement.executeUpdate();
        preparedStatement.close();
    }
    connection.close();
}
/**
	测试结果，发现所有的数据均匀的分布在两个库中
*/

  20. 具体的代码见 Spring整合sharding-jdbc实现分库分表

kangswx
关注
专栏目录
springboot整合sharding-jdbc实现分库分表详解
congge
05-21 6905
springboot整合sharding-jdbc实现分库分表详解
spring+mybatis+sharding-jdbc 整合
03-19
下载后要jdk1.7 ，sql也在conf下，文档在http://blog.csdn.net/linuu/article/details/50929904
项目集成sharding-jdbc
最新发布
luosuss的博客
09-22 1127
目录项目集成sharding-jdbc1.业务分析 2.数据库构建3.分库分表策略 项目配置默认数据源一：导入sharding-jdbc依赖 二：在application文件中编写配置三：注释掉主配置文件中配置的数据源注意：这里添加了spring.main.allow-bean-definition-overriding: true四：测试项目配置广播表（公共表）一:application配置二：测试项目使用standard标准模式配置分库算法一.分库算法类 二.application中配置逻辑表对应的数据
SpringBoot整合Sharding-JDBC通过标准分片策略(Standard)实现分表操作
热门推荐
一恍过去
09-09 2万+
SpringBoot整合Sharding-JDBC通过标准分片策略(Standard)实现分表操作
SpringBoot 整合sharding jdbc实现分库分表
12-15 926
SpringBoot 整合sharding jdbc实现分库分表
Spring Boot中整合Sharding-JDBC
05-03
NULL 博文链接：https://huangyongxing310.iteye.com/blog/2434356
Spring Boot 整合 Sharding-JDBC
woaiwojialanxi的专栏
03-05 4269
概述 ShardingSphere，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成。定位为轻量级Java框架。其实就是一个增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。内部改写了SQL的添加和查询规则。适用于任何基于Java的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。 技术架构： Spring Boot 2.6....
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
本篇文章将详细讲解如何使用Spring Boot结合Sharding-JDBC和Mybatis-Plus实现分库分表功能。 一、Sharding-JDBC简介 Sharding-JDBC是由Apache ShardingSphere项目提供的一个轻量级数据库中间件，它作为JDBC驱动...
集成sharding-jdbc实现分库分表.zip
12-19
在这个"集成sharding-jdbc实现分库分表.zip"的压缩包中，我们可以深入学习如何将Sharding-JDBC应用于实际项目，以提升系统的性能和可扩展性。 1. **Sharding-JDBC简介** Sharding-JDBC是Java语言实现的，它工作在...
SpringBoot+Mybatis-Plus整合Sharding-JDBC5.1.1实现单库分表【全网最新】.doc
07-09
传统的分库分表方案如Mycat虽然强大，但因其bug较多，使得许多人转向Sharding-JDBC等更为稳定可靠的方案。本文将详细介绍如何使用SpringBoot、Mybatis-Plus以及Sharding-JDBC 5.1.1版本来实现单库分表。 #### 二、...
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表
08-25
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表是指在 Spring Boot 2.0 框架下使用 sharding-jdbc 中间件来实现数据分库分表的技术方案。在这个方案中，sharding-jdbc 中间件扮演着核心角色，它可以将一个...
spring-sharding-mybatis
10-22
spring-sharding-mybatisspring-sharding-mybatisspring-sharding-mybatis
SpringBoot 整合 Sharding-JDBC
qq_35850889的博客
11-25 1万+
SpringBoot 整合 Mybatis Plus Sharding-JDBC
SpringBoot 集成 Sharding-JDBC 实现读写分离、分库分表、自定义复杂分片策略
kerwin的博客
08-07 1058
SpringBoot 集成 Sharding-JDBC 实现读写分离、分库分表、自定义复杂分片策略
SpringBoot2.0整合Sharding-Jdbc
art_code的博客
01-29 888
SpringBoot2.0整合Sharding-Jdbc maven: <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> &l...
springboot集成sharding-jdbc
m0_37999219的博客
07-13 1万+
3、水平分片：（1）数据库分片；yml文件会爆红，不影响项目启动。3、更新数据库内容自己测试。yml文件中采用的是。
SpringBoot整合Sharding-JDBC，实现从数据库读取sharding-jdbc数据源，实现多种数据库数据源切换，数据库方言动态切换
隔壁老王的专栏
03-21 1万+
SpringBoot整合Sharding-JDBC，实现从数据库读取sharding-jdbc数据源，实现多种数据库数据源切换，数据库方言动态切换 Hello，隔壁老王时隔很久很久又来了，今天给大家介绍的是一个分库分表的框架—sharding-jdbc。这个框架在我公司用到了，使用的还算比较复杂。这个项目有两种数据库，Mysql和SQLServer。因此需要动态的切换数据源，并且数据库方言也需要...
sharding jdbc入门-springboot整合sharding jdbc
ibigboy
04-12 999
创建springboot项目 项目目录结构： pom.xml文件 <dependencies> <dependency> <groupId>org.apache.shardingsphere</groupId> <artifactId>sharding-jdbc-spring-boot-starter</artifactId> <versio
Sharding-jdbc 集成springboot
m0_74779105的博客
03-06 599
【代码】Sharding-jdbc 集成springboot
Spring Boot与Sharding-JDBC+Mybatis-Plus整合实现分库分表
"本文主要讲解如何使用Spring Boot集成Sharding-JDBC和Mybatis-Plus来实现数据库的分库分表功能。文中通过实例代码详细展示了整个集成过程，并提供了项目的结构和POM配置信息。" 在分布式系统中，随着数据量的增长...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值