ShardingSphereJDBC分库分表Demo【附源码】

最新推荐文章于 2024-09-23 17:45:46 发布
最新推荐文章于 2024-09-23 17:45:46 发布
阅读量1.2k 收藏 8
点赞数 3
分类专栏： 数据库专题 文章标签： 数据库 分布式 mysql java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43885975/article/details/118637000
版权

数据库相关知识脉络图

目录

数据库相关知识脉络图

ShardingSphere简介

什么情况下考虑分库分表呢？

ShardingSphere JDBC基本概念解释

ShardingSphere JDBC使用

demo地址github

经典三步：

demo介绍：

单库分表

分库分表-inline模式-普通不支持范围查询

 分库分表-standard模式-范围查询

 分库分表-complex模式-混合字段范围查询

 分库分表-hint模式-指定数据库/表

ShardingSphere简介

官网地址

ShardingSphere是一套开源的分布式数据库解决方案组成的生态圈，包含：

  • ShardingSphere JDBC
    • 核心功能：分库分表 & 读写分离
    • 引入进我们程序中，提供api去操作分库分表的jar包。
    • 任意jdbc型数据库都可以使用。
    • 侵入性强，也灵活。
  • ShardingSphere Proxy
    • 隔离在我们程序之外的应用，提供操作分库分表功能。
    • 仅供MySQL，PostgreSQL使用。
    • 独立部署，需提前定义好与数据库交互的逻辑。
  • Sidecar（规划中）

什么情况下考虑分库分表呢？

  • 单表数据未来三年超过500万数据
  • 单表数据大小未来三年超过2G
  • 根据实际业务

ShardingSphere JDBC基本概念解释

序号名词解释
1逻辑表把一类相同的表、相同增删改查逻辑的表，抽象成一个“逻辑表”，不真实存在。
2真实表真实存在的表
3广播表所有库里这个表的逻辑字段使用逻辑都相同的表，例如数据字典表要统一。
4绑定表像是主表和子表的关系，不可分割，尽量保持一致的表。
5分片键例如插入数据时候，根据哪个字段来路由数据进入到各个库表？那个字段就是分片键
6分片算法根据什么算法去路由？取摩运算？直接指定库名？
7分片策略= 分片键 + 分片算法

ShardingSphere JDBC使用

demo地址github

https://github.com/lxnxxwl/shardingspheredemo.git

经典三步：

1、 建表：例如mall_order_1 \ mall_order_2..这样尾数有关联易表达的。

2、 引入sharding sphere jdbc的依赖

3、 编写配置文件

demo介绍：

  1. maven聚合项目：common包中实体类，其他包为不同配置的分库分表demo依赖common。
  2. 使用mybatis plus 进行操作数据库（测试用例简单）。mapper在各个demo包中。
  3. 测试例子在各个demo的test包中。
  4. 配置文件采用.properties文件配置。

