sharding-jdbc介绍及操作

最新推荐文章于 2024-03-06 10:02:38 发布
最新推荐文章于 2024-03-06 10:02:38 发布
阅读量804 收藏 2
点赞数
文章标签： mybatis java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengduan913/article/details/125629546
版权

文章目录

1. 介绍

Sharding-JDBC是ShardingSphere的第一个产品，也是ShardingSphere的前身。 它定位为轻量级Java框架，在Java的JDBC层提供的额外服务。它使用客户端直连数据库，以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。

  • 适用于任何基于JDBC的ORM框架，如：JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。
  • 支持任何第三方的数据库连接池，如：DBCP, C3P0, BoneCP, Druid, HikariCP等。
  • 支持任意实现JDBC规范的数据库。目前支持MySQL，Oracle，SQLServer，PostgreSQL以及任何遵循SQL92标准的数据库。

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.7.1</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.sharding.jdbc</groupId>
    <artifactId>shardingjdbc</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>shardingjdbc</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.23</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </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>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3. 水平分表

  1. 在node01（192.168.109.132）上创建sharding_sphere数据库
  2. 在数据库中创建两张表，orders_1和orders_2
CREATE TABLE `orders_1` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_type` int(11) DEFAULT NULL,
  `customer_id` int(11) DEFAULT NULL,
  `amount` decimal(10,2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

CREATE TABLE `orders_2` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_type` int(11) DEFAULT NULL,
  `customer_id` int(11) DEFAULT NULL,
  `amount` decimal(10,2) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

在这里插入图片描述

  1. 分片规则：如果订单编号是偶数添加到orders_1,如果是奇数添加到orders_2
  2. 创建配置文件
spring:
  shardingsphere:
    datasource:
      #配置数据源的名称
      names: ds1
      #配置数据源的具体内容
      ds1:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.132:3306/sharding_sphere?serverTimezone=UTC
        username: root
    sharding:
      tables:
        #指定orders表的分布情况，配置表在哪个数据库中，表名称是什么
        orders:
          actual-data-nodes: ds1.orders_$->{1..2}
          #指定orders表里主键id生成策略
          key-generator:
            column: id
            type: SNOWFLAKE
          #指定分片策略。根据id的奇偶性来判断插入到哪个表
          table-strategy:
            inline:
              algorithm-expression: orders_${id%2+1}
              sharding-column: id
    #打开sql输出日志
    props:
      sql:
        show: true

#开启驼峰
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. 创建实体类
@Data
public class Orders implements Serializable {

    private Integer id;
    private Integer orderType;
    private Integer customerId;
    private Double amount;

}
  1. 创建dao
public interface OrdersDao {

    @Insert("insert into orders(id,order_type,customer_id,amount) values(#{id},#{orderType},#{customerId},#{amount})")
    void insert(Orders orders);

    @Select("select * from orders where id = #{id}")
    public Orders selectOne(Integer id);

}
  1. 创建测试类
@SpringBootTest
public class ShardingJdbcApplicationTests {

    @Resource
    private OrdersDao ordersDao;

    @Test
    public void addOrders(){
        for (int i = 1; i <=10 ; i++) {
            Orders orders = new Orders();
            orders.setId(i);
            orders.setCustomerId(i);
            orders.setOrderType(i);
            orders.setAmount(1000.0*i);
            ordersDao.insert(orders);
        }
    }
    @Test
    public void queryOrders(){
        Orders orders = ordersDao.selectOne(1);
        System.out.println(orders);
    }
}
  1. 结果
    在这里插入图片描述
    orders_1：
    在这里插入图片描述
    orders_2：
    在这里插入图片描述

4. 水平分库

  1. 在不同的数据节点node01,node02上创建不同名称的数据库：sharding_sphere_1,sharding_sphere_2

  2. 在两个数据库上创建相同的表orders_1,orders_2
    在这里插入图片描述

  3. 分片规则，按照customer_id的奇偶性来进行分库，然后按照id的奇偶性进行分表

  4. 配置文件

