分布式数据库中间件--＞ sharding-sphere3.x 从概念到代码实现详解

最新推荐文章于 2024-01-28 11:15:29 发布
最新推荐文章于 2024-01-28 11:15:29 发布
阅读量358 收藏
点赞数
分类专栏： java开发 文章标签： 数据库 分布式 mysql 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CUITAO2305532402/article/details/113751302
版权

本文重点讲解sharding-phere是什么？能做什么？怎么用三大经典问题。

目录

本文重点讲解sharding-phere是什么？能做什么？怎么用三大经典问题。

 1.Sharding-Sphere 是什么？

2.Sharding-Sphere家族都有谁?

2.1 Sharding-JDBC

2. 2 Sharding-Proxy 

2.3. Mixed scheme of Sharding-JDBC & Sharding-Proxy

2.4  Sharding-Sidecar

3.Sharding-Sphere 3.X新功能

 4.spingBoot 结合Sharding-Sphere 

 4.1 maven 依赖

 4.2 项目地址

 4.3 官网信息

5.Sharding-JDBC水平切分&&垂直切分&&公共表处理示例代码

 5.0 pom.xml配置

5.1 application.properties配置

5.2 实体类示例

5.3 mapper示例

 5.4 数据库sql

5.5 testDemo

6.Sharding-JDBC配置主从复制，实现读写分离

 6.1 创建主从数据库

 6.2 配置Mysql主从数据库

7.Sharding-Proxy安装使用

7.1 Sharding-proxy下载入口 

7.2 Sharding-proxy下载包

7.3 Sharding-proxy解压启动

7.3 Sharding-proxy配置

 1.Sharding-Sphere 是什么？

Sharding-Sphere是一套开源的 分布式 数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar这3款相互独立的产品组成。他们均提供标准化的数据分片、读写分离、柔性事务和数据治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。

Sharding-Sphere定位为关系型数据库中间件，旨在充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。它与NoSQL和NewSQL是并存而非互斥的关系。NoSQL和NewSQL作为新技术探索的前沿，是非常值得推荐的。而Sharding-Sphere关注未来不变的东西，进而抓住事物本质。关系型数据库当今依然占有巨大市场，是各个公司核心业务的基石，我们目前阶段更加关注在原有基础上的增量，而非颠覆。其架构如下图所示： 

                                                                        img

2.Sharding-Sphere家族都有谁?

Sharding-JDBC, Sharding-Proxy以及Sharding-Sidecar 共同组成了Sharding-Sphere。他们分别定位、适用于不同的应用场景。您也可以将他们组合使用以得到增益的性能表现。

2.1 Sharding-JDBC

Sharding-JDBC是Sharding-Sphere的第一个，也是Sharding-Sphere的前身。 它定位为轻量级Java框架，在Java的JDBC层提供分库分表、读写分离、数据库治理、柔性事务等服务。它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。

2. 2 Sharding-Proxy 

Sharding-Proxy是Sharding-Sphere的第二个产品。 它定位为透明化的数据库代理端，提供封装了数据库二进制协议的服务端版本，用于完成对异构语言的支持。 Sharding-Proxy屏蔽了底层的分库分表，您可以像使用一个简单的数据库一样来操作分库分表的数据。目前提供MySQL版本，它可以使用任何兼容MySQL协议的访问客户端(如：MySQL Command Client, MySQL Workbench等)来访问Sharding-Proxy，进而进行DDL/DML等操作来变更数据，对DBA更加友好。

2.3. Mixed scheme of Sharding-JDBC & Sharding-Proxy

为了得到更好的性能以及友好的交互体验，您可以同时使用Sharding-JDBC和Sharding-Proxy。

线上应用使用Sharding-JDBC直连数据库以获取最优性能，使用MySQL命令行或UI客户端连接Sharding-Proxy方便的查询数据和执行各种DDL语句。它们使用同一个注册中心集群，通过管理端配置注册中心中的数据，即可由注册中心自动将配置变更推送至JDBC和Proxy应用。若数据库拆分的过多而导致连接数会暴涨，则可以考虑直接在线上使用Sharding-Proxy，以达到有效控制连接数的目的。其架构如下如所示：   

                                                                                