单库分表

  • 首先要自己建表（真实表）：
    • 这里就是在一个数据库里建两张相同的表mall_order_1 \ mall_order_2。
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for mall_order_1
-- ----------------------------
DROP TABLE IF EXISTS `mall_order_1`;
CREATE TABLE `mall_order_1` (
  `id` bigint NOT NULL,
  `order_name` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

SET FOREIGN_KEY_CHECKS = 1;
  • 引入pom依赖。
    • springboot为例
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>

​​​​​​

  • 编写配置文件【单库分表】
#sharding jdbc 数据库 起名 m1
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://localhost:3306/test?characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
spring.shardingsphere.datasource.m1.username=root
spring.shardingsphere.datasource.m1.password=root

# 1.哪些节点？==哪几张表
spring.shardingsphere.sharding.tables.mall_order.actual-data-nodes=m1.mall_order_$->{1..2}
# 2.主键是哪一列？
spring.shardingsphere.sharding.tables.mall_order.key-generator.column=cid
# 3.主键生成策略是什么？ 可自定义，此处采用已集成的雪花算法
spring.shardingsphere.sharding.tables.mall_order.key-generator.type=SNOWFLAKE
spring.shardingsphere.sharding.tables.mall_order.key-generator.props.worker.id=1
# 4.分片键：inline模式下按id分表
spring.shardingsphere.sharding.tables.mall_order.table-strategy.inline.sharding-column=cid
# 5.分片算法：ID取摩
spring.shardingsphere.sharding.tables.mall_order.table-strategy.inline.algorithm-expression=mall_order_$->{cid%2+1}

spring.shardingsphere.props.sql.show = true
spring.main.allow-bean-definition-overriding=true
  • mapper：     
public interface MallOrderMapper extends BaseMapper<MallOrder> {
}
  • 测试类
@RunWith(SpringRunner.class)
@SpringBootTest
public class OnedbApplicationTests {

    @Resource
    private MallOrderMapper orderMapper;

    @Test
    public void addOrder(){
        for(int i = 0 ; i < 10 ; i ++){
            MallOrder order = new MallOrder();
            order.setOrderName("第"+i+"个订单");
            orderMapper.insert(order);
        }
    }

}

 

分库分表-inline模式-普通不支持范围查询

  • 首先要自己建表（真实表）：
    • 这里就是在test数据库里建两张相同的表mall_order_1 \ mall_order_2。在test2中建两张相同的表mall_order_1 \ mall_order_2 。建表语句同上。
  • 依赖同上：放在父工程pom里即可
  • 配置文件：
# 应用名称
spring.application.name=twodb
#配置数据库别名:两个数据库
spring.shardingsphere.datasource.names=db1,db2
#第一个数据库 库名：test
spring.shardingsphere.datasource.db1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db1.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db1.username=root
spring.shardingsphere.datasource.db1.password=root
#第二个数据库 库名：test2
spring.shardingsphere.datasource.db2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db2.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db2.username=root
spring.shardingsphere.datasource.db2.password=root
#真实表有哪些
spring.shardingsphere.sharding.tables.mall_order.actual-data-nodes=db$->{1..2}.mall_order_$->{1..2}
#使用雪花算法自动生成id/主键生成策略
spring.shardingsphere.sharding.tables.mall_order.key-generator.column=id
spring.shardingsphere.sharding.tables.mall_order.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.mall_order.key-generator.props.worker.id=1
#分片（分表：table-strategy）策略
#分片键ID
spring.shardingsphere.sharding.tables.mall_order.table-strategy.inline.sharding-column=id
#分片算法：根据ID是奇数->mall_order_1;是偶数->mall_order_2
spring.shardingsphere.sharding.tables.mall_order.table-strategy.inline.algorithm-expression=mall_order_$->{id%2+1}
#分片（分库：database-strategy）策略
#分片键ID
spring.shardingsphere.sharding.tables.mall_order.database-strategy.inline.sharding-column=id
#分片算法：根据ID是奇数->db1 = test;是偶数->db2 = test2
spring.shardingsphere.sharding.tables.mall_order.database-strategy.inline.algorithm-expression=db$->{id%2+1}
#显示sql语句
spring.shardingsphere.props.sql.show = true
spring.main.allow-bean-definition-overriding=true
  • mapper同上
  • 测试用例
@SpringBootTest
@RunWith(SpringRunner.class)
public class TwodbApplicationTests {
    @Resource
    private MallOrderMapper orderMapper;

    /**
     * 向两个数据库四张表插入数据
     */
    @Test
    public void addOrderToDB() {
        for(int i = 0 ; i < 10 ; i ++){
            MallOrder order = new MallOrder();
            order.setOrderName("分库后的第"+i+"个订单");
            orderMapper.insert(order);
        }
    }

    /**
     * 按id查找某条数据
     * Logic  SQL: SELECT  id,order_name  FROM mall_order WHERE (id = ?)
     * Actual SQL: db2 ::: SELECT  id,order_name  FROM mall_order_2
     * shardingsphere已经按策略优化查询sql，仅在id可能存在的test2库的mall_order_2这张表中进行一次查询
     */
    @Test
    public void queryDataById(){
        QueryWrapper<MallOrder> wrapper = new QueryWrapper<>();
        wrapper.eq("id",1415550634731560961L);
        MallOrder mallOrder = orderMapper.selectOne(wrapper);
        System.out.println(mallOrder);
    }

    /**
     * 范围查询：ID在xxx～zzz之间的所有数据查询
     * Inline strategy cannot support this type sharding:RangeRouteValue
     * 使用inline模式是不支持范围查询的
     */
    @Test
    public void queryDataByRang(){
        QueryWrapper<MallOrder> wrapper = new QueryWrapper<>();
        wrapper.between("id",1415550634731560961L,1415550634748338178L);
        List<MallOrder> mallOrders = orderMapper.selectList(wrapper);
        mallOrders.forEach(mallOrder -> System.out.println(mallOrder));
    }

    /**
     * 按id排序查询出所有数据
     * Logic  SQL: SELECT  id,order_name  FROM mall_order
     * Actual SQL: db1 ::: SELECT  id,order_name  FROM mall_order_1
     * Actual SQL: db1 ::: SELECT  id,order_name  FROM mall_order_2
     * Actual SQL: db2 ::: SELECT  id,order_name  FROM mall_order_1
     * Actual SQL: db2 ::: SELECT  id,order_name  FROM mall_order_2
     * 两个库的四张表全部查询一遍（有待优化）
     */
    @Test
    public void queryDataBySort(){
        QueryWrapper<MallOrder> wrapper = new QueryWrapper<>();
        wrapper.orderByDesc("id");
        List<MallOrder> mallOrders = orderMapper.selectList(wrapper);
        mallOrders.forEach(mallOrder -> System.out.println(mallOrder));
    }

}

注：inline模式不支持范围查询，使用standard自定义规则后实现范围查询

 分库分表-standard模式-范围查询

  • 相同的sql和依赖和mapper省略
  • 配置文件
# 应用名称
spring.application.name=twodb-standard
#配置数据库别名:两个数据库
spring.shardingsphere.datasource.names=db1,db2
#第一个数据库 库名：test
spring.shardingsphere.datasource.db1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db1.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db1.username=root
spring.shardingsphere.datasource.db1.password=root
#第二个数据库 库名：test2
spring.shardingsphere.datasource.db2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db2.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db2.username=root
spring.shardingsphere.datasource.db2.password=root
#真实表有哪些
spring.shardingsphere.sharding.tables.mall_order.actual-data-nodes=db$->{1..2}.mall_order_$->{1..2}
#使用雪花算法自动生成id/主键生成策略
spring.shardingsphere.sharding.tables.mall_order.key-generator.column=id
spring.shardingsphere.sharding.tables.mall_order.key-generator.type=SNOWFLAKE
#spring.shardingsphere.sharding.tables.mall_order.key-generator.props.worker.id=1


#分片（分表：table-strategy）策略
#分片键ID
spring.shardingsphere.sharding.tables.mall_order.table-strategy.standard.sharding-column=id
#分表算法（需自己实现）：
spring.shardingsphere.sharding.tables.mall_order.table-strategy.standard.precise-algorithm-class-name=com.lixiunan.twodbstandard.algorithm.MyTablePreciseAlgorithm
#表范围查询算法（需自己实现）：
spring.shardingsphere.sharding.tables.mall_order.table-strategy.standard.range-algorithm-class-name=com.lixiunan.twodbstandard.algorithm.MyTableRangeAlgorithm


#分片（分库：database-strategy）策略
#分片键ID
spring.shardingsphere.sharding.tables.mall_order.database-strategy.standard.sharding-column=id
#分库算法（需自己实现）：
spring.shardingsphere.sharding.tables.mall_order.database-strategy.standard.precise-algorithm-class-name=com.lixiunan.twodbstandard.algorithm.MyDBPreciseAlgorithm
#库范围查找算法（需自己实现）：
spring.shardingsphere.sharding.tables.mall_order.database-strategy.standard.range-algorithm-class-name=com.lixiunan.twodbstandard.algorithm.MyDBRangeAlgorithm
#显示sql语句
spring.shardingsphere.props.sql.show = true
spring.main.allow-bean-definition-overriding=true
  •  自己写实现类：自己实现分库分表的规则，自己实现范围查询的方法等等
  • 自己实现分库策略
/**
 * @Description : TODO 自己实现分库策略
 * @Author : lixiunan
 * @Date : 2021/7/15
 **/
public class MyDBPreciseAlgorithm implements PreciseShardingAlgorithm<Long> {
    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> shardingValue) {
        //把雪花算法生成的id取出
        Long id = shardingValue.getValue();
        //对id取摩得到的数字
        BigInteger key =
                BigInteger.valueOf(id).mod(new BigInteger("2")).add(new BigInteger("1"));
        //生成真实表的表名
        String dbName = "db" + key;
        if(availableTargetNames.contains(dbName)){
            return dbName;
        }
        throw new UnsupportedOperationException("找不到数据库");
    }
}
  • 自己实现分表策略
