Sharding-JDBC——分库分表+读写分离

最新推荐文章于 2023-02-26 20:05:20 发布
最新推荐文章于 2023-02-26 20:05:20 发布
阅读量1.3k 收藏
点赞数
分类专栏： ShardingSphere 文章标签： mysql sharding jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tingxuejianghu/article/details/116142222
版权

一、简介

定位为轻量级Java框架，在Java的JDBC层提供的额外服务。 它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。

  • 适用于任何基于JDBC的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。
  • 支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP等。
  • 支持任意实现JDBC规范的数据库。目前支持MySQL，Oracle，SQLServer，PostgreSQL以及任何遵循SQL92标准的数据库。
    在这里插入图片描述
    ——摘自官方网站

二、数据分片——水平切分

1. 创建数据库和表
CREATE DATABASE `order-db1`;

CREATE TABLE `t_order_1` (
  `oid` bigint(20) NOT NULL COMMENT '订单id',
  `comment` varchar(100) CHARACTER  DEFAULT NULL COMMENT '订单备注',
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

CREATE TABLE `t_order_2` (
  `oid` bigint(20) NOT NULL COMMENT '订单id',
  `comment` varchar(100) CHARACTER DEFAULT NULL COMMENT '订单备注',
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户id'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

根据订单号的奇偶对数据进行分片。

2. java代码

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>sharding-jdbc-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>sharding-jdbc-demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--不能使用druid-spring-boot-starter-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.21</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

application.yml:

spring:
  shardingsphere:
    datasource:
      names: d0

      d0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/order-db1?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root


    sharding:
      tables:
        t_order:
          actualDataNodes: d0.t_order_$->{1..2}
          #如果添加订单的id是偶数把数据添加t_order_1，如果奇数添加到t_order_2
          tableStrategy:
            inline:
              shardingColumn: oid
              algorithmExpression: t_order_$->{oid % 2 + 1}
          keyGenerator:
            type: SNOWFLAKE
            column: oid
    props:
      sql.show: true

# 一个实体类对应两张表，覆盖
  main:
    allowBeanDefinitionOverriding: true

主启动类：

@SpringBootApplication
@MapperScan("com.example.shardingJdbcDemo.mapper")
public class ShardingJdbcDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShardingJdbcDemoApplication.class, args);
    }
}

实体类：

@Data
@TableName("t_order")
public class Order {
    private Long oid;
    private String comment;
    private Long userId;
}

注意：加上@TableName注解
Mapper接口：

@Repository
public interface OrderMapper extends BaseMapper<Order> {
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
class ShardingJdbcDemoApplicationTests {
    @Autowired
    private OrderMapper orderMapper;

    /**
     * 测试添加订单
     */
    @Test
    public void addOrder() {
        for (int i = 1; i <= 10; i++) {
            Order order = new Order();
            //使用雪花算法生产id
            //order.setOid((long) i);
            order.setComment("course" + i);
            order.setUserId((long) i);
            orderMapper.insert(order);
        }
    }

    /**
     * 测试查询订单
     */
    @Test
    public void getOrders() {
        List<Order> orders = orderMapper.selectList(null);
        System.out.println(orders.size());
    }
}

三、数据分片——垂直切分

1. 创建数据库和表
CREATE DATABASE `user-db`;

CREATE TABLE `user-db`.t_user (
	uid BIGINT NOT NULL COMMENT '用户id',
	uname varchar(100) NOT NULL COMMENT '用户姓名'
)
ENGINE=InnoDB
DEFAULT CHARSET=utf8mb4
COLLATE=utf8mb4_general_ci;

将用户表存放在order-db的t_user表中

2. java代码

application.yml

spring:
  shardingsphere:
    datasource:
      names: d0, d1

      d0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/order-db1?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root
      d1:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/user-db?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root

    sharding:
      tables:
        t_order:
          actualDataNodes: d$->{0}.t_order_$->{1..2}
          #如果添加课程id是偶数把数据添加course_1，如果奇数添加到course_2
          tableStrategy:
            inline:
              shardingColumn: oid
              algorithmExpression: t_order_$->{oid % 2 + 1}
          keyGenerator:
            type: SNOWFLAKE
            column: oid
        #配置user-db数据库里面t_user专库专表
        t_user:
          actualDataNodes: d$->{1}.t_user