spring:
  shardingsphere:
    datasource:
      #配置数据源的名称
      names: ds1,ds2
      #配置数据源的具体内容
      ds1:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.132:3306/sharding_sphere_1?serverTimezone=UTC
        username: root
      ds2:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.128:3306/sharding_sphere_2?serverTimezone=UTC
        username: root
    sharding:
      tables:
        #指定orders表的分布情况，配置表在哪个数据库中，表名称是什么
        orders:
          actual-data-nodes: ds$->{1..2}.orders_$->{1..2}
          #指定orders表里主键id生成策略
          key-generator:
            column: id
            type: SNOWFLAKE
          #指定分片策略。根据id的奇偶性来判断插入到哪个表
          table-strategy:
            inline:
              algorithm-expression: orders_${id%2+1}
              sharding-column: id
          #指定库分片策略，根据customer_id的奇偶性来添加到不同的库中
          database-strategy:
            inline:
              algorithm-expression: ds$->{customer_id%2+1}
              sharding-column: customer_id
    #打开sql输出日志
    props:
      sql:
        show: true
#开启驼峰
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. 修改ordersDao
public interface OrdersDao {

    @Insert("insert into orders(id,order_type,customer_id,amount) values(#{id},#{orderType},#{customerId},#{amount})")
    void insert(Orders orders);

    @Select("select * from orders where id = #{id}")
    public Orders selectOne(Integer id);

    @Select("select * from orders where id = #{id} and customer_id=#{customerId}")
    public Orders selectOneDB(Orders orders);
}
  1. 测试类
@SpringBootTest
public class ShardingJdbcApplicationTests {

    @Resource
    private OrdersDao ordersDao;

    @Test
    public void addOrdersDB(){
        for (int i = 1; i <=10 ; i++) {
            Orders orders = new Orders();
            orders.setId(i);
            orders.setCustomerId(new Random().nextInt(10));
            orders.setOrderType(i);
            orders.setAmount(1000.0*i);
            ordersDao.insert(orders);
        }
    }
    
    @Test
    public void queryOrdersDB(){
        Orders orders = new Orders();
        orders.setCustomerId(8);
        orders.setId(7);
        Orders o = ordersDao.selectOneDB(orders);
        System.out.println(o);
    }
}

5. 垂直分库

  1. 在不同的数据节点node01,node02创建相同的库sharding_jdbc

  2. 在node01上创建orders表，在node02上创建customer表
    在这里插入图片描述

  3. 分片规则：将不同的表插入到不同的库中

  4. 配置文件

spring:
  shardingsphere:
    datasource:
      #配置数据源的名称
      names: ds1,ds2
      #配置数据源的具体内容
      ds1:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.132:3306/sharding_jdbc?serverTimezone=UTC
        username: root
      ds2:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.128:3306/sharding_jdbc?serverTimezone=UTC
        username: root
    sharding:
      tables:
        #配置orders表所在的数据节点
        orders:
          actual-data-nodes: ds1.orders
          #指定orders表里主键id生成策略
          key-generator:
            column: id
            type: SNOWFLAKE
        #配置customer表所在的数据节点
        customer:
          actual-data-nodes: ds2.customer
          #指定customer表里主键id生成策略
          key-generator:
            column: id
            type: SNOWFLAKE
    #打开sql输出日志
    props:
      sql:
        show: true

#开启驼峰
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. 编写customer类
@Data
public class Customer implements Serializable {

    private Integer id;
    private String name;

}
  1. 编写dao
public interface CustomerDao {
    @Insert("insert into customer(id,name) values(#{id},#{name})")
    public void insertCustomer(Customer customer);
}
  1. 测试类
@SpringBootTest
public class ShardingJdbcApplicationTests {

    @Resource
    private OrdersDao ordersDao;
    @Resource
    private CustomerDao customerDao;