/**
 * @Description :
 * TODO 自己定制insert时按照什么算法去分发到不同表中：分片键的类型Lone传入泛型，确保此算法在范围查找时使用是有效的
 * @Author : lixiunan
 * @Date : 2021/7/15
 **/
public class MyTablePreciseAlgorithm implements PreciseShardingAlgorithm<Long> {
    @Override
    public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> shardingValue) {
        //把雪花算法生成的id取出
        Long id = shardingValue.getValue();
        //对id取摩得到表名的数字
        BigInteger key =
                BigInteger.valueOf(id).mod(new BigInteger("2")).add(new BigInteger("1"));
        //生成真实表的表名
        String tableName = shardingValue.getLogicTableName() + "_" + key;
        if(availableTargetNames.contains(tableName)){
            return tableName;
        }else {
            throw new UnsupportedOperationException("找不到表名");
        }
    }
}
  • 自己实现范围查找（库 + 表）
/**
 * @Description : TODO 分为查找时分库策略定制
 * @Author : lixiunan
 * @Date : 2021/7/15
 **/
public class MyDBRangeAlgorithm implements RangeShardingAlgorithm<Long> {
    @Override
    public Collection<String> doSharding(
            Collection<String> availableTargetNames, RangeShardingValue<Long> shardingValue) {
        //范围查询库
        return Arrays.asList("db1","db2");
    }
}
/**
 * @Description : TODO 定制范围查找时分表查找策略
 * @Author : lixiunan
 * @Date : 2021/7/15
 **/
