二、Sharding-JDBC 快速入门（只水平分表）

最新推荐文章于 2024-05-22 02:20:35 发布

PkyShare

最新推荐文章于 2024-05-22 02:20:35 发布

阅读量2.1k

点赞数 2

分类专栏：分库分表文章标签： Sharding-JDBC

本文链接：https://blog.csdn.net/qq_34369588/article/details/102617388

版权

分库分表专栏收录该内容

6 篇文章 4 订阅

订阅专栏

1、Sharding-JDBC 介绍

本文章是通过黑马的 sharding-jdbc 教程摘录总结

Sharding-JDBC 是当当网研发的开源分布式数据库中间件，从3.0开始其被包含在Sharding-Sphere中，之后该项目进入Apache孵化器，4.0版本之后的为Apache版本
ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar(计划中)这3款相互独立的产品组成。他们均提供标准化的数据分片、分布式事务和数据库治理功能，可适用于Java同构、异构语言、容器、云原生等各种多样化应用场景
官方地址:https://shardingsphere.apache.org/document/current/cn/overview
目前只需关注Sharding-JDBC，它定位为轻量级Java框架，在Java的JDBC层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，无需二额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。
Sharding-JDBC的核心功能为数据分片和读写分离，通过Sharding-JDBC，应用可以透明的使用 jdbc 访问已经分库分表、读写分离的多个数据源，而不用关心数据源的数量以及数据如何分布。如下图：
在这里插入图片描述

适用于任何基于Java的ORM框架，如Mybatis，Hibernate，Spirng JDBC Template或直接使用JDBC.
基于任何第三方的数据库连接池，如：DBCP,C3P0，BoneCPU，Druid，HikariCP等。
支持任意实现 JDBC 规范的数据库。目前支持 MySQL，Oracle，SQLServer 和 PostgreSQL。

2、与 jdbc 性能对比

2.1、性能损耗测试：

服务器资源充足、并发数相同，比较 JDBC 和 Sharding-JDBC 性能损耗，Sharding-JDBC 相对 JDBC 损耗不超过 7%。

基准测试性能对比

业务场景	JDBC	Sharding-JDBC 1.5.2	Sharding-JDBC 1.5.2/JDBC 损耗
单库单表查询	493	470	4.7%
单库单表更新	6682	6303	5.7%
单库单表插入	6855	6375	7%

业务场景	业务平均响应时间（ms）	业务 TPS
JDBC 单库单表查询	7	493
Sharding-JDBC 1.5.2单库单表查询	8	470

2.2 性能对比测试

当服务器资源使用到极限，相同场景 JDBC 与 Sharding-JDBC 的吞吐量相同。
当服务器资源使用到极限，Sharding-JDBC 采用分库分表后，Sharding-JDBC 吞吐量较 JDBC 不分库有接近两倍的提升。

JDBC 单库两表与 Sharding-JDBC 两库各两表对比

业务场景	JDBC 单库两表	Sharding-JDBC 两库各两表	性能提升至
查询	1736	3331	192%
更新	9170	17997	196%
插入	11574	23043	199%

JDBC 单库单表与 Sharding-JDBC 两库各一表对比

业务场景	JDBC 单库单表	Sharding-JDBC 两库各一表	性能提升至
查询	1586	2944	185%
更新	9548	18561	194%
插入	11182	21414	192%

3、Sharding-JDBC 快速入门

3.1 需求分析

使用 Sharding-JDBC 完成对订单表的水平分表，通过快速入门程序的开发，快速体验 Sharding-JDBC 的使用方法。
人工创建两张表，t_order_1 和 t_order_2，这两张表是订单表拆分后的表，通过 Sharding-JDBC 向订单表插入数据，按照一定的分片规则，主键为奇数的进入 t_order_1，另一部分数据进入 t_order_2，通过 Sharding-JDBC 查询数据，根据 SQL 语句的内容从 t_order_1 或 t_order_2 查询数据。