2.4  Sharding-Sidecar

Sharding-Sidecar是Sharding-Sphere的第三个产品，目前仍处在孵化中。 定位为Kubernetes或Mesos的云原生数据库代理。其核心思想是Database Mesh，即通过无中心、零侵入的方案提供与数据库交互的啮合层。关注重点在于如何将分布式的数据访问应用与数据库有机串联起来。

2.4 Sharding-Sphere的功能特性

2.4 .1. 分库分表

为解决关系型数据库面对海量数据由于数据量过大而导致的性能问题，将数据进行分片是行之有效的解决方案，而将集中于单一节点的数据拆分并分别存储到多个数据库或表，称为分库分表。作为分布式数据库中间件，我们的目标是透明化分库分表所带来的影响，让使用方尽量像使用一个数据库一样使用水平拆分之后的数据库。

2.4 .2. 读写分离

面对日益增加的系统访问量，数据库的吞吐量面临着巨大瓶颈。 对于同一时间有大量并发读操作和较少写操作类型的应用系统来说，将单一的数据库拆分为主库和从库，主库负责处理事务性的增删改操作，从库负责处理查询操作，能够有效的避免由数据更新导致的行锁，使得整个系统的查询性能得到极大的改善。透明化读写分离所带来的影响，让使用方尽量像使用一个数据库一样使用 主从 数据库，是读写分离中间件的主要功能。

2.4 .3. 柔性事务

对于分布式的数据库来说，强一致性分布式事务在性能方面存在明显不足。追求最终一致性的柔性事务，在性能和一致性上则显得更加平衡。 Sharding-Sphere目前支持最大努力送达型柔性事务，未来也将支持TCC柔性事务。若不使用柔性事务，Sharding-Sphere也会自动包含弱XA事务支持。

2.4 .4. 数据治理

Sharding-Sphere提供注册中心、配置动态化、数据库熔断禁用、调用链路等治理能力。

3.Sharding-Sphere 3.X新功能

  1. Sharding-Proxy MySQL版本上线，支持DML/DDL/DAL/DQL等基本 SQL。屏蔽底层所有分库分表，可像使用单一MySQL数据库一样处理分库分表数据。
  2. 新增对OR SQL语句的支持，例如：select * from t_order where (id>10 and id<20) or status=‘init’;
  3. 新增对INSERT批量插入的支持，例如 insert into t_order(order_id, user_id, status) values (1, 2, ‘init’), (2, 3, ‘init’), (3, 4, ‘init’);
  4. 优化对INSERT SQL语句的支持，主要包括不指定具体列进行INSERT操作，例如：insert into t_order values(1, 2,‘init’);
  5. 增加解析引擎对SQL的缓存，进一步提升解析性能。
  6. Sharding-JDBC新增对InlineExpression占位符   $->{}   的支持。

 4.spingBoot 结合Sharding-Sphere 

 4.1 maven 依赖

<dependency>
    <groupId>org.apache.shardingsphere</groupId>
    <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
    <version>4.0.0-RC1</version>
</dependency>

 4.2 项目地址

https://github.com/sharding-sphere/sharding-sphere/

https://gitee.com/sharding-sphere/sharding-sphere/

 4.3 官网信息

5.Sharding-JDBC水平切分&&垂直切分&&公共表处理示例代码

 5.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 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.2.7.RELEASE</version>
        <relativePath/>
    </parent>
    <groupId>com.richardtown</groupId>
    <artifactId>sharding-phere-demo</artifactId>
    <version>2.2.1</version>
    <name>sharding-phere-demo</name>
    <description>Demo project for Spring Boot and sharding-phere</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.18</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </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>

5.1 application.properties配置

