1. Python技术站首页
  2. 其他
  3. Java

利用Sharding-Jdbc进行分库分表的操作代码

• Java

分库分表是数据库水平扩容的重要手段之一。Sharding-Jdbc是一个开源的分布式的关系型数据库中间件，它提供了比较完整的分库分表方案。下面就介绍一下如何使用Sharding-Jdbc进行分库分表的操作代码。

准备工作

  • 在Maven中引入Sharding-Jdbc相关的依赖包。
  • 编写Sharding-Jdbc的配置文件，配置主要包括数据源信息和分库分表等规则。

配置文件示例

spring:
  shardingsphere:
    datasource:
      names: ds_0, ds_1
      ds_0:
        url: jdbc:mysql://localhost:3306/db_0?useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: root
        type: com.zaxxer.hikari.HikariDataSource
      ds_1:
        url: jdbc:mysql://localhost:3306/db_1?useUnicode=true&characterEncoding=utf8&useSSL=false
        username: root
        password: root
        type: com.zaxxer.hikari.HikariDataSource
    sharding:
      tables:
        user:
          actualDataNodes: ds_${0..1}.user_${0..3}
          tableStrategy:
            standard:
              shardingColumn: id
              shardingAlgorithmName: userShardingAlgorithm
          keyGenerateStrategy:
            column: id
            keyGeneratorName: snowflake
      shardingAlgorithms:
        userShardingAlgorithm:
          type: INLINE
          props:
            algorithm-expression: user_${id % 4}
      keyGenerators:
        snowflake:
          type: SNOWFLAKE
          props:
            worker-id: 123
      props:
        sql:
          show: true
  • 该示例中配置了两个数据源：ds_0和ds_1。
  • 表user分散在两个数据源中，每个数据源都分了4个表（user_0, user_1, user_2, user_3）。
  • user表的分库分表策略是根据shardingColumn=id进行筛选，使用Inline算法，id%4的余数即为表名后缀。
  • user表的主键生成策略是用雪花算法生成。

在代码中配置Sharding-Jdbc

在代码中引入Sharding-Jdbc的配置，示例如下：

@Bean
public DataSource shardingDataSource() throws SQLException {
    return ShardingDataSourceFactory.createDataSource(readConfigFile(), readRules());
}

private ShardingRule readRules() {
    return ShardingRule.builder()
            .dataSourceRule(dataSourceRule())
            .tableRules(Collections.singleton(tableRule()))
            .databaseShardingStrategy(new DatabaseShardingStrategy("id", new UserDatabaseAlgorithm()))
            .tableShardingStrategy(new TableShardingStrategy("id", new UserTableAlgorithm()))
            .build();
}

private DataSourceRule dataSourceRule() {
    Map<String, DataSource> dataSourceMap = new HashMap<>();
    dataSourceMap.put("ds_0", dataSource0());
    dataSourceMap.put("ds_1", dataSource1());
    return new DataSourceRule(dataSourceMap, "ds_0");
}

private TableRule tableRule() {
    TableRule tableRule = TableRule.builder("user")
            .actualTables(Arrays.asList("user_0", "user_1", "user_2", "user_3"))
            .dataSourceRule(dataSourceRule())
            .build();
    return tableRule;
}

private DataSource dataSource0() {
    HikariDataSource hikariDataSource = new HikariDataSource();
    hikariDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db_0?useUnicode=true&characterEncoding=utf8&useSSL=false");
    hikariDataSource.setUsername("root");
    hikariDataSource.setPassword("root");
    return hikariDataSource;
}

private DataSource dataSource1() {
    HikariDataSource hikariDataSource = new HikariDataSource();
    hikariDataSource.setJdbcUrl("jdbc:mysql://localhost:3306/db_1?useUnicode=true&characterEncoding=utf8&useSSL=false");
    hikariDataSource.setUsername("root");
    hikariDataSource.setPassword("root");
    return hikariDataSource;
}
  • 在readRules()方法中，根据Sharding的规则配置DataSourceRule和TableRule。
  • 在dataSourceRule()方法中，配置了两个数据源ds_0和ds_1。
  • 在tableRule()方法中，配置了user表的实际表名列表和DataSourceRule。
  • 在数据源ds_0和ds_1中都有user表的4个实际表user_0、user_1、user_2和user_3。
  • 在readRules()方法中，使用了DatabaseShardingStrategy和TableShardingStrategy两个策略。

使用Sharding-Jdbc进行分库分表的操作

使用Spring JdbcTemplate进行数据库操作的示例：