    @Test
    public void addOrders(){
        for (int i = 1; i <=10 ; i++) {
            Orders orders = new Orders();
            orders.setId(i);
            orders.setCustomerId(i);
            orders.setOrderType(i);
            orders.setAmount(1000.0*i);
            ordersDao.insert(orders);
        }
    }

    @Test
    public void insertCustomer(){
        for (int i = 1; i <= 10 ; i++) {
            Customer customer = new Customer();
            customer.setId(i);
            customer.setName("zs"+i);
            customerDao.insertCustomer(customer);
        }
    }
}

6. 公共表

之前我们在学习mycat的时候接触过字典表的概念，其实在shardingsphere中也有类似的概念，只不过名字叫做公共表，也就是需要在各个库中都存在的表，方便做某些关联查询。

  1. 在不同节点的库上创建相同的表(node01,node02上创建dict_order_type)
CREATE TABLE `dict_order_type` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `order_type` varchar(200) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

在这里插入图片描述

  1. 分片规则：公共表表示所有的库都具备相同的表
  2. 配置文件
spring:
  shardingsphere:
    datasource:
      #配置数据源的名称
      names: ds1,ds2
      #配置数据源的具体内容
      ds1:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.132:3306/sharding_jdbc?serverTimezone=UTC
        username: root
      ds2:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.128:3306/sharding_jdbc?serverTimezone=UTC
        username: root
    sharding:
      #配置广播表
      broadcast-tables: dict_order_type
      tables:
        dict_order_type:
          #指定orders表里主键id生成策略
          key-generator:
            column: id
            type: SNOWFLAKE
    #打开sql输出日志
    props:
      sql:
        show: true

#开启驼峰
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. 创建实体类
@Data
public class DictOrderType {

    private Integer id;
    private String orderType;

}
  1. 创建dao
public interface DictOrderTypeDao {

    @Insert("insert into dict_order_type(id,order_type) values(#{id},#{orderType})")
    public void insertDictOrderType(DictOrderType dictOrderType);

    @Delete("delete from dict_order_type where id = #{id}")
    public void DeleteDictOrderType(Integer id);

}
  1. 测试类
@SpringBootTest
public class ShardingJdbcApplicationTests {

    @Resource
    private DictOrderTypeDao dictOrderTypeDao;

    @Test
    public void insertDictOrderType(){
        for (int i = 1; i <= 10 ; i++) {
            DictOrderType dictOrderType = new DictOrderType();
            dictOrderType.setId(i);
            dictOrderType.setOrderType("orderType"+i);
            dictOrderTypeDao.insertDictOrderType(dictOrderType);
        }
    }

    @Test
    public void deleteDictOrderType(){
        dictOrderTypeDao.DeleteDictOrderType(1);
    }

}

7. 实现读写分离

  1. node03，node04配置主从复制
  2. 在node03上创建person表
