数据库分库分表-ShardingSphere学习

最新推荐文章于 2024-08-29 17:00:41 发布

学Java的skyyyyyyyy

最新推荐文章于 2024-08-29 17:00:41 发布

阅读量804

点赞数 15

文章标签：数据库 java

本文链接：https://blog.csdn.net/weixin_61669379/article/details/141648151

版权

ShardingSphere是一个开源的分布式数据库中间件解决方案，旨在提供数据库分片、分布式事务、读写分离、数据治理等多种数据服务，它以模块化的方式设计，使用户可以根据不同的应用场景选择适合的模块来部署。

ShardingSphere架构概述

ShardingSphere的架构主要围绕四个核心组件展开，分别是Sharding-JDBC、Sharding-Proxy、Sharding-Sidecar（计划中）和Sharding-Scheduler（计划中）。这些组件可以独立部署，也可以组合使用，形成一个完整的分布式数据库解决方案。ShardingSphere通过提供统一的API和配置方式，使得这些组件可以在不同的场景下无缝协作。

1.Sharding-JDBC

Sharding-JDBC是ShardingSphere的一个轻量级Java数据库访问层，它类似于JDBC驱动，嵌入到应用程序中，通过拓展原生的JDBC API，实现对分库分表、读写分离、分布式事务等功能的支持。
核心功能：
分库分表： 根据配置的分片规则，将数据自动分片到多个数据库实例或表中。支持多种分片算法，如范围分片、哈希分片、自定义分片等。
读写分离： 将读操作路由到从库，写操作路由到主库，从而实现数据库的负载均衡。
分布式事务： 通过支持XA事务、BASE事务等方式，确保跨数据库的事务一致性。
数据脱敏： 在数据操作中支持脱敏处理，以保护敏感数据。
场景应用：
适用于需要分库分表但不想改变现有数据库访问层代码的Java应用程序。
在单体应用、微服务架构中都可以使用。

2.Sharding-Proxy

Sharding-Proxy是ShardingSphere的一个独立的代理层，它类似于MySQL Proxy或PgBouncer，可以作为一个独立的服务部署。客户端直接连接到Sharding-Proxy，而不是直接连接数据库。Sharding-Proxy会根据配置规则对SQL进行解析、重写、路由，并将结果返回给客户端。
核心功能：
数据库代理： 代理SQL请求，将其路由到正确的数据库实例和表中。
协议支持： 目前支持MySQL、PostgreSQL协议，可以支持多种数据库。
透明访问： 对客户端透明，不需要修改应用程序代码，只需要配置数据库连接信息即可使用。
多语言支持： 由于是独立服务，可以支持Java、Python、PHP等多种语言的应用程序。
场景应用：
适用于多语言环境下的分布式数据库场景，尤其是在不方便修改应用程序代码的情况下。
可以在现有系统中无缝引入分库分表和读写分离功能。

3. Sharding-Sidecar（计划中）

Sharding-Sidecar（也称为Sharding-Mesh）是ShardingSphere计划中的一个组件，它将与容器化和微服务架构紧密集成。Sharding-Sidecar的设计思路是为每个服务实例提供一个独立的数据库代理，类似于Service Mesh中的数据面。
核心功能：
服务网格集成： 与Service Mesh集成，支持微服务架构下的数据库治理。
去中心化： 每个服务实例拥有独立的代理层，消除单点故障问题。
动态路由： 支持根据流量、服务状态动态调整数据库访问策略。
场景应用：
适用于容器化、微服务架构中，需要对数据库进行更加精细的治理。
能够充分利用Kubernetes等容器编排平台的优势。

4. Sharding-Scheduler（计划中）

Sharding-Scheduler是ShardingSphere未来计划中的一个分布式任务调度组件，旨在解决分布式环境下的数据调度和任务管理问题。
核心功能：
分布式任务调度： 支持在分布式系统中进行任务的统一调度和管理。
数据迁移与治理： 通过调度任务，实现数据的迁移、清理等治理功能。
自动扩展： 根据数据量和请求量自动扩展或收缩数据库实例。
场景应用：
适用于大规模分布式系统中的数据调度与管理需求。
可以帮助实现数据的自动化运维与优化。

