1 -【 MySQL 集群 】- 6 Sharding-Jdbc 分表分库

最新推荐文章于 2024-04-25 20:15:00 发布
最新推荐文章于 2024-04-25 20:15:00 发布
阅读量325 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42112635/article/details/105230310
版权

1 Sharding-Jdbc 分表分库

LogicTable

数据分片的逻辑表，对于水平拆分的数据库(表)，同一类表的总称。

订单信息表拆分为 2 张表，分别是：t_order_0、t_order_1，他们的逻辑表名为 t_order。

ActualTable

在分片的数据库中真实存在的物理表。即上个示例中的 t_order_0、t_order_1。

DataNode

数据分片的最小单元。由数据源名称和数据表组成，例：test_msg0.t_order_0。配置时默认各个分片数据库的表结构均相同，直接配置逻辑表和真实表对应关系即可。

ShardingColumn

分片字段。用于将数据库(表)水平拆分的关键字段。SQL 中如果无分片字段，将执行全路由，性能较差。Sharding-JDBC 支持多分片字段。

ShardingAlgorithm

分片算法。Sharding-JDBC 通过分片算法将数据分片，支持通过等号、BETWEEN 和 IN 分片。分片算法目前需要业务方开发者自行实现，可实现的灵活度非常高。未来 Sharding-JDBC 也将会实现常用分片算法，如 range，hash 和 tag 等。

2 SpringBoot 整合 Sharding-Jdbc 分为两种方式

数据库表结构

创建 test 数据库：