CREATE TABLE `person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(200) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
  1. 配置文件
spring:
  shardingsphere:
    datasource:
      #配置数据源的名称
      names: ds1,ds2
      #配置数据源的具体内容
      ds1:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.129:3306/chencc?serverTimezone=UTC
        username: root
      ds2:
        driver-class-name: com.mysql.jdbc.Driver
        password: 123456
        type: com.alibaba.druid.pool.DruidDataSource
        url: jdbc:mysql://192.168.109.130:3306/chencc?serverTimezone=UTC
        username: root
    masterslave:
      name: ms
      master-data-source-name: ds1
      slave-data-source-names: ds2
    #打开sql输出日志
    props:
      sql:
        show: true

#开启驼峰
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. 创建person类
@Data
public class Person implements Serializable {
    private Integer id;
    private String name;
}
  1. 创建dao
public interface PersonDao {
    @Insert("insert into person(id,name) values(#{id},#{name})")
    public void insertPerson(Person person);

    @Select("select * from person where id = #{id}")
    public Person queryPerson(Integer id);
}
  1. 测试类
@SpringBootTest
public class ShardingJdbcApplicationTests {

    @Resource
    private PersonDao personDao;

    @Test
    public void insertPerson(){
        for (int i = 1; i <= 10; i++) {
            Person person = new Person();
            person.setId(i);
            person.setName("zhangsan"+i);
            personDao.insertPerson(person);
        }
    }

    @Test
    public void queryPerson(){
        Person person = personDao.queryPerson(1);
        System.out.println(person);
    }

}
梦断泪影
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
sharding-jdbc-demo.rar
05-01
分库分表作为数据分布式存储的一个重要领域，有很多解决方案， ...例子中采用java main 方法直接分表分库，有数据删除，数据插入操作，对分表分库学习非常好，sharding-jdbc 直观感受分表分库的例子
zdp-sharding-jdbc:轻量级分库分表框架
05-15
显示告诉框架应该选择主库还是从库，这2个注解可以放在类上，也可以放到方法上，优先级为：方法级写>方法级读>类级写>类级读，方法和类都未标注时默认为写操作 分库分表 开发者可以根据自身业务实现相应的分库分表...
Sharding-JDBC
sinat_34814635的博客
11-07 2万+
数据库优化的几个阶段 数据库优化的几个阶段请参考： https://www.songma.com/news/txtlist_i21939v.html 分库分表适用场景 分库分表主要用于应对当前互联网常见的两个场景——大数据量和高并发。 1.数据量大时，减少单表查询压力 2.减少单表的访问压力 3.单表数据量上百万至千万，索引性能下降 4.索引也很难在提高性能或者更新、插入数据频繁等。 Shardi...
架构组件：基于shard-jdbc中间件，实现数据分库分表
项目管理、软件工厂、vue研发、Java研发、中国文化等。
06-25 492
LOG.debug("分表算法参数 {},{}",names,value);3)、可基于任何第三方的数据库连接池，如DBCP、C3P0、 BoneCP、Druid等。2)、适用于任何基于Java的ORM框架，如Hibernate、Mybatis等。5)、分片策略灵活，可支持等号、between、in等多维度分片，也可支持多分片键。4)、以jar包形式提供服务，无proxy代理层，无需额外部署，无其他依赖。6)、SQL解析功能完善，支持聚合、分组、排序、limit、or等查询。
sharding-jdbc基本使用
最新发布
daniuniuniu的博客
03-06 1290
Apache ShardingSphere 是一款分布式的数据库生态系统，可以将任意数据库转换为分布式数据库，并 通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如 何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。它站在数据库的上层视角， 关注它们之间的协作多于数据库自身。
全网最全最详细的Sharding-JDBC入门
weixin_55076626的博客
11-06 3070
Sharding-JDBC定位为轻量级Java框架,在Java的JDBC层提 供的额外服务。它使用客户端直连数据库,以jar包形式提供服务，无需额外部署和依赖，可理解为增强版的JDBC驱动，完全兼容JDBC和各种ORM框架。使用Sharding-JDBC可以在程序中轻松的实现数据库读写分离。1、适用于任何基于JDBC的ORM框架，如: JPA, Hibernate, Mybatis, Spring JDBC Template或直接使用JDBC。
【Sharding-JDBC】一文轻松了解Sharding-JDBC
qq_40975602的博客
08-27 894
MyBatis：MyBatis是一个持久层框架，用于简化数据库访问和操作。它提供了一组API和工具，使开发人员可以通过配置SQL语句和映射关系，将Java对象与数据库表进行映射，实现数据的持久化操作。MyBatis负责执行SQL语句、处理数据库连接、参数传递、结果映射等数据库操作的细节。它提供了丰富的配置选项和灵活的映射方式，可以满足各种复杂的数据库操作需求。ShardingDataSource是一个分布式数据库中间件，用于分片数据存储和访问。
基于 SpringBoot + ShardingSphere（Sharding-JDBC） 的水平分表测试项目+源代码+文档说明
11-29
- **分片：** 单库多表，通过 Sharding-JDBC 水平分表后操作 - **不分片：** 单库单表，通过 JDBC 操作 ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！...
Sharding Sphere课堂笔记.zip
10-26
Sharding Sphere的所有使用...4、使用 Sharding-JDBC 操作公共表 5、使用使用 Sharding-JDBC 读写分离 三、Sharding-Proxy 1、什么是 Sharding-Proxy 2、使用 Sharding-Proxy 分库分表 3、使用 Sharding-Proxy 读写分离
JDBC技术剖析
12-14
JDBC技术剖析1.JDBC概述2.JDBC原理2.1 JDBC中主要类2.1.1 DriverManager类2.1.2 Connection2.1.3 Statement3 JDBC应用示例1、 加载驱动2.、获取连接3、获取Statement4、执行sql的增删改查语句5、关闭资源6、示例代码...
Sharding-JDBC 实战（史上最全）
热门推荐
架构师尼恩
03-11 5万+
文章很长，而且持续更新，建议收藏起来，慢慢读！ Java 高并发 发烧友社群：疯狂创客圈（总入口） 奉上以下珍贵的学习资源： 免费赠送 经典图书 ： 极致经典 + 社群大片好评 《 Java 高并发 三部曲 》 面试必备 + 大厂必备 + 涨薪必备 免费赠送 经典图书 ： 《Netty Zookeeper Redis 高并发实战》 面试必备 + 大厂必备 +涨薪必备 （加尼恩领取） 免费赠送 经典图书 ： 《SpringCloud、Nginx高并发核心编程》 面试必备 + 大
sharding jdbc使用详解
lonely_baby的博客
02-22 1429
在这个例子中，t_order 表会被分成两个物理表 t_order_0 和 t_order_1，分别存储 order_id 值为偶数和奇数的数据。在这个例子中，Sharding-JDBC 数据源是通过 ShardingDataSourceFactory 创建的，使用了前面配置的分片规则和 SQL 解析规则。接下来，需要在 Spring 配置文件中配置 SQL 解析规则。以上是 Sharding-JDBC 的使用详解说明，使用 Sharding-JDBC 可以轻松地实现分布式数据库的横向扩展。
sharding-jdbc的使用
weixin_46264060的博客
12-15 1960
本文将说明sharding-jdbc的分片功能和数据加密功能
Sharding-JDBC（二）- Sharding-JDBC介绍
及时当勉励，岁月不待人
09-12 3150
Sharding-JDBC（二）- Sharding-JDBC介绍
Sharding-JDBC教程
xiaotu的博客
02-15 489
Sharding JDBC
Sharding-JDBC简单使用
Curtisjia的博客
09-21 2360
sharding-jdbc 定位为轻量级 Java 框架，在 Java 的 JDBC 层提供的额外服务。它使用客户端直连数据库，以 jar 包形式提供服务，无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。JAVA APIYamlSpringBootSpring 命名空间（xml 配置文件）
Sharding-JDBC之绑定表（关联表）
嘉禾嘉宁papa
05-16 4942
Sharding-JDBC之绑定表（关联表）
sharding-jdbc分库连接数优化教程
蓝易云
08-18 300
优化Sharding-JDBC分库连接数可以通过配置连接池参数、优化数据库连接释放以及合理配置分库连接池来实现。通过合理设置连接池参数、及时释放连接和独立配置分库连接池，可以提高连接数的使用效率，减少连接池的资源占用。在使用Sharding-JDBC进行分库分表时，优化连接数是一个重要的考虑因素。通过在Sharding-JDBC的数据源配置中为每个库配置独立的连接池参数，可以针对不同的库灵活地设置连接数，从而优化连接数的使用。通过合理设置连接池参数，可以有效地控制连接数的使用和管理。
sharding-jdbc原理
09-14
Sharding-JDBC是一个开源的分库分表中间件，它通过在应用层透明地对数据库进行分库分表操作，从而实现了数据库的水平扩展和性能优化。其原理如下： 1. 数据库拆分：Sharding-JDBC将一个大的数据库按照一定的规则...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值