详解Sharding-JDBC

Sharding-JDBC 是 ShardingSphere 的核心组件之一，通过提供分库分表和读写分离等功能，帮助解决数据库在大规模数据处理中的性能问题。

1.数据源配置

数据源配置 是 Sharding-JDBC 配置的基础，涉及到连接多个数据库实例以实现分库分表。
示例：假设你有两个数据库实例 db1 和 db2，每个数据库都有一个表 user。
配置文件配置（application.yml）

spring:
  datasource:
    sharding:
      name: ds0
      datasource:
        ds0:
          url: jdbc:mysql://localhost:3306/db1
          username: root
          password: password
        ds1:
          url: jdbc:mysql://localhost:3306/db2
          username: root
          password: password

Java代码配置

import org.apache.shardingsphere.api.config.RuleConfiguration;
import org.apache.shardingsphere.api.config.datasource.DataSourceParameter;
import org.apache.shardingsphere.api.config.datasource.DataSourceConfiguration;
import org.apache.shardingsphere.api.config.rule.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;

import javax.sql.DataSource;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

public class DataSourceConfig {
    public DataSource createDataSource() throws SQLException {
        // Define data sources
        Map<String, DataSource> dataSourceMap = new HashMap<>();
        dataSourceMap.put("ds0", createDataSource("jdbc:mysql://localhost:3306/db1", "root", "password"));
        dataSourceMap.put("ds1", createDataSource("jdbc:mysql://localhost:3306/db2", "root", "password"));

        // Define sharding rule
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        // Add sharding rules here

        // Create data source
        return ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, new Properties());
    }

    private DataSource createDataSource(String url, String username, String password) {
        // Create and return a data source
    }
}

2.分片规则配置

分片规则配置 用于定义数据如何在多个数据库和表中分片。主要包括分片字段和分片算法。
分片字段： 指定哪个字段作为分片键，如 user_id。
分片算法： 定义数据如何根据分片字段分配到不同的分片中。常见的分片算法有：
Hash算法： 将分片字段的值进行哈希运算，然后根据哈希值决定分片。
Range算法： 根据分片字段的值范围进行分片。
示例：假设我们要按 user_id 对用户表进行水平分片。
配置文件配置（sharding-config.yml）

sharding:
  tables:
    user:
      actualDataNodes: ds0.user_${0..1},ds1.user_${0..1}
      tableStrategy:
        inline:
          shardingColumn: user_id
          algorithmExpression: user_${user_id % 2}
      keyGenerator:
        column: user_id
        type: SNOWFLAKE
  defaultDatabaseStrategy:
    inline:
      shardingColumn: user_id
      algorithmExpression: ds${user_id % 2}

Java代码配置

import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;

public class ShardingConfig {
    public ShardingRuleConfiguration createShardingRuleConfig() {
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        
        // Configure table sharding
        TableRuleConfiguration userTableRule = new TableRuleConfiguration("user", "ds${0..1}.user_${0..1}");
        userTableRule.setTableShardingStrategy(new InlineShardingStrategyConfiguration("user_id", "user_${user_id % 2}"));
        shardingRuleConfig.getTableRules().add(userTableRule);

        return shardingRuleConfig;
    }
}

3.分表策略

分表策略 是在单个数据库中将表拆分成多个子表的策略。
水平分片： 将表按行拆分成多个子表。
垂直分片： 将表按列拆分成多个子表。
示例：假设 user 表按用户 ID 进行水平分片。
水平分片配置（在 sharding-config.yml 中）：

sharding:
  tables:
    user:
      actualDataNodes: ds0.user_${0..1},ds1.user_${0..1}
      tableStrategy:
        inline:
          shardingColumn: user_id
          algorithmExpression: user_${user_id % 2}

分库分表的代码实现

简单示例：编写Java代码实现分库分表和配置
Java代码配置