public class MyTableRangeAlgorithm implements RangeShardingAlgorithm<Long> {
    @Override
    public Collection<String> doSharding(
            Collection<String> availableTargetNames, RangeShardingValue<Long> shardingValue) {
        String logicTableName = shardingValue.getLogicTableName();
        //范围查询表
        return Arrays.asList(logicTableName+"_1",logicTableName+"_2");
    }
}
  •  测试用例
@SpringBootTest
@RunWith(SpringRunner.class)
public class TwodbStandardApplicationTests {

    @Resource
    private MallOrderMapper orderMapper;
    /**
     * 向两个数据库四张表插入数据
     */
    @Test
    public void addOrderToDB() {
        for(int i = 0 ; i < 10 ; i ++){
            MallOrder order = new MallOrder();
            order.setOrderName("standard中第"+i+"个订单");
            orderMapper.insert(order);
        }
    }

    /**
     * 范围查询：
     * Logic SQL: SELECT  id,order_name  FROM mall_order WHERE (id BETWEEN ? AND ?)
     * Actual SQL: db1 ::: SELECT  id,order_name  FROM mall_order_1 WHERE (id BETWEEN ? AND ?) ::: [1415550634731560961, 1415550634748338178]
     * Actual SQL: db1 ::: SELECT  id,order_name  FROM mall_order_2 WHERE (id BETWEEN ? AND ?) ::: [1415550634731560961, 1415550634748338178]
     * Actual SQL: db2 ::: SELECT  id,order_name  FROM mall_order_1 WHERE (id BETWEEN ? AND ?) ::: [1415550634731560961, 1415550634748338178]
     * Actual SQL: db2 ::: SELECT  id,order_name  FROM mall_order_2 WHERE (id BETWEEN ? AND ?) ::: [1415550634731560961, 1415550634748338178]
     *
     *
     * 使用inline模式是不支持范围查询的，standard可以按照算法提供的方法或表名库名进行范围查找
     */
    @Test
    public void queryDataByRang(){
        QueryWrapper<MallOrder> wrapper = new QueryWrapper<>();
        wrapper.between("id",1415550634731560961L,1415550634748338178L);
        List<MallOrder> mallOrders = orderMapper.selectList(wrapper);
        mallOrders.forEach(mallOrder -> System.out.println(mallOrder));
    }

}

 分库分表-complex模式-混合字段范围查询

  • 相同的sql和依赖和mapper省略
  • 配置文件