CREATE TABLE `t_order_0` (
  `order_id` bigint(20) NOT NULL,
  `user_id` bigint(20) NOT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;


CREATE TABLE `t_order_1` (
  `order_id` bigint(20) NOT NULL,
  `user_id` bigint(20) NOT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

2.1 方式一：原生配置方式，自己需要实现接口

  1. 分库算法 类需要实现 SingleKeyDatabaseShardingAlgorithm<T> 接口
  2. 分表算法 类需要实现 SingleKeyTableShardingAlgorithm<T> 接口

Ⅰ 依赖

<?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.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.snow</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</name>
    <description>Demo project for Spring Boot</description>

    <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.23</version>
        </dependency>
        <!-- 引入sharding-jdbc依赖 -->
        <dependency>
            <groupId>io.shardingjdbc</groupId>
            <artifactId>sharding-jdbc-core</artifactId>
            <version>2.0.3</version>
        </dependency>
        <dependency>
            <groupId>com.dangdang</groupId>
            <artifactId>sharding-jdbc-self-id-generator</artifactId>
            <version>1.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Ⅱ 启动项

package com.snow;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow
 * @Description : 启动项
 * @date ：2020/4/8 22:25
 */
@SpringBootApplication
@EnableJpaRepositories("com.snow.repository")
public class App {

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }

}

Ⅲ application.yml

spring:
  application:
    name: app-snow-mysql
  jdbc:
    db0:
      className: com.mysql.jdbc.Driver
      url: jdbc:mysql://192.168.153.101:3306/%s?characterEncoding=utf-8&serverTimezone=GMT
      username: root
      password: 123456
  jpa:
    database: mysql
    show-sql: true
    hibernate:
      ## 自己建表
      ddl-auto: none

Ⅳ 实体类

package com.snow.entity;

import lombok.Data;
import lombok.ToString;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.entity
 * @Description : User 实体类
 * @date ：2020/4/8 23:13
 */
@Data
@ToString
@Entity
@Table(name = "t_order")
public class Order {

    /**
     * 订单ID
     */
    @Id
    private Long orderId;

    /**
     * 用户ID
     */
    private Long userId;
}

Ⅴ OrderRepository

package com.snow.repository;

import com.snow.entity.Order;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

import java.util.List;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.repository
 * @Description : OrderRepository
 * @date ：2020/4/9 21:10
 */
public interface OrderRepository extends CrudRepository<Order, Long> {

    @Query(value = "SELECT order_id, user_id FROM t_order WHERE order_id IN (?1);", nativeQuery = true)
    public List<Order> findExpiredOrderState(List<String> bpIds);

    @Query(value = "SELECT order_id, user_id FROM t_order WHERE user_id=:userId ", nativeQuery = true)
    public List<Order> findByUserId(@Param("userId") Long userId);

}

Ⅵ OrderController

package com.snow.controller;

import com.snow.entity.Order;
import com.snow.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.controller
 * @Description : OrderController
 * @date ：2020/4/8 22:25
 */
@RestController
public class OrderController {

    @Autowired
    private OrderRepository orderRepository;

    // 查询所有的订单信息
    @RequestMapping("/getOrderAll")
    public List<Order> getOrderAll() {
        List<Order> listOrder = (List<Order>) orderRepository.findAll();
        System.out.println("总数：" + listOrder.size());
        return listOrder;
    }

    @RequestMapping("/findIdByOrder")
    public Optional<Order> findIdByOrder(Long id) {
        return orderRepository.findById(id);
    }

    @RequestMapping("/findIdByUserId")
    public List<Order> findIdByUserId(Long userId) {
        return orderRepository.findByUserId(userId);
    }

    // 使用in条件查询
    @RequestMapping("/inOrder")
    public List<Order> inOrder() {
        List<String> ids = new ArrayList<>();
        ids.add("2");
        ids.add("3");
        ids.add("4");
        ids.add("5");
        return orderRepository.findExpiredOrderState(ids);

    }

    // 增加
    @RequestMapping("/inserOrder")
    public String inserOrder(Order order) {
        for (int i = 0; i < 100; i++) {
            Order order1 = new Order();
            order1.setOrderId((long) i);
            order1.setUserId((long) i);
            // 根据userid进行分片存放
            orderRepository.save(order1);
        }
        return "success";
    }

}

① 单库分表算法

分表算法类需要实现 SingleKeyTableShardingAlgorithm<T> 接口

Ⅰ DataSourceConfig

package com.snow.config;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSource;
import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.id.generator.IdGenerator;
import com.dangdang.ddframe.rdb.sharding.id.generator.self.CommonSelfIdGenerator;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.config
 * @Description : 数据源相关配置信息
 * @date ：2020/4/9 21:46
 */
@Configuration
public class DataSourceConfig {

	@Value("${spring.jdbc.db0.className}")
	private String className;
	@Value("${spring.jdbc.db0.url}")
	private String url;
	@Value("${spring.jdbc.db0.username}")
	private String username;
	@Value("${spring.jdbc.db0.password}")
	private String password;

	// 配置自动增长的策略
	@Bean
	public IdGenerator getIdGenerator() {
		return new CommonSelfIdGenerator();
	}

	// 创建数据源
	@Bean
	public DataSource getDataSource() {
		return buildDataSource();
	}

	private DataSource buildDataSource() {
		// 1.设置分库映射
		Map<String, DataSource> dataSourceMap = new HashMap<>(2);
		dataSourceMap.put("ds_0", createDataSource("ds_0"));
		// 设置默认db为ds_0，也就是为那些没有配置分库分表策略的指定的默认库
		// 如果只有一个库，也就是不需要分库的话，map里只放一个映射就行了，只有一个库时不需要指定默认库，
		// 但2个及以上时必须指定默认库，否则那些没有配置策略的表将无法操作数据
		DataSourceRule rule = new DataSourceRule(dataSourceMap, "ds_0");
		// 2.设置分表映射，将t_order_0和t_order_1两个实际的表映射到t_order逻辑表
		TableRule orderTableRule = TableRule.builder("t_order")
				.actualTables(Arrays.asList("t_order_0", "t_order_1"))
				.dataSourceRule(rule).build();
		// 3.具体的分库分表策略
		ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(rule)
				.tableRules(Arrays.asList(orderTableRule))
				// 根据userid 进行分库策略
				.tableShardingStrategy(new TableShardingStrategy("user_id", new TableShardingAlgorithm()))
				.build();
		// 创建数据源
		DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule);
		return dataSource;
	}

	private DataSource createDataSource(String dataSourceName) {
		// 使用druid连接数据库
		DruidDataSource druidDataSource = new DruidDataSource();
		druidDataSource.setDriverClassName(className);
		druidDataSource.setUrl(String.format(url, dataSourceName));
		druidDataSource.setUsername(username);
		druidDataSource.setPassword(password);
		return druidDataSource;
	}
}

Ⅱ TableShardingAlgorithm

package com.snow.config;

import java.util.Collection;

import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.config
 * @Description : 分表策略
 * @date ：2020/4/9 21:54
 */
public class TableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {

    // sql 中关键字 匹配符为 =的时候，表的路由函数
    @Override
    public String doEqualSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) {
        for (String tableName : availableTargetNames) {
            if (tableName.endsWith(shardingValue.getValue() % 2 + "")) {
                return tableName;
            }
        }
        throw new IllegalArgumentException();
    }

    @Override
    public Collection<String> doInSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) {
        return null;
    }

    @Override
    public Collection<String> doBetweenSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) {
        return null;
    }

}