import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ShardingDemo {
    public static void main(String[] args) throws SQLException {
        // Configure data sources
        Map<String, DataSource> dataSourceMap = new HashMap<>();
        dataSourceMap.put("ds0", createDataSource("jdbc:mysql://localhost:3306/db1", "root", "password"));
        dataSourceMap.put("ds1", createDataSource("jdbc:mysql://localhost:3306/db2", "root", "password"));
        
        // Configure sharding rules
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        TableRuleConfiguration userTableRule = new TableRuleConfiguration("user", "ds${0..1}.user_${0..1}");
        userTableRule.setTableShardingStrategy(new InlineShardingStrategyConfiguration("user_id", "user_${user_id % 2}"));
        shardingRuleConfig.getTableRules().add(userTableRule);

        // Create Sharding DataSource
        DataSource dataSource = ShardingDataSourceFactory.createDataSource(dataSourceMap, shardingRuleConfig, new Properties());

        // Test CRUD operations
        try (Connection connection = dataSource.getConnection(); 
             Statement statement = connection.createStatement()) {
            statement.execute("INSERT INTO user (user_id, name) VALUES (1, 'John')");
            statement.execute("SELECT * FROM user WHERE user_id = 1");
        }
    }
    
    private static DataSource createDataSource(String url, String username, String password) {
        // Create and return a data source
    }
}

5. 读写分离

主从数据库配置：
主库：用于写操作。
从库：用于读操作。
示例：
配置文件配置（application.yml）：

spring:
  datasource:
    sharding:
      name: ds0
      datasource:
        ds0:
          url: jdbc:mysql://localhost:3306/db1
          username: root
          password: password
        ds1:
          url: jdbc:mysql://localhost:3306/db2
          username: root
          password: password
      masterSlave:
        name: masterSlave
        masterDataSourceName: ds0
        slaveDataSourceNames:
          - ds1

读写分离的实现：
负载均衡策略： 在从库之间进行负载均衡，以分担读请求
示例：
配置文件配置（sharding-config.yml）：

sharding:
  defaultDatabaseStrategy:
    none: {}
  defaultTableStrategy:
    none: {}
  masterSlave:
    rules:
      - name: master_slave
        masterDataSourceName: ds0
        slaveDataSourceNames:
          - ds1

Java代码实现

import org.apache.shardingsphere.api.config.masterslave.MasterSlaveRuleConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;

public class ReadWriteSeparationDemo {
    public static void main(String[] args) throws SQLException {
        // Configure data sources
        Map<String, DataSource> dataSourceMap = new HashMap<>();
        dataSourceMap.put("ds0", createDataSource("jdbc:mysql://localhost:3306/db1", "root", "password"));
        dataSourceMap.put("ds1", createDataSource("jdbc:mysql://localhost:3306/db2", "root", "password"));
        
        // Configure master-slave rules
        MasterSlaveRuleConfiguration masterSlaveRuleConfig = new MasterSlaveRuleConfiguration("master_slave", "ds0", Arrays.asList("ds1"));

        // Create Sharding DataSource
        DataSource dataSource = ShardingDataSourceFactory.createDataSource(dataSourceMap, masterSlaveRuleConfig, new Properties());

        // Test read/write separation
        try (Connection connection = dataSource.getConnection(); 
             Statement statement = connection.createStatement()) {
            // Perform write operation (write to master)
            statement.execute("INSERT INTO user (user_id, name) VALUES (2, 'Jane')");

            // Perform read operation (read from slave)
            statement.executeQuery("SELECT * FROM user WHERE user_id = 2");
        }
    }
}

1. 分库分表