3.2 环境搭建

3.2.1 环境说明

操作系统：Win10
数据库：MySQL 8.0.11
JDK：64位 jdk1.8.0_201
应用框架：spring-boot-2.1.3RELEASE，Mybatis 3.5.0
Sharding-JDBC：sharding-jdbc-spring-boot-starter-4.0.0.RC1

3.2.2 创建数据库

/*
SQLyog Ultimate v12.08 (32 bit)
MySQL - 8.0.11 : Database - order_db
*********************************************************************
*/


/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`order_db` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `order_db`;

/*Table structure for table `t_order_1` */

DROP TABLE IF EXISTS `t_order_1`;

CREATE TABLE `t_order_1` (
  `order_id` bigint(20) NOT NULL COMMENT '订单id',
  `price` decimal(10,2) NOT NULL COMMENT '订单价格',
  `user_id` bigint(20) NOT NULL COMMENT '下单用户id',
  `status` varchar(50) NOT NULL COMMENT '订单状态',
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='订单表1';

/*Data for the table `t_order_1` */

/*Table structure for table `t_order_2` */

DROP TABLE IF EXISTS `t_order_2`;

CREATE TABLE `t_order_2` (
  `order_id` bigint(20) NOT NULL COMMENT '订单id',
  `price` decimal(10,2) NOT NULL COMMENT '订单价格',
  `user_id` bigint(20) NOT NULL COMMENT '下单用户id',
  `status` varchar(50) NOT NULL COMMENT '订单状态',
  PRIMARY KEY (`order_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='订单表2';

/*Data for the table `t_order_2` */

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

3.2.3 引入 maven

引入 sharding-jdbc 和 SpringBoot 整合的 jar 包：

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

完整 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.pky</groupId>
    <artifactId>sharding-jdbc</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>sharding-jdbc</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--  SpringBoot Begin -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.0-RC1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!--  SpringBoot End -->

        <!-- Commons Begin -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
        </dependency>
        <!-- Commons End -->
    </dependencies>

    <build>
        <plugins>
            <!-- Compiler 插件, 设定 JDK 版本 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <showWarnings>true</showWarnings>
                </configuration>
            </plugin>

            <!-- 打包 jar 文件时，配置 manifest 文件，加入 lib 包的 jar 依赖 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <configuration>
                            <archive>
                                <manifest>
                                    <!-- Add directory entries -->
                                    <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                                    <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
                                    <addClasspath>true</addClasspath>
                                </manifest>
                            </archive>
                        </configuration>
                    </execution>
                </executions>
            </plugin>

            <!-- resource -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
            </plugin>

            <!-- install -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-install-plugin</artifactId>
            </plugin>

            <!-- clean -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-clean-plugin</artifactId>
            </plugin>

            <!-- ant -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-antrun-plugin</artifactId>
            </plugin>

            <!-- dependency -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
            </plugin>
        </plugins>

        <pluginManagement>
            <plugins>
                <!-- Java Document Generate -->
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-javadoc-plugin</artifactId>
                    <executions>
                        <execution>
                            <phase>prepare-package</phase>
                            <goals>
                                <goal>jar</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>

                <!-- YUI Compressor (CSS/JS压缩) -->
                <plugin>
                    <groupId>net.alchim31.maven</groupId>
                    <artifactId>yuicompressor-maven-plugin</artifactId>
                    <version>1.5.1</version>
                    <executions>
                        <execution>
                            <phase>prepare-package</phase>
                            <goals>
                                <goal>compress</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <encoding>UTF-8</encoding>
                        <jswarn>false</jswarn>
                        <nosuffix>true</nosuffix>
                        <linebreakpos>30000</linebreakpos>
                        <force>true</force>
                        <includes>
                            <include>**/*.js</include>
                            <include>**/*.css</include>
                        </includes>
                        <excludes>
                            <exclude>**/*.min.js</exclude>
                            <exclude>**/*.min.css</exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>

        <!-- 资源文件配置 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
    </build>

    <repositories>

        <repository>
            <id>aliyun-repos</id>
            <name>Aliyun Repository</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>

        <repository>
            <id>sonatype-repos</id>
            <name>Sonatype Repository</name>
            <url>https://oss.sonatype.org/content/groups/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>sonatype-repos-s</id>
            <name>Sonatype Repository</name>
            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
            <releases>
                <enabled>false</enabled>
            </releases>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>

        <repository>
            <id>spring-snapshots</id>
            <name>Spring Snapshots</name>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

    <pluginRepositories>

        <pluginRepository>
            <id>aliyun-repos</id>
            <name>Aliyun Repository</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>

</project>

3.2.4 分片规则配置

分片规则配置是 sharding-jdbc 进行对分库分表操作的重要依据，配置内容包括：数据源、主键生成策略、分片策略等。

application.properties

server.port = 9095
server.servlet.context-path = /sharding-jdbc

spring.application.name = sharding-jdbc
spring.http.encoding.charset = utf-8
spring.http.encoding.enabled = true
spring.http.encoding.force = true
# 针对bean被重复定义，重复则覆盖
spring.main.allow-bean-definition-overriding = true  
# 和数据库字段进行印射，最终成为驼峰命名
mybatis.configuration.map-underscore-to-canel-case = true

## Sharding-jdbc 分片规则配置
# 数据源
spring.shardingsphere.datasource.names = m1
# 数据库连接池
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://127.0.0.1:3306/order_db?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&zeroDateTimeBehavior=CONVERT_TO_NULL&serverTimezone=Asia/Shanghai
spring.shardingsphere.datasource.m1.username = root
spring.shardingsphere.datasource.m1.password = 123456

# 指定t_order表的数据分布情况配置数据节点
spring.shardingsphere.sharding.tables.t_order.actual-data-nodes = m1.t_order_$->{1..2}

# 指定t_order表的主键生成策略为SNOWFLAKE(雪花算法，实现全局主键自增)
spring.shardingsphere.sharding.tables.t_order.key-generator.column = order_id
spring.shardingsphere.sharding.tables.t_order.key-generator.type = SNOWFLAKE

# 指定t_order表的分片策略，分片策略包括分片键和分片算法
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.sharding-column = order_id
spring.shardingsphere.sharding.tables.t_order.table-strategy.inline.algorithm-expression = t_order_$->{order_id % 2 + 1}

# 打开sql输出日志
spring.shardingsphere.props.sql.show = true

application.yml

server:
  port: 9095
  servlet:
    context-path: /sharding-jdbc

spring:
  application:
    name: sharding-jdbc
  http:
    encoding:
      charset: UTF-8
      enabled: true
      force: true
  main:
    allow-bean-definition-overriding: true     # 针对bean被重复定义，重复则覆盖

  ## Sharding-jdbc 分片规则配置
  # 数据源
  shardingsphere:
    datasource:
      names: m1 # m1 为数据源别名
      # 数据库连接池
      m1:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/order_db?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&zeroDateTimeBehavior=CONVERT_TO_NULL&serverTimezone=Asia/Shanghai
        username: root
        password: 123456
    # 指定t_order表的数据分布情况配置数据节点
    sharding:
      tables:
        t_order:  # 数据库中已经分表的表逻辑表
          actual-data-nodes: m1.t_order_$->{1..2}
          # 指定t_order表的主键生成策略
          key-generator:
            column: order_id # 主键列
            type: SNOWFLAKE # 策略算法类型为SNOWFLAKE(雪花算法，实现全局主键自增)
          # 指定t_order表的分片策略，分片策略包括分片键和分片算法
          table-strategy:
            inline:
              sharding-column: order_id # 以 order_id 为分片键
              algorithm-expression: t_order_$->{order_id % 2 + 1} # order_id 取模进行分片，如 order_id 尾数为偶数则存入 t_order_1中，否则存入 t_order_2 中
    # 打开sql输出日志
    props:
      sql:
        show: true

# 和数据库字段进行印射，最终成为驼峰命名
mybatis:
  configuration:
    map-underscore-to-canel-case: true

步骤：

配置数据源
配置数据节点
配置主键生成策略
配置分片策略

3.2.5 具体代码

mapper
创建 mapper 包，并创建 mapper 接口 OrderMapper

package com.pky.shardingjdbc.mapper;

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.math.BigDecimal;
import java.util.List;
import java.util.Map;

@Repository
public interface OrderMapper {

    /**
     * 插入订单
     * @param price 价格
     * @param userId 用户id
     * @param status 状态
     */
    @Insert("insert into t_order(price, user_id, status) values (#{price}, #{userId}, #{status})")
    void insert(@Param("price") BigDecimal price, @Param("userId") Long userId, @Param("status") String status);

    /**
     * 根据id查询订单
     * @param orderIds id集合
     * @return
     */
    @Select("<script>" +
            "select * from t_order o " +
            "where o.order_id in " +
            "<foreach collection = 'orderIds' open = '(' separator = ',' close = ')' item = 'id'> " +
            "#{id}" +
            "</foreach>" +
            "</script>")
    List<Map> selectOrderByIds(@Param("orderIds") List<Long> orderIds);

}

这里用了注解形式替代了 mapper.xml，另外在 insert 方法中无需手动插入 order_id，因为 sharding-jdbc 会采用雪花算法帮我们自动生成。

测试
在 test 文件夹下创建 java 测试文件，并创建 com.pky.shardingjdbc 包，然后创建测试类 OrderTest：

package com.pky.shardingjdbc;

import com.pky.shardingjdbc.domain.Order;
import com.pky.shardingjdbc.mapper.OrderMapper;
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;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ShardingJDBCApplication.class})
public class OrderTest {

    @Autowired
    OrderMapper orderMapper;

    @Test
    public void testInsert() {
        for(int i = 0; i < 20; i++) {
            orderMapper.insert(new BigDecimal(i), 1L, "yes");
        }
    }

    @Test
    public void testSelect() {
        List<Long> orderIds = new ArrayList<>();
        orderIds.add(393345721874513920l);
        orderIds.add(393345722830815232l);
        orderIds.add(393345721346031617l);
        List<Map> orders = orderMapper.selectOrderByIds(orderIds);
    }
}

3.3 测试结果

3.3.1 插入结果

在这里插入图片描述
这里总共插入 20 条记录，通过截图的 sql 可知，我们写的 sql 是 inset into t_order(price, user_id, status) values(?, ? ,?)，t_order 为逻辑表；而实际中，sharding-jdbc 通过配置的 order_id 全局主键取模，来判断是存入到哪个表中，实际执行的 sql 为 insert into t_order_1 (price, user_id, status, order_id) VALUES (?, ?, ?, ?) 或 insert into t_order_2 (price, user_id, status, order_id) VALUES (?, ?, ?, ?)，插入到真实的 t_order_1 或 t_order_2 表中

3.3.2 查询结果

在这里插入图片描述

3.4 执行流程分析

通过日志分析，Sharding-JDBC 在拿到用户要执行的 sql 之后干了哪些事：

解析 sql，获取片键值，在本例中是 order_id
Sharding-JDBC 通过规则配置 t_order_$->{order_id % 2 +1}，知道了当 order_id 为偶数时，应该往 t_order_1 表插数据；为奇数时，往 t_order_2 表中插数据。
于是 Sharding-JDBC 根据 order_id 的值改写 sql 语句，改写后的 SQL 语句是真实所要执行的 SQL 语句。
执行改写后的真实 sql 语句
将所有真正执行 sql 的结果进行汇总合并，返回。

3.5 其他集成方式

&mesp;Sharding-JDBC 不仅可以与 SpringBoot 良好集成，它还支持其他配置方式，共支持一下四种集成方式。以上有 application.properties 和 application.yml 配置方式，因此介绍另外两种

3.5.1 Java 配置

添加配置类：

package com.pky.shardingjdbc.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.shardingsphere.api.config.sharding.KeyGeneratorConfiguration;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.InlineShardingStrategyConfiguration;
import org.apache.shardingsphere.shardingjdbc.api.ShardingDataSourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import javax.xml.crypto.Data;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

/**
 * Sharding-JDBC 配置类
 */
@Configuration
public class ShardingJdbcConfig {

    /**
     * 配置分片策略（定义数据源）
     * @return
     */
    public Map<String, DataSource> createDataSourceMap() {
        DruidDataSource dataSource1 = new DruidDataSource();
        dataSource1.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource1.setUrl("jdbc:mysql://192.168.6.101:3306/order_db?useSSL=false&useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&zeroDateTimeBehavior=CONVERT_TO_NULL&serverTimezone=Asia/Shanghai");
        dataSource1.setUsername("root");
        dataSource1.setPassword("host");
        Map<String, DataSource> result = new HashMap<>();
        result.put("m1", dataSource1);
        return result;
    }

    /**
     * 定义主键生成策略
     * @return
     */
    private static KeyGeneratorConfiguration getKeyGeneratorConfiguration() {
        KeyGeneratorConfiguration result = new KeyGeneratorConfiguration("SNOWFLAKE", "order_id");
        return result;
    }

    /**
     * 定义 t_order 表分片策略
     * @return
     */
    public TableRuleConfiguration getOrderTableRuleConfiguration() {
        TableRuleConfiguration result = new TableRuleConfiguration("t_order", "m1.t_order_$->{1..2}");
        result.setTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("order_id","t_order_$->{order_id % 2 + 1}"));
        result.setKeyGeneratorConfig(getKeyGeneratorConfiguration());
        return result;
    }

    /**
     * 定义sharding-JDBC 数据源
     * @return
     * @throws SQLException
     */
    @Bean
    public DataSource getShardingDataSource() throws SQLException {
        ShardingRuleConfiguration shardingRuleConfiguration = new ShardingRuleConfiguration();
        shardingRuleConfiguration.getTableRuleConfigs().add(getOrderTableRuleConfiguration());
        // spring.shardingsphere.props.sql.show = true
        Properties properties = new Properties();
        properties.put("sql.show", "true");
        return ShardingDataSourceFactory.createDataSource(createDataSourceMap(), shardingRuleConfiguration, properties);
    }
}

将 yml 或 properties 配置文件中的 sharding-jdbc 配置注释掉

排除 SpringBoot 自动扫描配置类，否则会报错

package com.pky.shardingjdbc;

import org.apache.shardingsphere.shardingjdbc.spring.boot.SpringBootConfiguration;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(exclude = SpringBootConfiguration.class) // 排除 SpringBoot 默认读取 properties 或 yml 配置文件
@MapperScan(basePackages = "com.pky.shardingjdbc.mapper")  // 扫描该路径下的 mapper
public class ShardingJDBCApplication {
    public static void main(String[] args) {
        SpringApplication.run(ShardingJDBCApplication.class, args);
    }
}

注意引用的 SpringBootConfiguration 包是 org.apache.shardingsphere.shardingjdbc.spring.boot.

3.5.2 xml 配置

我们使用的是 springboot 应用程序，因此这里不做介绍

当前配置建议使用 properties，因为层次关系太深的话 yml 看起来不直观，java 配置的话要写很多 java 代码

以上是 Sharding-JDBC 快速入门，接下来深入学习 Sharding-JDBC

PkyShare

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
二、Sharding-JDBC 快速入门（只水平分表）

1、Sharding-JDBC 介绍 Sharding-JDBC 是当当网研发的开源分布式数据库中间件，从3.0开始其被包含在Sharding-Sphere中，之后该项目进入Apache孵化器，4.0版本之后的为Apache版本 ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-S...
复制链接

扫一扫