    props:
      sql.show: true

  # 一个实体类对应两张表，覆盖
  main:
    allowBeanDefinitionOverriding: true

增加分库配置

User实体类：

package com.example.shardingJdbcDemo.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

/**
 * @author Castle
 * @Date 2021/4/26 8:49
 */
@Data
@TableName("t_user")
public class User {
    private Long uid;
    private String uname;
}

UserMapper:

@Repository
public interface UserMapper extends BaseMapper<User> {
}

测试类：

    /**
     * 测试添加用户
     */
    @Test
    public void addUser() {
        for (int i = 1; i <= 10; i++) {
            User user = new User();
            user.setUid((long) i);
            user.setUname("user" + i);
            userMapper.insert(user);
        }
    }

四、公共表

1. 建表

在order-db1和user-db中分别创建字典表:

CREATE TABLE t_dict (
	tid BIGINT NOT NULL COMMENT '字典id',
	tname varchar(100) NOT NULL COMMENT '字典名称',
	CONSTRAINT t_dict_pk PRIMARY KEY (tid)
)
ENGINE=InnoDB
DEFAULT CHARSET=utf8mb4
COLLATE=utf8mb4_general_ci;

字典表的数据将同时存储在2个数据库中

2.代码

修改application.yml:

spring:
  shardingsphere:
    datasource:
      names: d0, d1

      d0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/order-db1?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root
      d1:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/user-db?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root

    sharding:
      tables:
        t_order:
          actualDataNodes: d$->{0}.t_order_$->{1..2}
          #如果添加课程id是偶数把数据添加course_1，如果奇数添加到course_2
          tableStrategy:
            inline:
              shardingColumn: oid
              algorithmExpression: t_order_$->{oid % 2 + 1}
          keyGenerator:
            type: SNOWFLAKE
            column: oid
        #配置user-db数据库里面t_user专库专表
        t_user:
          actualDataNodes: d$->{1}.t_user
      #配置公共表
      broadcast-tables: t_dict

    props:
      sql.show: true

  # 一个实体类对应两张表，覆盖
  main:
    allowBeanDefinitionOverriding: true

实体类：

@Data
@TableName("t_dict")
public class Dict {
    private Long tid;
    private String tname;
}

mapper:

@Repository
public interface DictMapper extends BaseMapper<Dict> {
}

测试类：

    /**
     * 测试添加字典
     */
    @Test
    public void addDict() {
        for (int i = 1; i <= 10; i++) {
            Dict dict = new Dict();
            dict.setTid((long) i);
            dict.setTname("name" + i);
            dictMapper.insert(dict);
        }
    }

五、 读写分离

参考MySQL（10）——主从复制搭建主从数据库。

主库：192.168.30.132，从库：192.168.30.133
在test库中创建user表：

CREATE TABLE t_course (
	id BIGINT NOT NULL COMMENT '用户id',
	name varchar(100) NOT NULL COMMENT '用户姓名'
)

insert into t_course values (1,@@hostname);

修改application.yml:

spring:
  shardingsphere:
    datasource:
      names: d0, d1,m0,s0

      d0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/order-db1?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root
      d1:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://localhost:3306/user-db?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root

      m0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.30.132:3306/test?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root

      s0:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://192.168.30.133:3306/test?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8
        username: root
        password: root
    ##配置读写分离
    masterslave:
      name: ms
      master-data-source-name: m0
      slave-data-source-names: s0
    sharding:
      tables:
        t_order:
          actualDataNodes: d$->{0}.t_order_$->{1..2}
          #如果添加课程id是偶数把数据添加course_1，如果奇数添加到course_2
          tableStrategy:
            inline:
              shardingColumn: oid
              algorithmExpression: t_order_$->{oid % 2 + 1}
          keyGenerator:
            type: SNOWFLAKE
            column: oid
        #配置user-db数据库里面t_user专库专表
        t_user:
          actualDataNodes: d$->{1}.t_user
        #配置读写分离的t_course专库专表
        t_course:
          actualDataNodes: m$->{0}.t_course
      #配置公共表
      broadcast-tables: t_dict

    props:
      sql.show: true