# 应用名称
spring.application.name=twodb-complex
#配置数据库别名:两个数据库
spring.shardingsphere.datasource.names=db1,db2
#第一个数据库 库名：test
spring.shardingsphere.datasource.db1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db1.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db1.username=root
spring.shardingsphere.datasource.db1.password=root
#第二个数据库 库名：test2
spring.shardingsphere.datasource.db2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db2.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db2.username=root
spring.shardingsphere.datasource.db2.password=root
#真实表有哪些
spring.shardingsphere.sharding.tables.product.actual-data-nodes=db$->{1..2}.product_$->{1..2}


#分片（分表：table-strategy）策略
#分片键ID:可以多个ID联合
spring.shardingsphere.sharding.tables.product.table-strategy.complex.sharding-columns=id,store_id
#分表算法（需自己实现）：
spring.shardingsphere.sharding.tables.product.table-strategy.complex.algorithm-class-name=com.lixiunan.twodbcomplex.algorithm.MyComplexTableAlgorithm

#分片（分库：database-strategy）策略
#分片键ID：#分片键ID：
spring.shardingsphere.sharding.tables.product.database-strategy.complex.sharding-columns=id,store_id
#分库算法（需自己实现）：
spring.shardingsphere.sharding.tables.product.database-strategy.complex.algorithm-class-name=com.lixiunan.twodbcomplex.algorithm.MyComplexDBAlgorithm
#显示sql语句
spring.shardingsphere.props.sql.show = true
spring.main.allow-bean-definition-overriding=true

自己实现存储&范围查找（库 + 表） 的策略

public class MyComplexDBAlgorithm implements ComplexKeysShardingAlgorithm<Long> {
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, ComplexKeysShardingValue<Long> shardingValue) {
        //获取店铺ID集合
        Collection<Long> storeIdCollection =
                shardingValue.getColumnNameAndShardingValuesMap().get("store_id");
        //创建新集合
        ArrayList<String> result = new ArrayList<String>();
        //策略为取摩尔
        for (Long storeId : storeIdCollection){
            BigInteger storeIdInteger = BigInteger.valueOf(storeId);
            BigInteger key =
                    (storeIdInteger.mod(new BigInteger("2"))).add(new BigInteger("1"));
            result.add("db"+key);
        }
        return result;
    }
}
public class MyComplexTableAlgorithm implements ComplexKeysShardingAlgorithm<Long> {
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, ComplexKeysShardingValue<Long> shardingValue) {
        //获取店铺ID集合
        Collection<Long> storeIdCollection =
                shardingValue.getColumnNameAndShardingValuesMap().get("store_id");
        //获取真实表前缀名称
        String logicTableName = shardingValue.getLogicTableName();
        //创建新集合
        ArrayList<String> result = new ArrayList<String>();
        //策略为取摩尔
        for (Long storeId : storeIdCollection){
            BigInteger storeIdInteger = BigInteger.valueOf(storeId);
            BigInteger key =
                    (storeIdInteger.mod(new BigInteger("2"))).add(new BigInteger("1"));
            result.add(logicTableName+"_"+key);
        }
        return result;
    }
}

 测试类——支持混合id范围条件查询

@RunWith(SpringRunner.class)
@SpringBootTest
public class TwodbComplexApplicationTests {
    @Resource
    private ProductMapper productMapper;
    @Resource
    private StoreMapper storeMapper;

    /**
     *添加数据
     */
    @Test
    public void add() {
        for(int i = 0 ; i < 10 ; i ++){
            Product product = new Product();
            Long idLong = Long.valueOf(202110L + i);
            product.setId(idLong);
            Long storeIdLong = Long.valueOf(676 + i);
            product.setStoreId(storeIdLong);
            product.setProductName("complex第"+i+"个商品");
            product.setProductStatus(((i % 2)+1)+"");
            productMapper.insert(product);
        }
    }

    /**
     * 缺少参数不能查询
     */
    @Test
    public void queryRange(){
        QueryWrapper<Product> wrapper = new QueryWrapper<>();
        wrapper.between("store_id",670L,680L);
        List<Product> products = productMapper.selectList(wrapper);
        products.forEach(product -> System.out.println(product));
    }