# 配置数据源，给数据源起名称,
# 水平分库，配置两个数据源
spring.shardingsphere.datasource.names=m1,m2,m0
#配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码
spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&allowMultiQueries=true&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.m1.username=root
spring.shardingsphere.datasource.m1.password=
#配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码
spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&allowMultiQueries=true&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.m2.username=root
spring.shardingsphere.datasource.m2.password=
#配置第三个数据源具体内容，包含连接池，驱动，地址，用户名和密码
spring.shardingsphere.datasource.m0.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.m0.url=jdbc:mysql://localhost:3306/user_db?useUnicode=true&characterEncoding=utf8&autoReconnect=true&useSSL=false&allowMultiQueries=true&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.m0.username=root
spring.shardingsphere.datasource.m0.password=
#==========================================公共表配置  【start】==========================
#表名
spring.shardingsphere.sharding.broadcast-tables=t_udict
#主键生产策略
spring.shardingsphere.sharding.tables.t_udict.key-generator.column=idctid
spring.shardingsphere.sharding.tables.t_udict.key-generator.type=SNOWFLAKE
#==========================================公共表配置  【end】============================
#==========================================垂直切分之转库专表  【start】===================
# 配置 user_db 数据库里面 t_user [目标：实现专库专表]
spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user
# 指定 t_user 表里面主键 user_id 生成策略 SNOWFLAKE
spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id
spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE
# 指定表分片策略 ，只要一张表，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
#==========================================垂直切分之转库专表  【end】===================

#==========================================水平切分之分库分表 【start】===================
#指定数据库分布情况 &&  数据库里面表分布情况
# m1 m2 student_1 student_2
spring.shardingsphere.sharding.tables.student.actual-data-nodes=m$->{1..2}.student_$->{1..2}
# 指定 student 表里面主键 cid 生成策略 SNOWFLAKE
spring.shardingsphere.sharding.tables.student.key-generator.column=cid
spring.shardingsphere.sharding.tables.student.key-generator.type=SNOWFLAKE
# 所有数据库[库中的表有user_id字段就按这个规则分库]分片策略 约定 user_id 是偶数添加 m1，是奇数添加 m2
#spring.shardingsphere.sharding.default-database-strategy.inline.sharding-column=user_id
#spring.shardingsphere.sharding.default-database-strategy.inline.algorithm- expression=m$->{user_id % 2 + 1}
# 指定的数据库[规则为student的数据库]分片策略 约定 user_id 是偶数添加 m1，是奇数添加 m2
spring.shardingsphere.sharding.tables.student.database-strategy.inline..sharding-column=user_id
spring.shardingsphere.sharding.tables.student.database-strategy.inline.algorithm-expression=m$->{user_id % 2 + 1}
# 指定表分片策略 约定 cid 值偶数添加到 student_1 表，如果 cid 是奇数添加到student_2 表
spring.shardingsphere.sharding.tables.student.table-strategy.inline.sharding-column=cid
spring.shardingsphere.sharding.tables.student.table-strategy.inline.algorithm-expression=student_$->{cid % 2 + 1}
#==========================================水平切分之分库分表 【end】===================
# 打开 sql 输出日志
spring.shardingsphere.props.sql.show=true
# 一个实体类对应两张表，覆盖
spring.main.allow-bean-definition-overriding=true

5.2 实体类示例

@Data
@TableName(value = "t_udict")
public class Udict {
    private Long idctid;
    private Long ustatus;
    private String uvalue;
}

5.3 mapper示例


import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.richardtown.shardingpheredemo.entity.Course;
import org.springframework.stereotype.Repository;

/**
 * @author 
 * @ className:
 * @ description:
 * @ create 2021-02-08 14:42
 **/
@Repository
public interface CourseMapper extends BaseMapper<Course> {
}

 5.4 数据库sql



SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for student_1
-- ----------------------------
DROP TABLE IF EXISTS `student_1`;
CREATE TABLE `student_1`  (
  `cid` bigint NOT NULL,
  `cname` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `user_id` bigint NOT NULL,
  `cstatus` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`cid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of student_1
-- ----------------------------

-- ----------------------------
-- Table structure for student_2
-- ----------------------------
DROP TABLE IF EXISTS `student_2`;
CREATE TABLE `student_2`  (
  `cid` bigint NOT NULL,
  `cname` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `user_id` bigint NOT NULL,
  `cstatus` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`cid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of student_2
-- ----------------------------
INSERT INTO `student_2` VALUES (565837698279931905, 'javademo', 100, 'Normal1');
INSERT INTO `student_2` VALUES (565838364469624833, 'javademo', 100, 'Normal1');
INSERT INTO `student_2` VALUES (565838574272905217, 'javademo', 100, 'Normal1');

-- ----------------------------
-- Table structure for t_udict
-- ----------------------------
DROP TABLE IF EXISTS `t_udict`;
CREATE TABLE `t_udict`  (
  `idctid` bigint NOT NULL,
  `ustatus` bigint NOT NULL,
  `uvalue` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`idctid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_udict
-- ----------------------------
INSERT INTO `t_udict` VALUES (565884634462683137, 1, '启用');

SET FOREIGN_KEY_CHECKS = 1;




SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_udict
-- ----------------------------
DROP TABLE IF EXISTS `t_udict`;
CREATE TABLE `t_udict`  (
  `idctid` bigint NOT NULL,
  `ustatus` bigint NOT NULL,
  `uvalue` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`idctid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_udict
-- ----------------------------
INSERT INTO `t_udict` VALUES (565884634462683137, 1, '启用');

-- ----------------------------
-- Table structure for t_user
-- ----------------------------
DROP TABLE IF EXISTS `t_user`;
CREATE TABLE `t_user`  (
  `user_id` bigint NOT NULL,
  `user_name` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `user_status` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`user_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_user
-- ----------------------------
INSERT INTO `t_user` VALUES (565849633989853185, '小红', 'status1');

SET FOREIGN_KEY_CHECKS = 1;



SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for course_1
-- ----------------------------
DROP TABLE IF EXISTS `course_1`;
CREATE TABLE `course_1`  (
  `cid` bigint NOT NULL,
  `cname` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `user_id` bigint NOT NULL,
  `cstatus` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`cid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of course_1
-- ----------------------------
INSERT INTO `course_1` VALUES (565566794123706368, 'java2', 100, 'Normal2');
INSERT INTO `course_1` VALUES (565566794169843712, 'java4', 100, 'Normal4');
INSERT INTO `course_1` VALUES (565566794215981056, 'java6', 100, 'Normal6');
INSERT INTO `course_1` VALUES (565566794257924096, 'java8', 100, 'Normal8');
INSERT INTO `course_1` VALUES (565566794291478528, 'java10', 100, 'Normal10');

-- ----------------------------
-- Table structure for course_2
-- ----------------------------
DROP TABLE IF EXISTS `course_2`;
CREATE TABLE `course_2`  (
  `cid` bigint NOT NULL,
  `cname` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  `user_id` bigint NOT NULL,
  `cstatus` varchar(10) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
  PRIMARY KEY (`cid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of course_2
-- ----------------------------
INSERT INTO `course_2` VALUES (565566793683304449, 'java1', 100, 'Normal1');
INSERT INTO `course_2` VALUES (565566794148872193, 'java3', 100, 'Normal3');
INSERT INTO `course_2` VALUES (565566794195009537, 'java5', 100, 'Normal5');
INSERT INTO `course_2` VALUES (565566794236952577, 'java7', 100, 'Normal7');
INSERT INTO `course_2` VALUES (565566794274701313, 'java9', 100, 'Normal9');

SET FOREIGN_KEY_CHECKS = 1;

5.5 testDemo

5.5 .1. 水平分库分表


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.richardtown.shardingpheredemo.entity.Student;
import com.richardtown.shardingpheredemo.mapper.StudentMapper;
import lombok.extern.slf4j.Slf4j;
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;

/**
 * @author 
 * @ className:
 * @ description:
 * @ create 2021-02-08 17:18
 **/
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class ShardingJdbcSeprateDBAndTable {
    @Autowired
    private StudentMapper studentMapper;

    //添加操作
    @Test
    public void addStudent() {

        Student student = new Student();
        student.setCname("javademo");
        //分库根据 user_id
        student.setUserId(111L);
        student.setCstatus("Normal2");
        studentMapper.insert(student);

    }

    //查询操作
    @Test
    public void quereyStudent() {
        QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id", 111L);
        queryWrapper.eq("cid", 565838868767571969L);
        Student student = studentMapper.selectOne(queryWrapper);
        log.info("student",student);
    }
}

5.5 .2. 垂直分库分表

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.richardtown.shardingpheredemo.entity.User;
import com.richardtown.shardingpheredemo.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
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;

/**
 * @author 
 * @ className:
 * @ description:
 * @ create 2021-02-09 10:37
 **/
@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class VerticalDBTest {
    @Autowired
    UserMapper userMapper;

    @Test
    /**
     * 添加
     */
    public void addUser(){
        User user = new User();
        user.setUserName("小红");
        user.setUserStatus("status1");
        userMapper.insert(user);
    }

    /**
     * 查询
     */
    @Test
    public void findUser(){
        QueryWrapper<User>queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_id",565849633989853185L);
        User user= userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }
}

5.5 .3. 公共表处理

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.richardtown.shardingpheredemo.entity.Udict;
import com.richardtown.shardingpheredemo.mapper.PublicTableMapper;
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;

/**
 * @author 
 * @ className:
 * @ description:
 * @ create 2021-02-09 11:16
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class PublicTable {
    //操作公共表时，一顿增加，会广播到所有库中的公共表都添加，
    //       一顿删除，会广播到所有的库中的公共表都删除
    //       一顿更新，会广播到所有的库中的公共表都更新
    @Autowired
    private PublicTableMapper publicTableMapper;

    /**
     * 新增
     */
    @Test
    public void addPubicTableData() {
        Udict udict = new Udict();
        udict.setUstatus(1L);
        udict.setUvalue("启用");
        publicTableMapper.insert(udict);
    }

    /**
     * 更新
     */
    @Test
    public void updatePublicTableData() {
        //将所有 ustatus 为 1 的，userValue 改为 “禁用”
        Udict udict = new Udict();
        udict.setUvalue("禁用");
        QueryWrapper<Udict> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("ustatus", 1L);
        publicTableMapper.update(udict, queryWrapper);
    }

    /**
     * 删除
     */
    @Test
    public void delPublicTableData(){
        QueryWrapper<Udict>queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("ustatus",1L);
        publicTableMapper.delete(queryWrapper);
    }

    /**
     * 查询时，会随机的到对应一个库中国的公共表  t_udict 中去查
     */
    @Test
    public void finadPublicTableData(){

        for (int i = 0; i < 10; i++) {
            QueryWrapper<Udict>queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("idctid",565884634462683137L);
            Udict udict = publicTableMapper.selectOne(queryWrapper);
            System.out.println(udict);
        }

    }
}

6.Sharding-JDBC配置主从复制，实现读写分离

 6.1 创建主从数据库

1.复制N份之间的数据库，如一主一从

                                                                               

2.修改从机的配置文件(没有my.ini 的解决方案 ,主从机都要配置my.ini)

                                                                          

3.修改端口号，安装目录，数据存储目录

                                                                   

4.删除并重新生产data文件

删除之前生成的data文件，如果有重要的数据表，请先备份好。

mysqld --initialize-insecure --user=mysql

5.安装从机并绑定my.ini



mysqld --install "MySql80" --defaults-file="D:\developmentEnvironment\mysql-8.0.22-winx64\mysql-8.0.22-winx64 -slaver\my.ini"

6.启动从机

                                                          

命令启动：  net start mysql80

 6.2 配置Mysql主从数据库

6.2 .1. my.ini配置

#主机配置
[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8
[mysqld]
#设置3306端口
port = 3306
basedir = D:\developmentEnvironment\mysql-8.0.22-winx64\mysql-8.0.22-winx64
datadir = D:\developmentEnvironment\mysql-8.0.22-winx64\mysql-8.0.22-winx64\data
# 允许最大连接数
max_connections=200
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
#=========主从复制关键配置【start】=====================
server_id=1 #主库和从库需要不一致,配一个唯一的ID编号，1至32。 手动设定
log-bin=mysql-bin #二进制文件存放路径,存放在根目录data
binlog-do-db=user_db #需要复制的库,多个库用逗号隔开,如果此项不配置所有主库都参与复制
binlog-ignore-db=mysql #不需要复制的库，和上项同理

#=========主从复制关键配置[end]=====================


#从机配置


[mysql]
# 设置mysql客户端默认字符集
default-character-set=utf8
[mysqld]
#设置3306端口
port = 3307
basedir = D:\developmentEnvironment\mysql-8.0.22-winx64\mysql-8.0.22-winx64 -slaver
datadir = D:\developmentEnvironment\mysql-8.0.22-winx64\mysql-8.0.22-winx64 -slaver\data
# 允许最大连接数
max_connections=200
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB
#========主从复制关键配置[start]======================
server_id=2 #主库和从库需要不一致,配一个唯一的ID编号，1至32。 手动设定
binlog-do-db=user_db.% #需要复制的库,多个库用逗号隔开,如果此项不配置所有主库都参与复制
binlog-ignore-db=Mysql.% #不需要复制的库，和上项同理
#========主从复制关键配置[end]======================

6.2 .2. 主机上创建用于主从复制的账户

 CREATE USER 'db_sync'@'localhost' IDENTIFIED BY 'db_sync';

GRANT REPLICATION SLAVE ON *.* TO 'db_sync'@'localhost';

flush privileges;

 show master status;

     确认位点 记录下文件名以及位点  

 

6.2 .2. 从机上做主从复制同步设置

#切换至从库bin目录，登录从库
mysql ‐h localhost ‐P3307 ‐uroot ‐p
#先停止同步
STOP SLAVE;
CHANGE MASTER TO
master_host = 'localhost',
master_user = 'db_sync',
master_password = 'db_sync',
master_log_file = 'mysql-bin.000012',
master_log_pos = 1919;
#启动同步
START SLAVE;

6.2 .3 查看slave 状态

show slave status\G;

                                                                                                          

# 查看 Slave_IO_Runing 和 Slave_SQL_Runing 字段值都为 Yes ，表示同步配置成功。如果不为 Yes ，请排
查相关异常。

7.Sharding-Proxy安装使用

7.1 Sharding-proxy下载入口 

7.2 Sharding-proxy下载包

 

7.3 Sharding-proxy解压启动

7.3 Sharding-proxy配置

7.3.1 修改server.yaml文件 【打开注释】

7.3.2 修改config-sharding.yaml文件 【配置分库分表相关内容】

 
配置分库分表的规则demo

# 要配置的数据库名称，和server.yaml保持一致
schemaName: sharding_db

dataSourceCommon:
 username: root
 password: root
 connectionTimeoutMilliseconds: 30000
 idleTimeoutMilliseconds: 60000
 maxLifetimeMilliseconds: 1800000
 maxPoolSize: 50
 minPoolSize: 1
 maintenanceIntervalMilliseconds: 30000

dataSources:
  # 配置要连接的多个数据源
 ds_0:
   url: jdbc:mysql://127.0.0.1:3306/edu_1?serverTimezone=UTC&useSSL=false
 # ds_1:
 #   url: jdbc:postgresql://127.0.0.1:5432/demo_ds_1?serverTimezone=UTC&useSSL=false
# 配置sharding JDBC规则
rules:
- !SHARDING
 tables:
  #要配置的表
   t_order:
     actualDataNodes: ds_${0}.t_order_${0..1}
     # actualDataNodes: ds_${0..1}.t_order_${0..1}
     tableStrategy:
       standard:
        # 根据order_id 字段进行表分片
         shardingColumn: order_id
         shardingAlgorithmName: t_order_inline
    # 主键生成策略
     keyGenerateStrategy:
       column: order_id
       keyGeneratorName: snowflake
  # 其他表如：t_order_item 也是做类似的配置
   # t_order_item:
   #   actualDataNodes: ds_${0}.t_order_item_${0..1}
   #   tableStrategy:
   #     standard:
   #       shardingColumn: order_id
   #       shardingAlgorithmName: t_order_item_inline
   #   keyGenerateStrategy:
   #     column: order_item_id
   #     keyGeneratorName: snowflake
 bindingTables:
  # 绑定的表，多个表用,隔开
   - t_order
   # - t_order,t_order_item
 defaultDatabaseStrategy:
   standard:
     shardingColumn: user_id
     shardingAlgorithmName: database_inline
 defaultTableStrategy:
   none:
 
 shardingAlgorithms:
   database_inline:
     type: INLINE
     props:
       algorithm-expression: ds_${0}
   t_order_inline:
     type: INLINE
     props:
       algorithm-expression: t_order_${order_id % 2}
   # t_order_item_inline:
   #   type: INLINE
   #   props:
   #     algorithm-expression: t_order_item_${order_id % 2}
 
 keyGenerators:
   snowflake:
     type: SNOWFLAKE
     props:
       worker-id: 123

 

做个专注的工程师
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ShardingSphere-ShardingSphere基本介绍及核心概念
qq_39093474的博客
03-31 1881
分布式数据库中间件（Distributed Database Middleware，检测DDM），是一款分布式关系型数据库，采用先进的存储计算分离架构，实现并发，计算，数据存储三个方面均可线性扩展，专注于解决数据库分布式扩展问题，突破了传统数据库的容量和性能瓶颈，实现海量数据高并发访问，其核心的优势是提供数据库水平扩展能力。
面试三连问：你这个数据量多大？分库分表怎么做？用的哪个组件？
码猿技术专栏
12-11 1931
点击上方蓝色“码猿技术专栏”，选择“设为星标”来源：cnblogs.com/cjsblog/p/13154158.html1. 概述1.1. ShardingSphere-JDBC1....
分布式数据库中间件Mycat介绍
牧羊人的方向
12-19 1603
从Cobar到Mycat，从闭源到开源，作为一个开源的分布式数据库中间件，Mycat已经被众多开源项目使用。本文简要介绍下Mycat的特性、基本架构以及分库分表和读写分离的配置。
分布式数据库中间件介绍
JolyouLu的博客
08-30 1733
分布式数据库中间件 在分布式情况下随着用户量的增加，Mysql数据库表逐渐庞大随之而来的问题就是导致数据库性能的下降，当数据量超过500W行那么就可以考虑分库分表了 分库分表概述 什么是分库分表 分库分表，相信大家在编写Web项目的时都会使用到关系型数据库，通常在传统的Web项目中我们一个项目只会对应一个数据库，当对于类似电商这些用户量与数据量大的项目通常使用单个数据库是无法支撑的，所以就有了分库分表，即把项目中的表按不同的业务分别存放到不同的数据库中、或把一张表数据拆分到不同的数据库中 为什么要分
ShardingSphere简介与分表使用
Charge8的博客
04-16 3348
一、ShardingSphere简介 1、简介 ShardingSphere 已于 2020 年 4 月 16 日成为 Apache 软件基金会的顶级项目。 ShardingSphere 是一套开源的分布式数据库中间件解决方案。 ShardingSphere 产品定位为 Database Plus，旨在构建异构数据库上层的标准和生态圈。 它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。 ShardingSphere 站在数据库的上层视角，关注他们之间的协作多于数据库自身。 它由S
ShardingSphere学习（超详细）
hyzsuccess的博客
11-02 2705
Apache ShardingSphere是一款开源的分布式数据库中间件组成的生态圈。它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（规划中）这3款相互独立的产品组成。 他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于如Java同构、异构语言、容器、云原生等各种多样化的应用场景。
分布式数据库中间件-Python开发
05-25
Sharding-Sphere-分布式数据库中间件Ecosphere文档概述Sharding-Sphere是一个开源的分布式数据库中间件解决方案套件，由Sharding-JDBC，Sharding-Sphere-分布式数据库中间件Ecosphere文档概述Sharding-Sphere是一个...
Sharding-Sphere是一套开源的分布式数据库中间件解决方案组成的生态圈-python
06-18
Sharding-Sphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar这3款相互独立的产品组成。他们均提供标准化的数据分片、读写分离、柔性事务和数据治理...
Sharding-JDBC是一个开源的分布式数据库中间件解决方案
08-06
Sharding-JDBC是一个开源的分布式数据库中间件解决方案。它在Java的JDBC层以对业务应用零侵入的方式额外提供数据分片，读写分离，柔性事务和分布式治理能力。
分布式数据库-MySQL Sharding1
08-08
分布式数据库-MySQL Sharding1 分布式数据库-MySQL Sharding1 是一种将单个数据库拆分成多个数据库节点的技术，目的是为了解决单个数据库的性能瓶颈和存储空间限制。这种技术可以将数据分布到多个数据库节点上，以...
ShardingSphere新一代读写分离、分库分表神器
zfxgf123456789的博客
08-09 555
ShardingSphere是京东开源目前交给Apache的一个专门解决分库分表和读写分离等问题的框架，它是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。它站在数据库的上层视角，关注它们之间的协作多于数据库自身。
ShardingSphere原理分析和实战总结
击水三千里的专栏
07-28 4563
代码模块 架构原理 官方文档：https://shardingsphere.apache.org/document/current/cn/quick-start/sharding-jdbc-quick-start/ 分片策略 Sharding-JDBC认为对于分片策略存有两种维度： 数据源分片策略（DatabaseShardingStrategy）：数据被分配的目标数据...
介绍完整的分布式中间件有哪些，各自的应用场景和作用。
NZC2237的博客
12-19 1965
分布式中间件是在分布式系统中用于解决通信、数据传输、负载均衡、数据存储和处理等问题的软件组件。
Sharding Sphere基本概念理解
weixin_40663800的博客
01-12 8680
什么是 Sharding Sphere Apache ShardingSphere(Incubator) 是一套开源的分布式数据库中间件解决方案组成的生态圈。 组成： 1.Sharding-JDBC 2.Sharding-Proxy 3.Sharding-Sidecar 功能：提供标准化的数据分片、分布式事务和数据库治理功能 目的：充分合理地在分布式的场景下利用关系型数据库的计算和存储能力，而并非实现一个全新的关系型数据库。它通过关注不变，进而抓住事物本质...
盘点分布式数据计算框架和相关中间件
最新发布
xxx
01-28 898
Avro 不仅提供数据序列化，还允许定义数据的架构（Schema），使得数据能够被动态检测和理解。
SQL题 （困难）
qq1226546902的博客
03-03 444
SQL练习
分布式数据库中间件对比总结 数据库（分库分表）中间件对比
热门推荐
许恒的博客
07-15 1万+
分布式数据库中间件对比总结2016年08月28日 11:19:22阅读数：11082摘要：目前数据库中间件有很多，基本这些中间件在下都有了解和使用，各种中间件优缺点及使用场景也都有些心的。所以总结一个关于中间件比较的系列，希望可以对大家有帮助。 分布式数据库中间件对比总结(1)目前数据库中间件有很多，基本这些中间件在下都有了解和使用，各种中间件优缺点及使用场景也都有些心的。所以总结一个关于中间件比...
数据库：分库分表中间件
初心不改
07-06 3442
对于海量数据，且有一定的并发量的分库分表，绝不是引入某一个分库分表中间件就能解决问题，而是一项系统的工程。需要分析整个表相关的业务，让合适的中间件做它最擅长的事情。例如有sharding column的查询走分库分表，一些模糊查询，或者多个不固定条件筛选则走es，海量存储则交给HBase。做了这么多事情后，后面还会有很多的工作要做，比如数据同步的一致性问题，还有运行一段时间后，某些表的数据量慢慢达到单表瓶颈，这时候还需要做冷数据迁移。
阿里云 专有云企业版 V3.6.0 分布式关系型数据库服务DRDS 用户指南 - 20180824.pdf
05-27
1. **分布式数据库概念**： DRDS是一种基于分布式架构的数据库服务，它将传统的关系型数据库拆分为多个小的数据节点，每个节点负责一部分数据的存储和处理。这种设计使得数据库能够横向扩展，处理能力随着节点数量...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值