@Repository
public class UserDaoImpl implements UserDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public User getUserById(Long id) {
        String sql = "SELECT * FROM user WHERE id = ?";
        Object[] params = {id};
        return jdbcTemplate.queryForObject(sql, params, new UserRowMapper());
    }

    @Override
    public void saveUser(User user) {
        String sql = "INSERT INTO user (id, name, age) VALUES (?, ?, ?)";
        Object[] params = {user.getId(), user.getName(), user.getAge()};
        jdbcTemplate.update(sql, params);
    }
}

class UserRowMapper implements RowMapper<User> {
    @Override
    public User mapRow(ResultSet rs, int rowNum) throws SQLException {
        User user = new User();
        user.setId(rs.getLong("id"));
        user.setName(rs.getString("name"));
        user.setAge(rs.getInt("age"));
        return user;
    }
}
  • 在DatabaseShardingStrategy和TableShardingStrategy中，分别使用了UserDatabaseAlgorithm和UserTableAlgorithm两个算法。
  • 以上是Sharding-Jdbc进行分库分表的基本操作流程。

再给一个Sharding-Jdbc分库分表的实际项目实战缺省的示例：

spring:
  shardingsphere:
    datasource:
      names: ds_master,ds_slave0,ds_slave1,ds_slave2
      ds_master:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db1?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowMultiQueries=true
        username: root
        password: admin123
      ds_slave0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3307/db1?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowMultiQueries=true
        username: root
        password: admin123
      ds_slave1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3307/db1?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowMultiQueries=true
        username: root
        password: admin123
      ds_slave2:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3307/db1?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowMultiQueries=true
        username: root
        password: admin123
    sharding:
      default-database-strategy:
        inline:
          sharding-column: user_id
          algorithm-expression: ds${user_id % 4}
      tables:
        t_order:
          actual-data-nodes: ds${0..3}.t_order_${0..1}
          database-strategy:
            hint:
              sharding-algorithm-name: order-database-strategy
              sharding-column: order_id
          table-strategy:
            hint:
              sharding-algorithm-name: order-table-strategy
              sharding-column: order_id
      sharding-algorithms:
        order-database-strategy:
          type: hint
          props:
            algorithm-class-name: com.soul.blog.repository.ShardingAlgorithm.OrderDatabaseShardingAlgorithm
        order-table-strategy:
          type: hint
          props:
            algorithm-class-name: com.soul.blog.repository.ShardingAlgorithm.OrderTableShardingAlgorithm
      props:
        sql:
          show: true
          simple: true

package com.soul.blog.repository;

import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.metadata.DataSourcePoolMetadataProvidersConfiguration;
import org.springframework.boot.autoconfigure.transaction.PlatformTransactionManagerAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.google.common.collect.Maps;
import com.soul.blog.constant.DataSourceNames;

import io.shardingsphere.api.config.HintShardingStrategyConfiguration;
import io.shardingsphere.api.config.ShardingRuleConfiguration;
import io.shardingsphere.api.config.TableRuleConfiguration;
import io.shardingsphere.api.config.algorithm.HintShardingAlgorithmConfiguration;
import io.shardingsphere.api.config.rule.DataSourceRuleConfiguration;
import io.shardingsphere.api.config.rule.TableRule;
import io.shardingsphere.api.config.strategy.HintShardingStrategyConfiguration;
import io.shardingsphere.api.config.strategy.StandardShardingStrategyConfiguration;
import io.shardingsphere.api.config.strategy.TableShardingStrategyConfiguration;
import io.shardingsphere.api.config.strategy.standard.StandardShardingStrategyConfiguration;
import io.shardingsphere.api.datasource.ShardingDataSource;
import io.shardingsphere.api.spring.datasource.SpringShardingDataSource;
import io.shardingsphere.api.spring.transaction.SpringShardingTransactionManager;

@AutoConfigureAfter({DataSourcePoolMetadataProvidersConfiguration.class})
@Configuration
@EnableTransactionManagement(order = 2)
@EnableConfigurationProperties(ShardingDatabasesProperties.class)
public class ShardingJdbcConfiguration {

    @Autowired
    private Environment env;

    @Autowired
    private List<DataSource> dataSourceList;

    @Autowired
    private ShardingDatabasesProperties shardingDatabasesProperties;