    /**
     * 支持（必须）混合ID复杂查询，如配置中的
     */
    @Test
    public void queryCourseComplex(){
        QueryWrapper<Product> wrapper = new QueryWrapper<>();
        wrapper.between("id",202100L,202114L);
        wrapper.eq("store_id",677L);
        List<Product> products = productMapper.selectList(wrapper);
        products.forEach(product -> System.out.println(product));
    }

}

 分库分表-hint模式-指定数据库/表

  • 相同的sql和依赖和mapper省略
  • 配置文件
# 应用名称
spring.application.name=twodb-hint
#配置数据库别名:两个数据库
spring.shardingsphere.datasource.names=db1,db2
#第一个数据库 库名：test
spring.shardingsphere.datasource.db1.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db1.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db1.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db1.username=root
spring.shardingsphere.datasource.db1.password=root
#第二个数据库 库名：test2
spring.shardingsphere.datasource.db2.type=com.alibaba.druid.pool.DruidDataSource
spring.shardingsphere.datasource.db2.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.db2.url=jdbc:mysql://localhost:3306/test2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
spring.shardingsphere.datasource.db2.username=root
spring.shardingsphere.datasource.db2.password=root
#真实表有哪些
spring.shardingsphere.sharding.tables.product.actual-data-nodes=db$->{1..2}.product_$->{1..2}
#使用雪花算法自动生成id/主键生成策略
spring.shardingsphere.sharding.tables.product.key-generator.column=id
spring.shardingsphere.sharding.tables.product.key-generator.type=SNOWFLAKE

#分片（分表：table-strategy）策略
#分片键ID:可以多个ID联合
#分表算法（需自己实现hint模式）：
spring.shardingsphere.sharding.tables.product.table-strategy.hint.algorithm-class-name=com.lixiunan.twodbhint.algorithm.MyHintTableAlgorithm
#分片（分库：database-strategy）策略
#分片键ID：#分片键ID：
#分库算法：不指定
#显示sql语句
spring.shardingsphere.props.sql.show = true
spring.main.allow-bean-definition-overriding=true

自己实现如何制定表/库

/**
 * @Description : TODO hint可向指定表/库中添加/获取数据
 * @Author : lixiunan
 * @Date : 2021/7/19
 **/
public class MyHintTableAlgorithm implements HintShardingAlgorithm<Long> {
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, HintShardingValue<Long> shardingValue) {
        String key =
                shardingValue.getLogicTableName() + "_" + shardingValue.getValues().toArray()[0];
        if(availableTargetNames.contains(key)){
            return Arrays.asList(key);
        }
        throw new UnsupportedOperationException("找不到表");
    }
}

 测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class TwodbHintApplicationTests {

    @Resource
    private ProductMapper productMapper;

    /**
     * 指定查询的表
     * SELECT  id,store_id,product_name,product_status  FROM product
     * Actual SQL: db1 ::: SELECT  id,store_id,product_name,product_status  FROM product_1
     * Actual SQL: db2 ::: SELECT  id,store_id,product_name,product_status  FROM product_1
     */
    @Test
    public void queryByHint1(){
        HintManager hintManager = HintManager.getInstance();
        hintManager.addTableShardingValue("product",1);
        List<Product> products = productMapper.selectList(null);
        products.forEach(product -> System.out.println(product));
        hintManager.close();
    }

    /**
     * Logic SQL: SELECT  id,store_id,product_name,product_status  FROM product
     * Actual SQL: db1 ::: SELECT  id,store_id,product_name,product_status  FROM product_2
     * Actual SQL: db2 ::: SELECT  id,store_id,product_name,product_status  FROM product_2
     */
    @Test
    public void queryByHint2(){
        HintManager hintManager = HintManager.getInstance();
        hintManager.addTableShardingValue("product",2);
        List<Product> products = productMapper.selectList(null);
        products.forEach(product -> System.out.println(product));
        hintManager.close();
    }

}