  # 一个实体类对应两张表，覆盖
  main:
    allowBeanDefinitionOverriding: true

实体类：

@Data
@TableName("t_course")
public class Course {
    private Long id;
    private String name;
}

mapper:

@Repository
public interface CourseMapper extends BaseMapper<Course> {
}

测试类：

    /**
     * 测试添加课程
     */
    @Test
    public void addCourse() {
        for (int i = 5; i <= 10; i++) {
            Course course = new Course();
            course.setId((long) i);
            course.setName("name" + i);
            courseMapper.insert(course);
        }
    }

    /**
     * 测试获取课程
     */
    @Test
    public void getCourse() {
        QueryWrapper<Course> wrapper = new QueryWrapper<>();
        wrapper.eq("id", 1L);
        List<Course> courses = courseMapper.selectList(wrapper);
        System.out.println(courses.get(0));
    }

由于建表后的insert语句中的@@hostname,会被主从解析成不同的值。通过查询id为1的值，获取到来自从库的信息：

Course(id=1, name=server4)
tingxuejianghu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Sharding-JDBC-04-分库、分表、公共表、绑定表、读写分离
dark
06-09 1144
水平分表 水平分表是在同一个数据库内，把同一个表的数据按照一定的规则拆分到多个表中，在快速入门里，已经进行实现，这里不再赘述。 水平分表 水平分库是把同一个表的数据按一定规则拆到不同的数据库中，每个库可以放在不同的服务器 上。接下来看一下如何使用Sharding-JDBC实现水平分库，咱们继续对快速入门中的例子进行完善。 拆分数据库 将原有order_db库拆分为order_db_1、order_db_2 分片规则修改 由于数据库拆分了两个，这里需要配置两个数据源。 分库需要配置分库的策略，和分表策略的意
sharding-jdbc之——分库分表实例完整源码
02-25
标题"sharding-jdbc之——分库分表实例完整源码"指出了本主题的核心，即`Sharding-JDBC`在实现数据库分库分表中的应用。Sharding-JDBC是阿里巴巴开源的轻量级Java框架，它可以在不修改现有数据库的情况下，对数据库...
sharding-jdbc分库分表及读写分离
zhangbingfa90的博客
11-27 792
sharding-jdbc分库分表及读写分离 介绍 sharding-jdbc定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。 它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。 ●适用于任何基于 JDBC 的 ORM 框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template 或直接使用 JDBC。 ●支持任何第三方的数据库连接池，如
Sharding-JDBC实现分库分表和读写分离
周先生丶的博客
05-29 987
在遇到数据量大、性能瓶颈的时候，分库分表和读写分离能够很好解决此类问题。 分库分表包括分库和分表两个部分，在生产中通常包括：垂直分库、水平分库、垂直分表、水平分表四种方式。 ...
ShardingJDBC(读写分离、分库分表、分布式事务)
usernamehui的博客
01-11 3364
ShardingJDBC(读写分离、分库分表、分布式事务)
ShardingJdbc 分库分表 读写分离
kutianya518的博客
10-31 1439
1、核心概念 1.1逻辑表 水平拆分的数据库（表）的相同逻辑和数据结构表的总称，如温度数据表，根据上传的日期，一月可以分为31张表，temp_1.....temp_31，它们的逻辑表名就是temp。 配置文件对应信息：spring.shardingsphere.sharding.tables.temp 2、数据分片 2.1分片键 用于分片的数据库字段，是将数据库(表)水平拆分的关键字段。 例如：将温度表中上传时间temppoint,取yyyy-MM-dd中的天对表进...
Sharding-Jdbc实现读写分离、分库分表
hxt的博客
03-27 2404
1、概览 ShardingSphere-Jdbc定位为轻量级Java框架，在Java的Jdbc层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，可理解为增强版的Jdbc驱动，完全兼容Jdbc和各种ORM框架 2、MySQL主从复制 1）、docker配置mysql主从复制 1）创建主服务器所需目录 mkdir -p /usr/local/mysqlData/master/cnf mkdir -p /usr/local/mysqlData/master/data 2）定义主服务器配置文件
集成sharding-jdbc实现分库分表.zip
12-19
在这个"集成sharding-jdbc实现分库分表.zip"的压缩包中，我们可以深入学习如何将Sharding-JDBC应用于实际项目，以提升系统的性能和可扩展性。 1. **Sharding-JDBC简介** Sharding-JDBC是Java语言实现的，它工作在...
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
本篇文章将详细讲解如何使用Spring Boot结合Sharding-JDBC和Mybatis-Plus实现分库分表功能。 一、Sharding-JDBC简介 Sharding-JDBC是由Apache ShardingSphere项目提供的一个轻量级数据库中间件，它作为JDBC驱动...
基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置
10-26
1、基于yml 配置方式 ，实现springBoot+sharding-jdbc+mybatis-plus 实现分库分表，读写分离，以及全局表，子表的配置。 2、实现mybatis-plus 整合到springboot 详细使用请看 测试用例
shardingSpringbootDemo-master-分库分表+读写分离.zip
09-04
【标题】"shardingSpringbootDemo-master-分库分表+读写分离.zip" 提供的是一个基于Sharding-JDBC的Spring Boot应用示例，它实现了数据库的分库分表和读写分离功能。Sharding-JDBC是阿里巴巴开源的一个轻量级Java...
SpringBoot + Sharding JDBC，一文搞定分库分表、读写分离
m0_71777195的博客
10-06 4549
*** @date 2022年06月19日 10:45*/@Data}/*** @date 2022年06月19日 10:45*/}}}/*** @date 2022年06月19日 10:46*/@Mapper}
【SpringBoot框架篇】30.使用sharding-jdbc实现读写分离和分库分表
皓亮君的博客
09-07 1439
ShardingSphere-JDBC 提供了 4 种配置方式，用于不同的使用场景。 通过配置，应用开发者可以灵活的使用数据分片、读写分离、数据加密、影子库等功能，并且能够叠加使用。
SpringBoot+ShardingJDBC实现读写分离、分库分表
田维常
06-23 1259
简介Sharding-JDBC 最早是当当网内部使用的一款分库分表框架，到2017年的时候才开始对外开源，这几年在大量社区贡献者的不断迭代下，功能也逐渐完善，现已更名为 ShardingSphere，2020年4⽉16日正式成为 Apache 软件基金会的顶级项目。如果你正在准备面试，推荐给你一篇文章：★手把手教：如何准备面试！ShardingSphere-Jdbc定位为...
Spring Boot中整合Sharding-JDBC单库分表示例
老班长的博客
09-12 561
今天给大家演示的是单库中分表的操作，如果用XML方式配置，那么就是下面的配置： 我们将user表分成了4个，分别是user_0,user_1,user_2,user_3，通过id取模的方式决定数据落在哪张表上面。 如果用Spring Boot方式配置自然就简单多了，如下： sharding.jdbc.datasource...
【分库分表】ShardingSphere分库分表实战--inline策略
m0_45406092的博客
08-18 2585
参考 【分库分表】sharding-jdbc—分片策略 Sharding JDBC(四) 分片策略一：标准分片策略StandardShardingStrategy
ShardingSphere -04- ShardingSphere-Proxy(水平分表，水平分库)
迷雾总会解
07-21 504
ShardingSphere-Proxy 介绍  定位为透明化的数据库代理端，提供封装了数据库二进制协议的服务端版本，用于完成对异构语言的支持。 目前提供 MySQL 和 PostgreSQL 版本，它可以使用任何兼容 MySQL/PostgreSQL 协议的访问客户端(如：MySQL Command Client, MySQL Workbench, Navicat 等)操作数据，对 DBA 更加友好。 向应用程序完全透明，可直接当做 MySQL/PostgreSQL 使用。 适用于任何兼容 MySQL/
Sharding-Springboot-mybatis-plus整合（三）-inline策略
qq_42583549的博客
02-26 634
本节目标，使用SpringBoot整合Sharding和Mybatis-Plus验证上节分片策略从配置文件上看策略包括（ inline、standard、complex、hint）环境搭建以inline策略演示inline 策略inline策略是简单的表达式策略，不支持特殊范围查询。
使用sharding-jdbc分库分表
最新发布
07-28
Sharding-JDBC是一个开源的分库分表中间件，它提供了一种简单、高效、灵活的方式来实现数据库的分片和分表。 要使用Sharding-JDBC进行分库分表，你需要进行以下步骤： 1. 引入Sharding-JDBC的依赖：在你的项目中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值