测试

启动项目，浏览器访问：http://127.0.0.1:8080/inserOrder

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

浏览器访问：http://127.0.0.1:8080/getOrderAll

在这里插入图片描述

② 多库分表算法

数据库环境准备

CREATE TABLE `t_order` (
  `order_id` bigint(20) NOT NULL,
  `user_id` bigint(20) NOT NULL,
  PRIMARY KEY (`order_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

新建两个数据库，下面均创建 t_order 表：

在这里插入图片描述

Ⅰ 创建多库分表配置文件

package com.snow.config;

import java.util.Collection;

import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.config
 * @Description : 多库分表策略配置
 * @date ：2020/4/9 22:25
 */
public class DatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> {

	// 考虑表的数据存放在那个库里面
	@Override
	public String doEqualSharding(Collection<String> databases, ShardingValue<Long> shardingValue) {
		for (String databaseName : databases) {
			if (databaseName.endsWith(shardingValue.getValue() % 2 + "")) {
				return databaseName;
			}
		}
		throw new IllegalArgumentException();
	}

	@Override
	public Collection<String> doInSharding(Collection<String> availableTargetNames, ShardingValue<Long> shardingValue) {

		return null;
	}

	@Override
	public Collection<String> doBetweenSharding(Collection<String> availableTargetNames,
			ShardingValue<Long> shardingValue) {

		return null;
	}

}

Ⅱ 修改 DataSourceConfig

package com.snow.config;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import com.alibaba.druid.pool.DruidDataSource;
import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.id.generator.IdGenerator;
import com.dangdang.ddframe.rdb.sharding.id.generator.self.CommonSelfIdGenerator;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.config
 * @Description : 数据源相关配置信息
 * @date ：2020/4/9 21:46
 */
@Configuration
public class DataSourceConfig {

	@Value("${spring.jdbc.db0.className}")
	private String className;
	@Value("${spring.jdbc.db0.url}")
	private String url;
	@Value("${spring.jdbc.db0.username}")
	private String username;
	@Value("${spring.jdbc.db0.password}")
	private String password;

	// 配置自动增长的策略
	@Bean
	public IdGenerator getIdGenerator() {
		return new CommonSelfIdGenerator();
	}

	// 创建数据源
	@Bean
	public DataSource getDataSource() {
		return buildDataSource();
	}

	private DataSource buildDataSource() {
		// 1.设置分库映射
		Map<String, DataSource> dataSourceMap = new HashMap<>(2);
		dataSourceMap.put("ds_0", createDataSource("ds_0"));
		dataSourceMap.put("ds_1", createDataSource("ds_1"));
		// 设置默认db为ds_0，也就是为那些没有配置分库分表策略的指定的默认库
		// 如果只有一个库，也就是不需要分库的话，map里只放一个映射就行了，只有一个库时不需要指定默认库，
		// 但2个及以上时必须指定默认库，否则那些没有配置策略的表将无法操作数据
		DataSourceRule rule = new DataSourceRule(dataSourceMap, "ds_0");
		// 2.设置分表映射，将t_order_0和t_order_1两个实际的表映射到t_order逻辑表
		TableRule orderTableRule = TableRule.builder("t_order")
//				.actualTables(Arrays.asList("t_order_0", "t_order_1"))
				.dataSourceRule(rule).build();
		// 3.具体的分库分表策略
		ShardingRule shardingRule = ShardingRule.builder().dataSourceRule(rule)
				.tableRules(Arrays.asList(orderTableRule))
				// 根据userid 进行分库策略
//				.tableShardingStrategy(new TableShardingStrategy("user_id", new TableShardingAlgorithm()))
				.databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new DatabaseShardingAlgorithm()))
				.build();
		// 创建数据源
		DataSource dataSource = ShardingDataSourceFactory.createDataSource(shardingRule);
		return dataSource;
	}

	private DataSource createDataSource(String dataSourceName) {
		// 使用druid连接数据库
		DruidDataSource druidDataSource = new DruidDataSource();
		druidDataSource.setDriverClassName(className);
		druidDataSource.setUrl(String.format(url, dataSourceName));
		druidDataSource.setUsername(username);
		druidDataSource.setPassword(password);
		return druidDataSource;
	}
}

在这里插入图片描述

测试

启动项目，浏览器访问：http://127.0.0.1:8080/inserOrder

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

浏览器访问：http://127.0.0.1:8080/getOrderAll

在这里插入图片描述

2.2 方式二：SpringBoot 集成

Ⅰ 依赖

<?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.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.snow</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</name>
    <description>Demo project for Spring Boot</description>

    <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <!-- 引入spring-boot整合sharding-jdbc依赖 -->
        <dependency>
            <groupId>io.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>3.0.0.M3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Ⅱ 配置文件

###springjpa配置
spring:
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: none
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
sharding:
  jdbc:
    ####ds1
    datasource:
      names: ds1
      ds1:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://192.168.153.101:3306/ds_1?characterEncoding=utf-8
        username: root
        password: 123456
    ####  分片配置
    config:
      sharding:
        tables:
          ####t_order表分表策略
          t_order:
            table-strategy:
              inline:
                #### 根据userid 进行分片
                sharding-column: user_id
                ####  ds_1.t_order_0 ds_1.t_order_1
                algorithm-expression: ds_1.t_order_$->{user_id % 2}
              ###分表的总数 0到1   t_order_0 t_order_1
            actual-data-nodes: ds1.t_order_$->{0..1}
        props:
          sql:
            ### 开启分片日志
            show: true

Ⅲ 启动项

package com.snow;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow
 * @Description : 启动项
 * @date ：2020/4/8 22:25
 */
@SpringBootApplication
@EnableJpaRepositories("com.snow.repository")
public class App {

    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }

}

Ⅳ 实体类

package com.snow.entity;

import lombok.Data;
import lombok.ToString;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.entity
 * @Description : User 实体类
 * @date ：2020/4/8 23:13
 */
@Data
@ToString
@Entity
@Table(name = "t_order")
public class Order {

    /**
     * 订单ID
     */
    @Id
    private Long orderId;

    /**
     * 用户ID
     */
    private Long userId;
}

Ⅴ OrderRepository

package com.snow.repository;

import com.snow.entity.Order;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

import java.util.List;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.repository
 * @Description : OrderRepository
 * @date ：2020/4/9 21:10
 */
public interface OrderRepository extends CrudRepository<Order, Long> {

    @Query(value = "SELECT order_id, user_id FROM t_order WHERE order_id IN (?1);", nativeQuery = true)
    public List<Order> findExpiredOrderState(List<String> bpIds);

    @Query(value = "SELECT order_id, user_id FROM t_order WHERE user_id=:userId ", nativeQuery = true)
    public List<Order> findByUserId(@Param("userId") Long userId);

}

Ⅵ OrderController

package com.snow.controller;

import com.snow.entity.Order;
import com.snow.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * @author ：yang-windows
 * @Title : springboot
 * @Package ：com.snow.controller
 * @Description : OrderController
 * @date ：2020/4/8 22:25
 */
@RestController
public class OrderController {

    @Autowired
    private OrderRepository orderRepository;

    // 查询所有的订单信息
    @RequestMapping("/getOrderAll")
    public List<Order> getOrderAll() {
        List<Order> listOrder = (List<Order>) orderRepository.findAll();
        System.out.println("总数：" + listOrder.size());
        return listOrder;
    }

    @RequestMapping("/findIdByOrder")
    public Optional<Order> findIdByOrder(Long id) {
        return orderRepository.findById(id);
    }

    @RequestMapping("/findIdByUserId")
    public List<Order> findIdByUserId(Long userId) {
        return orderRepository.findByUserId(userId);
    }

    // 使用in条件查询
    @RequestMapping("/inOrder")
    public List<Order> inOrder() {
        List<String> ids = new ArrayList<>();
        ids.add("2");
        ids.add("3");
        ids.add("4");
        ids.add("5");
        return orderRepository.findExpiredOrderState(ids);

    }

    // 增加
    @RequestMapping("/inserOrder")
    public String inserOrder(Order order) {
        for (int i = 0; i < 100; i++) {
            Order order1 = new Order();
            order1.setOrderId((long) i);
            order1.setUserId((long) i);
            // 根据userid进行分片存放
            orderRepository.save(order1);
        }
        return "success";
    }

}

3 Sharding-Jdbc日志分析与原理图

  1. Sharding-JDBC 中的路由结果是通过分片字段和分片方法来确定的，如果查询条件中有 id 字段的情况还好，查询将会落到某个具体的分片；
  2. 如果查询没有分片的字段，会向所有的 db 或者是表都会查询一遍，让后封装结果级给客户端。

Sharding-Jdbc 和 MyCat 查询原理大致相同

在这里插入图片描述

不知所起 一往而深
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springMvc Mybatis mysql 分库分表-shardingJdbc.zip
11-06
Spring MVC、MyBatis和MySQL是常见的Web开发框架与数据库系统，而ShardingJDBC则是阿里巴巴开源的一款分布式数据库中间件，用于实现数据库的分库分表。本项目结合了这些技术，旨在提供一种高效且可扩展的解决方案。 ...
java软件工程的成长之路（java学习路线）
小猪奋斗
10-31 854
第一阶段 JavaSE编程基础 DOS常用命令 安装JDK、设置环境变量 DOS系统编译、执行Java程序 Java的注释 标识符、标识符的命名规范 Java 关键字 Java的数据类型 变量的定义及初始化 Java的运算符 表达式 转义字符 运算符的优先级 类型转换 Java分支if...else 多重if、嵌套if Java switch Switch vs if Java循环 for、whi...
Mysql集群 ShardingSphere
努力学习，努力爱你！
08-08 529
mysql-mmm 的监管端会提供多个虚拟 IP（VIP），包括一个可写 VIP，多个可读 VIP，通过监管的管理，这些 IP 会绑定在可用 mysql 之上，当某一台 mysql 宕机时，监管会将 VIP迁移至其他 mysql。在MySQL故障切换过程中，MHA 能做到在 0~30 秒之内自动完成数据库的故障切换操作（以 2019 年的眼光来说太慢了），并且在进行故障切换的过程中，MHA 能在最大程度上保证数据的一致性，以达到真正意义上的高可用。server.yaml 文件。如有问题，欢迎指正！...
Mycat（一）入门概述
最新发布
爱喝星冰乐的博客
04-25 1630
mycat概述
第十一章 Mysql集群方案
weixin_40503364的博客
05-24 602
11.1 Mycat 11.2 sharding-jdbc 11.1 Mycat 性能很好的分库分表中间件 大数据集群，加强版mysql数据库，融合内存缓存，NoSql，HDFS大数据的新SQL服务器 应用场景 分库分表，读写分离，替代Hbase分析大数据，海量数据实时查询 Mycat工作原理 1 将订单表order表按照省分片 2 应用连接Mycat提交SQL 3 Mycat拦截 解析SQL，分片分析，路由，读写分离，缓存等一系列分析 然后orderBy，groupBy排序等合并结果集 架构
Mycat2.0搭建教程
weixin_39338423的博客
12-14 7520
Mycat2搭建实战
MySql集群(1)-读写分离
市民景先生
03-23 985
简单概括：创建多个数据库，每个数据库只做单一功能，分别“读”操作或者“写“操作，并且通过日志进行同步数据操作。详细原理：1.主库负责处理事务的增删改操作，从库负责查询操作。能够有效避免数据更新的行锁，使得整个系统的查询得到极大的改善。2.读写分离是根据SQL语义的分析，将读操作和写操作分别路由至主库与从库。3.通过一主多仆的配置配置方式，将查询请求均匀的分散到数据副本，能够近一步提升系统的处理能力。4.使用多主多仆的方式，更能提高吞吐量和。
springboot整合sharding-jdbc完整代码
05-14
SpringBoot整合Sharding-JDBC是将Sharding-JDBC这一分布式数据库中间件与SpringBoot框架结合，以实现数据分片、读写分离等高级数据库管理功能。这个完整的代码示例覆盖了Sharding-JDBC的主要技术点，使开发者可以...
sharding-jdbc.rar
09-23
**描述：**该压缩包内容主要涉及使用Sharding-JDBC技术在MySQL环境中实现数据库的分库分表和读写分离。分库分表是一种常见的数据库扩展策略，用于应对大数据量场景下的性能挑战。通过将单一的大表分解为多个小表，...
mysql分库分表-apache-shardingsphere.zip
11-06
MySQL的分库分表是大型分布式系统中解决数据存储与查询性能问题的一种常见策略，而Apache ShardingSphere作为一款开源的分布式数据库解决方案，为实现这一策略提供了强大的支持。ShardingSphere是一个由Apache软件...
基于mybatis-plus+sharding+mysql的分库分表项目源码.zip
02-03
此外，MySQL的分区功能也可以辅助分库分表，但Sharding-JDBC通常会提供更高级的分片策略和管理。 **项目结构与实现** "mybatis-plus-dynamic-sharding-main"这个文件名可能代表项目的主模块，包含了Mybatis-Plus的...
MyCat2介绍以及部署和读写分离/分库分表（MyCat2.0）
征服Bug的博客
06-19 4048
官网：http://www.mycat.org.cn/​ mycat是数据库中间件它可以干什么？读写分离数据分片：垂直拆分，水平拆分多数据源整合[ root@localhost ~ ] # cd /usr/local/mycat/conf/ [ root@localhost conf ] # ll 总用量 32 drwxr-xr-x 2 root root 36 6 月 28 2021 clusters。
MySQL_11_ShardingJDBC实现分库分表
毛毛的专栏
02-26 2395
文章目录一、前言二、关系型数据库层面的高并发优化2.1 MYSQL海量数据带来的性能问题2.2 分片策略2.3 分布式ID2.3.1 定义全局表2.3.2 UUID2.3.3 雪花算法2.3 常见分库分表策略2.4 分库分表实战2.5 分库分表带来的问题三、Sharding-JDBC分库分表（uuid 雪花算法 SPI机制）四、ShardingSphere读写分离和分布式事务（理论+实战）4.1 读写分离4.2 分布式事务2.2 详解分库分表2.3 常见分库分表策略2.4 分库分表实战2.5 分库分表带来的
MySQL 之分库分表技术ShardingJDBC
const_
02-10 392
参考： https://shardingsphere.apache.org/document/current/cn/overview/ https://www.jianshu.com/p/52ccdb7d5683 https://mp.weixin.qq.com/s/M0e5u8V_c2sv6aYJHl0Y6Q https://zhuanlan.zhihu.com/p/41705760 ...
MySQL从入门到精通【实践篇】之使用Sharding-JDBC 分库分表详解
日拱一卒无有尽，功不唐捐终入海
09-06 688
Sharding-JDBC 是一款开源的分布式数据库中间件，主要目标是充分利用数据库的水平扩展能力，尽可能地避免改变已有的应用程序代码，简化分布式系统的开发难度。本文主要是使用sharding-jdbc 实现分库分表 以及各种分库分表策略实战验证。在学习本文之前建议 先看下我之前写的两篇文章《MySQL从入门到精通【进阶篇】MySQL分库分表详解》《MySQL从入门到精通【进阶篇】MySQL的读写分离详解》分库分表是一种常见的数据库扩展策略，它通过将数据分散到多个数据库或表中，来提高系统的性能和可扩展性。
Sharding-jdbc分库分表
Lyzxii
07-30 5944
引入 不断增长的业务数据会对MySQL数据库的存储和访问造成极大的性能影响，由于单台服务器的资源（CPU、磁盘、内存等）总是有限的，所以单台数据库所能承载的数据量、数据处理能力都将遭遇瓶颈。不论是获取连接还是插入或查询都会有极大的性能问题。 MySQL大数据量造成的性能瓶颈解决方案： 从SQL入手 加入索引 -> 缓存 -> 主从复制/读写分离 使用缓存，减少对数据库的同步访问 减少MySQL使用，可以使用HBase、polarDB、TiDB等分布式存储，ES查询 分库分表 拓展
MySQL第十二讲：ShardingJDBC详解
Jet_qi的博客
09-19 685
互联网业务兴起之后，海量用户加上海量数据的特点，单个数据库服务器已经难以满足业务需要，必须考虑数据库集群的方式来提升性能。高性能数据库集群的`第一种方式是“读写分离”`，`第二种方式是“数据库分片”`。
基于MyCat2.0实现MySQL分库分表方案
qq_25409421的博客
01-05 1506
虽然说现在市场上出现了很多类型的数据库，比如MongoDB、时序数据库InfluxDB、内存数据库Redis等等，但是关系型数据库仍然是不可替代的，开源关系型数据库MySQL更是大受欢迎；在高并发场景中，MySQL基于主从架构实现的一主多从，多主多从部署方式，多个服务器共同分摊压力，解决了单机性能问题，实现了数据库的高可用，但是对于单表、大表的读写性能问题，只依赖MySQL本身提供的机制并不能解决；本文就介绍下基于第三方MyCat中间件实现MySQL读写分离以及分库分表的方案。
Sharding-JDBC分库分表详解：从概念到配置
"4-Sharding-JDBC分库分表4.1分库分表概念" Sharding-JDBC 是一个轻量级的Java框架，用于解决大数据量场景下的数据库分库分表问题。它允许开发者在不修改现有业务代码的情况下，通过配置实现数据的分布式存储。在分...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不知所起 一往而深

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值