Java程序员调优
关注
专栏目录
shardingsphere 无痛-分库分表demo
qq_36978700的博客
03-28 1650
修改配置文件把策略inline 注释掉，打开下面的注释即可。再添加一个配置文件MyTablePreciseShardingAlgorithm/*** collection 对应分片库中所有分片表的集合* preciseShardingValue 为分片属性，其中 logicTableName 为逻辑表，columnName 分片健（字段），value 为从 SQL 中解析出的分片健的值} }测试也是正常的！！！！
sharding-jdbc之——分库分表实例完整源码
02-25
sharding-jdbc之——分库分表实例完整源码，详情请参见博文：http://blog.csdn.net/l1028386804/article/details/79368021
sharding jdbc分库分表快速入门demo
weixin_44588771的博客
11-06 210
sharding jdbc分库分表快速入门demo 建立数据库 ds0, ds1库中建立user_0,user_1,user_2表，部分DDL create database ds0; use database ds0; create table user_0 ( id bigint, user_name varchar(20), number bigint, primary key(id) ) maven依赖 org.springframework.boot spring-boot-starter-w
彻底掌握ShardingSphere-jdbc：实战指南与技巧解析
最新发布
m0_65038841的博客
09-23 946
分片算法和阿里开源的数据库中间件 cobar 路由算法非常类似的。假设现在需要将订单表平均拆分到 4 个分库 shard0 ，shard1 ，shard2 ，shard3。首先将 [0-1023] 平均分为 4 个区段：[0-255]，[256-511]，[512-767]，[768-1023]，然后对字符串（或子串，由用户自定义）做 hash， hash 结果对 1024 取模，最终得出的结果slot落入哪个区段，便路由到哪个分库。
数据库分库分表（四）shardingjdbc水平分表demo
w_t_y_y的博客
12-16 1672
一、代码示例： 数据库/表创建：system_config只有一张，t_user表进行分表，分别建了t_user_1和t_user_2表 CREATE TABLE `system_config` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `config_key` varchar(255) DEFAULT NULL, `cocnfig_value` varchar(255) DEFAULT NULL, `create_time.
Sharding-Sphere 3.X 与spring与mybatis集成（分库分表）demo
weixin_33906657的博客
05-28 526
最近在弄这个sharding-sphere，公司内部分库分表是在此业务代码上进行逻辑分库分表，但是这种总是不好，也调研了几款分库分表中间件、mycat、网易cetus、阿里DRDS、这几种就是背景强大，大公司经过大量的实战，成熟度很高，而框架sharding-sphere比较轻量级，最近比较火，它是以jar包形式提供服务，可以无缝连接ORM框架，并不需要额外的部署，不需要依赖，运维可以不需要改动，...
【shardingjdbc】sharding-jdbc分库分表入门demo及原理分析
孟秋与你的博客
11-14 745
由一个分库案例 引发的思考
springboot分库分表操作demo源码案例演示
07-23
一、简介 二、工程搭建 1、工程结构 2、依赖管理 三、配置详解 1、配置文件 2、配置原理 四、测试案例 1、主库操作 2、分库操作 3、综合查询 五、参考源码
基于分布式事务seata+分库分表shardingspherejdbc+nacos+dubbo项目源码.zip
02-05
基于分布式事务seata+分库分表shardingspherejdbc+nacos+dubbo项目源码.zip 1. 环境准备 - nacos: `sh ./docker/nacos/startup.sh` - seata-server - 导入配置: `sh ./docker/seata-server/conf/nacos-config.sh ...
分库分表ShardingSphere-ShardingJDBC源码解析
janyxe的博客
03-25 701
系列文章目录 MySQL分表分库基础 分库分表-ShardingSphere基础 分库分表-(ShardingSphere)ShardingJDBC数据分片实战1 分库分表-ShardingJDBC数据分片实战2 文章目录系列文章目录前言一、下载源码以及编译1 下载源码2 导入并编译源码二、深入源码解析1.源码入口2.创建数据源源码解析2.1 创建数据源源码入库2.2 初始化路由规则2.2.1 创建表路由规则2.2.1.1构建分表策略总结 前言 上一篇文章结合一个示例讲解ShardingJDBC的使
mycat对mysql数据库进行分库分表demo-mycat-demo-parent.zip
11-06
标题"mycat对mysql数据库进行分库分表demo-mycat-demo-parent.zip"揭示了本示例主要围绕MyCat这一中间件，用于MySQL数据库的分布式处理，特别是分库分表功能。MyCat是一个开源的分布式数据库系统，它能够将一个大型...
分库分表-ShardingSphere-ShardingJDBC
CallmeMaybe
06-30 373
分片和分区的区别 Sharding 分片 Partition分区 存储依赖 可跨越DB 可跨越物理机器 可跨越表空间，不能跨DB存储 数据划分 常见为时间、范围、面向服务等 范围、Hash、列表、混合分区等 存储方式 分布式 集中式 扩展性 Scale Out (水平扩展) Scale Up（垂直扩展） 可用性 无单点 存在单点（DB本身） 价格 低廉 适中（DAS）甚至昂贵（SAN） 应用场景 Web 2.0网站 多数传统应用 ShardingSphere v
数据库之互联网常用分库分表方案
weixin_30613343的博客
08-08 155
一、数据库瓶颈 不管是IO瓶颈，还是CPU瓶颈，最终都会导致数据库的活跃连接数增加，进而逼近甚至达到数据库可承载活跃连接数的阈值。在业务Service来看就是，可用数据库连接少甚至无连接可用。接下来就可以想象了吧（并发量、吞吐量、崩溃）。 1、IO瓶颈 第一种：磁盘读IO瓶颈，热点数据太多，数据库缓存放不下，每次查询时会产生大量的IO，降低查询速度 -> 分库和垂直分表。 ...
Sharding-JDBC——数据分片——分表（最全demo）
cxclll的博客
07-21 748
标准分片策略适用于单分片键，此策略支持和两个分片算法。其中是必选的，用于处理和IN的分片。是可选的，用于处理BETWEEN==、AND>=
大白话讲解分库分表框架ShardingJDBC-含DEMO
热门推荐
不是很懂
04-19 2万+
分库分表 — Shardingjdbc 分库分表：分库分表 为什么分表？ 肯定是因为需要 怎么进行分表？垂直分表和水平分表 什么是垂直分表？如果表过大，垂直分表就是按照业务角度将大列分为几个表，划分的原则一般是频繁变化的分为一个表，不频繁变化的，尤其大字段，如text和blob字段这种影响io性能的划分为另外一个表中，这样就实现了垂直分表。如下图： 什么是水平分表？就是将数据根据策略分到不同的表中，从而使数据均匀的分布在不同的数据库和表中，也是最常见的分表方式。如下就是将一个表分为四个表： 将ds库中的o
数据库分库分表
lihuayong的专栏
12-20 5576
一、 基本思想 Sharding的基本思想就要把一个数据库切分成多个部分放到不同的数据库(server)上，从而缓解单一数据库的性能问题。对于海量数据的数据库，如果是因为表多而数据多，这时候适合使用垂直切分，即把关系紧密（比如同一模块）的表切分出来放在一个服务器上。如果表并不多，但每张表的数据非常多，这时候适合水平切分，即把表的数据按某种规则（比如按ID散列）切分到多个数据库(server)上。
dynamic-datasource+shardingsphere-jdbc实现分库分表demo
03-22
博客 ...基于spring boot 2.7实现了dynamic-datasource+shardingsphere-jdbc+mybatis-plus技术栈的整合，可以动态切换数据源及对部分库表的分库分表。适用于老系统增加新的分库分表数据源。
分库分表ShardingSphere之ShardingJDBC
SunAcument的博客
02-16 1287
ShardingJDBC ShardingJDBC是用来做客户端分库分表的产品，而ShardingProxy是用来做服务端分库分表的产品。 shardingjdbc的核心功能是数据分片和读写分离，通过ShardingJDBC，应用可以透明的使用JDBC访问已经分库分表、读写分离的多个数据源，而不用关心数据源的数量以及数据如何分布。 核心概念 逻辑表：水平拆分的数据库的相同逻辑和数据结构表的总称 真实表：在分片的数据库中真实存在的物理表。 数据节点：数据分片的最小单元。由数据源名称和数据表组成
sharding-sphere之分库分表demo
XZLABC12345的专栏
08-28 1484
需要准备的环境： idea 2017.3月 jdk1.8 maven3.1.1 请提前将idea与Maven、jdk配置好，本次项目用的都是比较新的 涉及技术栈： springmvc spring4.3.18 mybatisplus3.0.5 sharding-sphere3.1.0 搭建demo步骤： 1、用IDEA新建一个MAVEN webapp项目， 点击next ...
分库分表中间件ShardingSphere的测试demo
weixin_46475802的博客
01-02 364
sharding-jdbc demo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Java程序员调优

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

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

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

打赏作者

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

抵扣说明：

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

余额充值