Java ShardingJDBC实战演练攻略

简介

Java ShardingJDBC是一款基于JDBC接口，以分库分表为核心的中间件。它通过JDBC驱动的方式，为应用程序提供了一套分布式数据库访问的解决方案。

在本文中，我们将详细介绍Java ShardingJDBC的使用方法和实战演练攻略。

1. 环境准备

在进行实战演练前，需要准备如下环境：

JDK 1.8及以上版本
Maven 3.0及以上版本
MySQL数据库
ShardingJDBC版本为4.0.1
SpringBoot版本为2.4.2

2. 示例说明

示例1：分库分表

在这个示例中，我们将演示如何通过Java ShardingJDBC实现分库分表。

步骤1：准备数据库

在这个示例中，我们需要准备2个MySQL数据库，每个数据库中分别创建2个表。

-- 数据库1
CREATE DATABASE db1 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

-- 用户表
CREATE TABLE user (
  id BIGINT NOT NULL AUTO_INCREMENT,
  name VARCHAR(50),
  age INT,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

-- 商品表
CREATE TABLE goods (
  id BIGINT NOT NULL AUTO_INCREMENT,
  name VARCHAR(50),
  stock INT,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

-- 数据库2
CREATE DATABASE db2 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

-- 订单表
CREATE TABLE order (
  id BIGINT NOT NULL AUTO_INCREMENT,
  user_id BIGINT,
  goods_id BIGINT,
  amount INT,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

-- 购物车表
CREATE TABLE cart (
  id BIGINT NOT NULL AUTO_INCREMENT,
  user_id BIGINT,
  goods_id BIGINT,
  amount INT,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

步骤2：搭建SpringBoot工程

首先，我们需要在Maven中添加Sharding-JDBC和MySQL驱动的依赖：

<dependencies>
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.0.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>
</dependencies>

然后，我们需要在Spring Boot配置文件中添加如下配置：

spring:
  shardingsphere:
    datasource:
      names: ds0, ds1
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db1?serverTimezone=UTC&useSSL=false
        username: root
        password: 123456
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db2?serverTimezone=UTC&useSSL=false
        username: root
        password: 123456
    sharding:
      tables:
        user:
          actualDataNodes: ds$->{0..1}.user_$->{0..1}
          tableStrategy:
            inline:
              shardingColumn: id
              algorithmExpression: user_$->{id % 2}
        goods:
          actualDataNodes: ds$->{0..1}.goods_$->{0..1}
          tableStrategy:
            inline:
              shardingColumn: id
              algorithmExpression: goods_$->{id % 2}
        order:
          actualDataNodes: ds$->{0..1}.order_$->{0..1}
          tableStrategy:
            inline:
              shardingColumn: id
              algorithmExpression: order_$->{id % 2}
        cart:
          actualDataNodes: ds$->{0..1}.cart_$->{0..1}
          tableStrategy:
            inline:
              shardingColumn: id
              algorithmExpression: cart_$->{id % 2}
      defaultDatabaseStrategy:
        inline:
          shardingColumn: id
          algorithmExpression: ds$->{id % 2}

在这个配置文件中，我们定义了两个数据源ds0和ds1，分别对应两个MySQL数据库。

对于每一张表，我们需要定义它在不同数据源中的实际数据节点，以及表的分片策略。在这个示例中，我们使用了基于id对2进行取模的方式进行分片。

最后，我们还需要定义默认的数据源和数据库分片策略。

步骤3：测试代码

在测试代码中，我们可以直接注入数据源，操作相应的表。

@RestController
public class UserController {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GetMapping("/users")
    public List<Map<String, Object>> getUsers() {
        return jdbcTemplate.queryForList("SELECT * FROM user");
    }

    @PostMapping("/users")
    public String addUser(@RequestBody User user) {
        String sql = "INSERT INTO user(name, age) VALUES (?, ?)";
        jdbcTemplate.update(sql, user.getName(), user.getAge());
        return "success";
    }
}

示例2：读写分离

在这个示例中，我们将演示如何通过Java ShardingJDBC实现读写分离。

步骤1：准备数据库

在这个示例中，我们需要准备2个MySQL数据库，分别用于读写操作。

-- 主库
CREATE DATABASE db_master DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

-- 用户表
CREATE TABLE user (
  id BIGINT NOT NULL AUTO_INCREMENT,
  name VARCHAR(50),
  age INT,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

-- 从库
CREATE DATABASE db_slave DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

-- 商品表
CREATE TABLE goods (
  id BIGINT NOT NULL AUTO_INCREMENT,
  name VARCHAR(50),
  stock INT,
  PRIMARY KEY (id)
) ENGINE=InnoDB;

步骤2：搭建SpringBoot工程

首先，我们需要在Maven中添加Sharding-JDBC和MySQL驱动的依赖：

<dependencies>
    <dependency>
        <groupId>org.apache.shardingsphere</groupId>
        <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
        <version>4.0.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.22</version>
    </dependency>
</dependencies>

然后，我们需要在Spring Boot配置文件中添加如下配置：

spring:
  shardingsphere:
    datasource:
      names: ds_master, ds_slave
      ds_master:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db_master?serverTimezone=UTC&useSSL=false
        username: root
        password: 123456
      ds_slave:
        type: com.zaxxer.hikari.HikariDataSource
        driver-class-name: com.mysql.cj.jdbc.Driver
        jdbc-url: jdbc:mysql://localhost:3306/db_slave?serverTimezone=UTC&useSSL=false
        username: root
        password: 123456
    sharding:
      defaultDatabaseStrategy:
        inline:
          shardingColumn: id
          algorithmExpression: ds_master
      masterSlaveRule:
        masterDataSourceName: ds_master
        slaveDataSourceNames:
          - ds_slave

在这个配置文件中，我们定义了两个数据源ds_master和ds_slave，分别对应主库和从库。

然后，我们还需要在sharding配置中指定默认的数据源，以及定义读写分离的规则。

步骤3：测试代码

在测试代码中，我们可以直接注入数据源，根据需要的操作类型分别使用主库或从库。

@Component
public class UserService {

    @Autowired
    private ShardingDataSource shardingDataSource;

    public List<Map<String, Object>> getUsers() {
        try (Connection connection = shardingDataSource.getConnection();
             PreparedStatement ps = connection.prepareStatement("SELECT * FROM user")) {
            ResultSet rs = ps.executeQuery();
            List<Map<String, Object>> resultList = new ArrayList<>();
            while (rs.next()) {
                Map<String, Object> resultMap = new HashMap<>();
                resultMap.put("id", rs.getLong("id"));
                resultMap.put("name", rs.getString("name"));
                resultMap.put("age", rs.getInt("age"));
                resultList.add(resultMap);
            }
            return resultList;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public void addUser(User user) {
        try (Connection connection = shardingDataSource.getConnection();
             PreparedStatement ps = connection.prepareStatement("INSERT INTO user(name, age) VALUES (?, ?)")) {
            ps.setString(1, user.getName());
            ps.setInt(2, user.getAge());
            ps.executeUpdate();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}

总结

通过以上两个示例，我们可以清晰地了解到Java ShardingJDBC的使用方法和实现原理。同时，我们也可以通过不同的分片策略，满足不同场景下的数据访问需求。

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Java ShardingJDBC实战演练 - Python技术站

Java ShardingJDBC实战演练

Java ShardingJDBC实战演练攻略

简介

1. 环境准备

2. 示例说明

示例1：分库分表

步骤1：准备数据库

步骤2：搭建SpringBoot工程

步骤3：测试代码

示例2：读写分离

步骤1：准备数据库

步骤2：搭建SpringBoot工程

步骤3：测试代码

总结

相关文章