    @Bean(name = "shardingDataSource")
    public DataSource getShardingDS() throws Exception {
        DataSourceRuleConfiguration dataSourceRuleConfiguration = new DataSourceRuleConfiguration();
        dataSourceRuleConfiguration.setName("mainDataSourceGroup");
        int i = 0;
        for (DataSource dataSource : dataSourceList) {
            dataSourceRuleConfiguration.getDataSources().put(DataSourceNames.getRealDataSourceName(i), dataSource);
            i++;
        }

        TableRuleConfiguration orderTableRuleConfig = new TableRuleConfiguration("t_order", "mainDataSourceGroup.t_order${0..3}");

        orderTableRuleConfig.setDatabaseShardingStrategyConfig(new HintShardingStrategyConfiguration(new HintShardingAlgorithmConfiguration()));
        orderTableRuleConfig.setTableShardingStrategyConfig(new HintShardingStrategyConfiguration(new HintShardingAlgorithmConfiguration()));
        ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();
        shardingRuleConfiguration.getTableRuleConfigs().add(orderTableRuleConfig);

        shardingRuleConfiguration.getBindingTableGroups().add("t_order");
        shardingRuleConfiguration.getBroadcastTableNames().add("t_config");

        Object databases = shardingDatabasesProperties.getDatabases();

        Map<String, DataSource> dataSourceMap = Maps.newHashMap();
        dataSourceMap.putAll(dataSourceRuleConfiguration.getDataSources());
        ShardingDataSource shardingDataSource = new ShardingDataSource(dataSourceMap, shardingRuleConfiguration, Maps.newHashMap(), new Properties());
        return shardingDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactoryBean(@Qualifier("shardingDataSource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "shardingTX")
    public PlatformTransactionManager getShardingTX(@Qualifier("shardingDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

}


package com.soul.blog.repository.ShardingAlgorithm;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.springframework.stereotype.Component;

import com.google.common.collect.Range;
import com.soul.blog.constant.DataSourceNames;

import io.shardingsphere.api.algorithm.sharding.PreciseShardingAlgorithm;


@Component
public class OrderDatabaseShardingAlgorithm implements PreciseShardingAlgorithm<Integer> {

    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Integer> shardingValue) {

        Set<String> tables = new HashSet<>();
        for (String table : availableTargetNames) {
            if (table.startsWith("mainDataSourceGroup.t_order")) {
                tables.add(table);
            }
        }

        Integer value = shardingValue.getValue() % DataSourceNames.number;
        if (value == 0) {
            return "ds_master";
        } else {
            for (String table : tables) {
                Integer id = Integer.valueOf(table.substring(table.length() - 1)) % DataSourceNames.number;
                if (id.equals(value)) {
                    return table;
                }
            }
        }
        for (String table : tables) {
            if (table.endsWith("0")) {
                return table;
            }
        }
        return "订单不存在：user_id=" + shardingValue.getValue();
    }
}


package com.soul.blog.repository.ShardingAlgorithm;

import java.util.Collection;
import java.util.HashSet;
import java.util.Set;

import org.springframework.stereotype.Component;

import com.google.common.collect.Range;
import com.soul.blog.constant.DataSourceNames;

import io.shardingsphere.api.algorithm.sharding.standard.PreciseShardingAlgorithm;
import io.shardingsphere.api.algorithm.sharding.standard.RangeShardingAlgorithm;
import io.shardingsphere.api.config.ShardingRuleConfiguration;
import io.shardingsphere.api.config.rule.TableRuleConfiguration;
import io.shardingsphere.api.sharding.complex.ComplexKeysShardingAlgorithm;
import io.shardingsphere.api.sharding.complex.ComplexKeysShardingValue;
import io.shardingsphere.api.sharding.standard.StandardShardingAlgorithm;
import io.shardingsphere.api.sharding.standard.StandardShardingStrategyConfiguration;
import lombok.extern.slf4j.Slf4j;


@Component
@Slf4j
public class OrderTableShardingAlgorithm implements PreciseShardingAlgorithm<Long>, RangeShardingAlgorithm<Long> {

    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> shardingValue) {

        Set<String> tableNames = new HashSet<>();

        // 获取实际表名列表
        for (String name : availableTargetNames) {
            if (name.startsWith("t_order")) {
                tableNames.add(name);
            }
        }

        for (String tableName : tableNames) {
            if (tableName.endsWith(shardingValue.getValue() % DataType.orderTable.length + "")) {
                return tableName;
            }
        }

        throw new IllegalArgumentException();
    }

    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, RangeShardingValue<Long> shardingValue) {
        Set<String> tableNames = new HashSet<>();

        // 获取实际表名列表
        for (String name : availableTargetNames) {
            if (name.startsWith("t_order")) {
                tableNames.add(name);
            }
        }

        Range<Long> range = shardingValue.getValueRange();
        for (long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i ++) {
            // 决定落到哪个库哪张表
            String existTableName = null;
            for (String each : tableNames) {
                if (each.endsWith(i % DataType.orderTable.length + "")) {
                    existTableName = each;
                }
            }
            if (null != existTableName) {
                tableNames.add(existTableName); //确定类型
                // 将排序列用于限制路由范围
                if (tableNames.size() == DataType.orderTable.length) {
                    break;
                }
            }
        }
        if (tableNames.size() == 0) {
            throw new IllegalArgumentException();
        }
        return tableNames;
    }
}

其中，还有一些Sharding-Jdbc的配置细节和辅助类，这里不作赘述。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：利用Sharding-Jdbc进行分库分表的操作代码 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年6月16日
下一篇 2023年6月16日

相关文章

  • 如何从官网下载Hibernate jar包的方法示例

    下面是从官网下载Hibernate jar包的方法： 第一步：进入官网 首先，我们需要进入Hibernate的官网：https://hibernate.org/ 第二步：选择版本 在官网主页上，我们可以看到各种Hibernate的相关信息，需要找到“Download”选项卡。在下载页中，选择我们需要下载的版本和平台，例如： https://hibernate…

    Java 2023年5月20日
    00

  • java8 统计字符串字母个数的几种方法总结(推荐)

    Java8 统计字符串字母个数的几种方法总结(推荐) 在Java8中，有许多快捷方法可以用来计算字符串中的字母个数。下面总结了几种使用Java8进行字符串字母统计的方法。 方法1：使用filter和count方法 可以使用Java8的Stream API中的Filter和Count方法来计算一个字符串中字母的数量。示例代码如下： String str = &…

    Java 2023年5月27日
    00

  • 详解Tomcat双击startup.bat闪退的解决方法

    下面是“详解Tomcat双击startup.bat闪退的解决方法”的完整攻略。 问题背景 当我们在Windows系统上双击Tomcat的startup.bat启动脚本时，有时会出现闪退的情况。这可能是由于某些配置或系统环境问题导致的。下面我们将详解解决这一问题的方法。 解决方法 方法一：修改startup.bat文件 步骤如下： 打开Tomcat的安装目录，…

    Java 2023年5月19日
    00

  • 最新IntelliJ IDEA 2022配置 Tomcat 8.5 的详细步骤演示

    让我为你介绍如何在最新的 IntelliJ IDEA 2022 中配置 Tomcat 8.5 的详细步骤演示。 第一步：下载并安装 Tomcat 8.5 首先，我们需要从官方网站下载 Tomcat 8.5 的安装文件，并按照指导完成安装。Tomcat 的安装过程相对简单，请仔细查看安装说明。 第二步：以 Tomcat 服务器方式配置项目 打开 Intelli…

    Java 2023年6月2日
    00

  • Mybatis-Plus主键生成策略的方法

    关于Mybatis-Plus主键生成策略的方法，我们来一步步讲解。 什么是Mybatis-Plus主键生成策略 首先，让我们了解一下Mybatis-Plus是什么。Mybatis-Plus是一个Mybatis的增强工具，提供了很多强大的功能，包括自动生成代码、通用CRUD操作、分页插件等等。而Mybatis-Plus主键生成策略就是Mybatis-Plus提…

    Java 2023年5月19日
    00

  • JavaSE文件操作工具类FileUtil详解

    JavaSE文件操作工具类FileUtil详解 简介 JavaSE中提供了File类用来操作文件或目录。但是，操作文件或目录的流程较为繁琐，如果我们需要经常操作文件或目录，就需要编写大量的重复代码。为了解决这个问题，我们可以将文件操作的常用方法封装在一个工具类中，从而减少代码量和提高开发效率。本文将介绍一个JavaSE文件操作的工具类FileUtil。 Fi…

    Java 2023年5月19日
    00

  • Java线程间共享实现方法详解

    Java线程间共享实现方法详解 什么是线程间共享 在Java中，线程是运行在同一个进程中的多个子任务。这些子任务可以共享代码、数据和资源。线程间共享就是指多个线程访问同一个数据和资源的过程。 在多线程编程中，线程间共享常用于实现任务之间的通信和协作，例如，生产者消费者模式、读写锁等场景。 线程间共享实现方法 Java提供了多种实现线程间共享的方式，常用的包括…

    Java 2023年5月19日
    00

  • 详解jvm对象的创建和分配

    我来为你详细讲解“详解jvm对象的创建和分配”的完整攻略。 什么是JVM？ 首先，让我们来了解一下JVM是什么。JVM全称为Java Virtual Machine，即Java虚拟机，是Java程序的运行环境。JVM是Java应用程序与操作系统之间的一层抽象，负责管理程序的运行、内存分配等工作。 JVM对象的创建 在Java语言中，对象是通过new关键字来创…

    Java 2023年5月26日
    00
合作推广
合作推广
分享本页
返回顶部