什么是分库分表？
分库分表是将数据拆分到多个数据库实例（分库）和/或多个数据表（分表）中存储的一种策略，用于解决单个数据库在处理海量数据时面临的性能瓶颈问题。
分库： 将数据拆分到多个独立的数据库实例中。每个数据库实例可能运行在不同的服务器上，从而分散数据库负载，减轻单个数据库的压力。
分表： 在同一个数据库实例中，将大表按照某种规则拆分成多个小表。每个小表只存储一部分数据，避免单表数据量过大导致的查询和维护困难。
为什么需要分库分表？
性能优化： 当数据量庞大时，单个数据库难以支撑高并发的读写请求。分库分表通过分散数据到多个数据库实例或表中，提升了数据库的并发处理能力。
扩展性： 分库分表提供了一种水平扩展（scale-out）的方式。当数据量增长时，可以通过增加数据库实例或表来扩展系统容量，而不必依赖于单个数据库的垂直扩展（scale-up）。
高可用性： 通过分库分表，可以在多个数据库实例之间进行数据备份和恢复，提升系统的容灾能力和数据安全性。

2. 读写分离

什么是读写分离？
读写分离 是一种数据库架构设计模式，用于将数据库的读操作和写操作分开执行，以提高数据库的性能和可扩展性。
写操作（写库）： 所有的数据插入、更新、删除操作都会写入到主数据库（主库）。
读操作（读库）： 查询操作（SELECT）可以从一个或多个从数据库（从库）中读取，从而分担主库的查询压力。
读写分离的优势
负载均衡： 通过将读操作分散到多个从库，可以有效分散数据库的查询负载，减少主库的压力。
提高性能： 在高并发场景下，读写分离可以显著提高数据库的响应速度，特别是当读操作占大多数时。
数据备份： 从库通常是主库的数据备份，通过读写分离的机制，还可以增强数据的安全性。
读写分离的挑战
数据同步延迟： 由于主从库之间的数据复制是异步的，可能会存在一定的延迟，从而导致从库的数据不一致问题。
事务一致性： 在分布式系统中，确保读写分离后的一致性和事务性是一项复杂的任务，特别是在跨库事务中。

3. 水平分片与垂直分片

水平分片（Horizontal Sharding）
水平分片 是将同一张表的数据按行进行拆分，每个分片包含部分行数据，而列结构保持一致。每个分片独立存储在不同的数据库实例或表中。
分片规则： 通常根据某个分片键（如用户ID、订单ID）来决定数据存储到哪个分片。
应用场景：
数据量非常大，单表行数超出单个数据库实例的处理能力时。
需要通过增加数据库实例来提高系统容量时。
优势：
线性扩展：可以通过增加分片的数量来线性扩展数据库容量。
分布式查询：能够在多个分片上并行执行查询，提高查询效率。
垂直分片（Vertical Sharding）
垂直分片 是按列将表拆分为多个子表，每个子表只存储部分列数据，而行数据保持一致。通常，每个子表存储在不同的数据库实例中。
分片规则： 通常根据表的字段（列）来进行拆分。比如，将用户的基础信息和账户信息分成不同的子表。
应用场景：
表的列数非常多，不同业务场景只关注部分字段时。
需要将不同功能模块的数据分开存储和维护时。
优势：
数据库优化：通过分离不常用的列，减少了表的宽度，从而提高查询效率。
业务分离：不同业务场景的数据可以存储在不同的数据库实例中，便于扩展和维护。
水平分片与垂直分片的比较
扩展性：
水平分片更适合通过增加数据行数来扩展系统的容量。
垂直分片更适合根据业务需求对表结构进行优化和分离。
复杂性：
水平分片在实现和管理上相对复杂，特别是在分片间的跨库查询和事务处理上。
垂直分片实现相对简单，但需要对业务逻辑有清晰的划分。

学Java的skyyyyyyyy

关注

15
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
数据库分库分表-ShardingSphere学习

ShardingSphere的架构主要围绕四个核心组件展开，分别是Sharding-JDBC、Sharding-Proxy、Sharding-Sidecar（计划中）和Sharding-Scheduler（计划中）。这些组件可以独立部署，也可以组合使用，形成一个完整的分布式数据库解决方案。ShardingSphere通过提供统一的API和配置方式，使得这些组件可以在不同的场景下无缝协作。
复制链接

扫一扫