sharding-jdbc入门

Sharding | 数据分片策略:分片键和分片算法的选择 规划分片策略的过程需要考虑较多的问题,本文简单地概括了分片键应具有的特性,以及常见分片算法的特点。 阅读详情

概览

认识ShardingSphere

ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈,它由ShardingJDBC、Sharding-Proxy和Sharding-Sidecar(计划中)这3款相互独立的产品组成。
他们均提
供标准化的数据分片、分布式事务和数据库治理功能,可适用于如Java同构、异构语言、容
器、云原生等各种多样化的应用场景。

官网地址: https://shardingsphere.apache.org/index_zh.html

ShardingSphere构成:
在这里插入图片描述

认识Sharding-JDBC

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

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

在这里插入图片描述

功能列表

数据分片
分库 & 分表
读写分离
分布式主键
分布式事务(Doing)
XA强一致事务
柔性事务
数据库治理
配置动态化
熔断 & 禁用
调用链路追踪
弹性伸缩 (Planning)

数据分片工作原理

hardingSphere的3个产品的数据分片主要流程是完全一致的。 核心由 SQL解析 => 执行器优化
=> SQL路由 => SQL改写 => SQL执行 => 结果归并 的流程组成。
在这里插入图片描述

**SQL解析 **
分为词法解析和语法解析。 先通过词法解析器将SQL拆分为一个个不可再分的单词。再使用语
法解析器对SQL进行理解,并最终提炼出解析上下文。 解析上下文包括表、选择项、排序项、
分组项、聚合函数、分页信息、查询条件以及可能需要修改的占位符的标记。
**执行器优化 **
合并和优化分片条件,如OR等。

**SQL路由 **
根据解析上下文匹配用户配置的分片策略,并生成路由路径。目前支持分片路由和广播路由。
**SQL改写 **
将SQL改写为在真实数据库中可以正确执行的语句。SQL改写分为正确性改写和优化改写。
**SQL执行 **
通过多线程执行器异步执行。
**结果归并 **
将多个执行结果集归并以便于通过统一的JDBC接口输出。结果归并包括流式归并、内存归并和
使用装饰者模式的追加归并这几种方式。

入门DEMO

多数据源入门

  1. pom配置
<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.3.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
      <groupId>org.mybatis.spring.boot</groupId>
      <artifactId>mybatis-spring-boot-starter</artifactId>
      <version>2.0.0</version>
   </dependency>

   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
   </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>
   </dependency>
   <dependency>
       <groupId>io.shardingsphere</groupId>
       <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
       <version>3.1.0</version>
   </dependency>
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.1.14</version>
   </dependency>
</dependencies>
  1. 多数据源配置
sharding:
  jdbc:
    datasource:
      names: ds0,ds1   配置多数据源 ds0,ds1 ds0 ds1是逻辑名称真正的数据库是url连接中的
      ds0: 
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        maxPoolSize: 50
        minPoolSize: 1
      ds1: 
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        maxPoolSize: 50
        minPoolSize: 1
    config:
      sharding:
       default-data-source-name: ds0 默认走ds0数据库
      props:
        sql.show: true
             
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. dao代码,执行下面的addOrder()和get()默认会命中ds0-db1,因为配置了 default-data-source-name: ds0 默认走ds0数据库
@Mapper
public interface OrderDao {

   //@Insert("insert into t_order(order_time,customer_id) values(#{orderTime},#{customerId})")
   @Insert("insert into t_order(order_id,order_time,customer_id) values(#{orderId},now(),#{customerId})")
   void addOrder(Order o);
   
   @Select("select order_id,order_time,customer_id from t_order where order_id=#{id}")
   Order get(@Param("id")Long orderId);
}

读写分离

  1. pom文件和上面示例多数据源入门一致, 配置数据库的主从复制 可以参考MYSQL Master-Slaves主从复制.pdf或者其他帖子
  2. 主从复制数据源配置
sharding:
  jdbc:
    datasource:
      names: ds0,ds1
      ds0:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://192.168.120.218:3306/orders?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: mike
        password: Mike666!
        maxPoolSize: 50
        minPoolSize: 1
      ds1:
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://192.168.120.219:3306/orders?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: mike
        password: Mike666!
        maxPoolSize: 50
        minPoolSize: 1
    config:
      sharding:
        default-data-source-name: ds0
      masterslave:  主从复制配置
        name: ms
        master-data-source-name: ds0  主数据源
        slave-data-source-names: ds1  从数据源可以多个
      props:
        sql.show: true

mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. dao代码 配置完读写分离,进行addOrder()会命中配置的master对应的dso,进行查询会命中配置的slave对应的ds1

@Mapper
public interface OrderDao {

//@Insert(“insert into t_order(order_time,customer_id) values(#{orderTime},#{customerId})”)
@Insert(“insert into t_order(order_id,order_time,customer_id) values(#{orderId},now(),#{customerId})”)
void addOrder(Order o);

@Select(“select order_id,order_time,customer_id from t_order where order_id=#{id}”)
Order get(@Param(“id”)Long orderId);
}

简单分库分表

  1. pom文件和上面示例多数据源入门一致
  2. 数据源分库分表配置
sharding:
  jdbc:
    datasource:
      names: ds0,ds1
      ds0: 
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        maxPoolSize: 50
        minPoolSize: 1
      ds1: 
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        maxPoolSize: 50
        minPoolSize: 1
    config:
      sharding:
        tables:
           t_order:
             actual-data-nodes: ds$->{0..1}.t_order$->{0..1}   库(ds0、ds1对应各自物理库)、表节点(t_order0、t_order1)
             database-strategy:
               inline:
                 sharding-column: customer_id
                 algorithm-expression: ds$->{customer_id % 2} 数据库选择根据customer_id字段去余,然后得到逻辑名称,根据名称映射对应库,如ds1对应db2
             table-strategy:
               inline:
                 sharding-column: order_id 在上面确定库的基础上,表选择根据order_id取余确定表
                 algorithm-expression: t_order$->{order_id % 2}
        default-data-source-name: ds0
      props:
        sql.show: true        
mybatis:
  configuration:
    map-underscore-to-camel-case: true
  1. dao层代码配置分库分表 请求传入参数orderId=10000&customerId=1003&orderTime=2020-09-19 ;addOrder()传入orderId=10000和customerId=1003 访问OrderDao类addOrder和get方法

@Mapper
public interface OrderDao {

1.根据分库分表路由配置,首先根据customerId%2=1,确定ds1,ds1对应db2,数据库确定之后根据表路由算法order_id % 2=0 所以最终命中

ds1.t_order0(db2.t_order0),sql打印如下

Actual SQL: ds1 ::: insert into t_order0(order_id,order_time,customer_id) values(?,?,?) ::: [[10000, 2020-09-19 00:00:00.0, 1003]]

@Insert(“insert into t_order(order_id,order_time,customer_id) values(#{orderId},now(),#{customerId})”)
void addOrder(Order o);

2.查询因为传入是orderId,库选择是根据customer_id路由的,没传入customer_id会去ds0和ds1都去查询,然后根据传入的orderId确定是t_order0查询,所以查询两次从ds0.t_order0查询一次、ds1.t_order0查询一次,sql打印如下

Actual SQL: ds0 ::: select order_id,order_time,customer_id from t_order0 where order_id=? ::: [[10000]]

Actual SQL: ds1 ::: select order_id,order_time,customer_id from t_order0 where order_id=? ::: [[10000]]

@Select(“select order_id,order_time,customer_id from t_order where order_id=#{id}”)
Order get(@Param(“id”)Long orderId);
}

standard 时间字段确定分片

  1. pom引入包和以上一致

  2. 数据源配置,根据order_time字段自定义,2019年前放入dbo,2019后放入db1

    sharding:
      jdbc:
        datasource:
          names: ds0,ds1
          ds0: 
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class: com.mysql.jdbc.Driver
            url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
            username: root
            password: root
            maxPoolSize: 50
            minPoolSize: 1
          ds1: 
            type: com.alibaba.druid.pool.DruidDataSource
            driver-class: com.mysql.jdbc.Driver
            url: jdbc:mysql://localhost:3306/db2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
            username: root
            password: root
            maxPoolSize: 50
            minPoolSize: 1
        config:
          sharding:
            tables:
               t_order:
                 actual-data-nodes: ds$->{0..1}.t_order$->{0..1} 
                 database-strategy:
                   standard:
                     sharding-column: order_time  分片库路由字段
                     preciseAlgorithmClassName: com.study.mike.sharding.jdbc.sharding.OrderTimePreciseShardingAlgorithm  重写PreciseShardingAlgorithm自定义路由策略,2019年前放入dbo,2019后放入db1
                 table-strategy:
                   inline:
                     sharding-column: order_id
                     algorithm-expression: t_order$->{order_id % 2}
                 #keyGeneratorClassName: io.shardingsphere.core.keygen.DefaultKeyGenerator
            default-data-source-name: ds0
          props:
            sql.show: true
            
            
    mybatis:
      configuration:
        map-underscore-to-camel-case: true
    

3.dao层代码 传入参数orderId=10001&customerId=1004&orderTime=2018-09-19

@Mapper
public interface OrderDao {

1.根据分库分表路由配置,首先根据orderTime大于2019年路由ds0,否则ds1,因为传入2018年所以命中ds0,数据库确定之后根据表路由算法order_id % 2=01所以最终命中

ds1.t_order1(db2.t_order1),sql打印如下

Actual SQL: ds0 ::: insert into t_order1(order_id,order_time,customer_id) values(?,?,?) ::: [[10001, 2018-09-19 00:00:00.0, 1004]]

@Insert(“insert into t_order(order_id,order_time,customer_id) values(#{orderId},now(),#{customerId})”)
void addOrder(Order o);

2.get 方法和简单分库分表一致 因为没有传入分库字段 所以会两个库都会查询,查询的表根据orderId%2=1确定为t_order1

@Select(“select order_id,order_time,customer_id from t_order where order_id=#{id}”)
Order get(@Param(“id”)Long orderId);
}

4.OrderTimePreciseShardingAlgorithm

public class OrderTimePreciseShardingAlgorithm implements PreciseShardingAlgorithm<Date>{
   
   Date[] dateRanges = new Date[2];
   
   {
      Calendar cal = Calendar.getInstance();
      cal.set(2019, 1, 1, 0, 0, 0);
      dateRanges[0] = cal.getTime();
      cal.set(2020, 1, 1, 0, 0, 0);
      dateRanges[1] = cal.getTime();
   }

   @Override
   public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Date> shardingValue) {
      
      Date d = shardingValue.getValue();
      Iterator<String> ite = availableTargetNames.iterator();
      String target = null;
      for(Date s : dateRanges) {
         target = ite.next();
         if(d.before(s)) {
            break;
         }
      }
      return target;
   }

}

全局唯一主键

1.pom包引入和上面一致

2.数据源配置,配置keyGeneratorColumnName、 key-generator-column-name、keyGeneratorClassName三个字段,默认是雪花算法

sharding:
  jdbc:
    datasource:
      names: ds0,ds1
      ds0: 
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        maxPoolSize: 50
        minPoolSize: 1
      ds1: 
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/db2?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        maxPoolSize: 50
        minPoolSize: 1
    config:
      sharding:
        tables:
           t_order:
             actual-data-nodes: ds$->{0..1}.t_order$->{0..1}
             database-strategy:
               standard:
                 sharding-column: order_time
                 preciseAlgorithmClassName: com.study.mike.sharding.jdbc.sharding.OrderTimePreciseShardingAlgorithm
             table-strategy:
               inline:
                 sharding-column: order_id
                 algorithm-expression: t_order$->{order_id % 2}
             keyGeneratorColumnName: order_id  order_id当做自增主键,默认是雪花算法
             key-generator-column-name: order_id
             keyGeneratorClassName: io.shardingsphere.core.keygen.DefaultKeyGenerator
        default-data-source-name: ds0
          #type: SNOWFLAKE
      props:
        sql.show: true
        
        
mybatis:
  configuration:
    map-underscore-to-camel-case: true

3.dao 插入数据库 orderid不用传入,由shardingjdbc生成

@Insert("insert into t_order(order_time,customer_id) values(#{orderTime},#{customerId})")
void addOrder(Order o);

绑定表

指分片规则一致的主表和子表。例如:t_order表和t_order_item表,均按照order_id分片(路由策略一致),则此两张表互为绑定表关系。绑定表之间的多表关联查询不会出现笛卡尔积关联,关联查询效率将大大提升。使用bindingTables进行绑定。

在这里插入图片描述

绑定示例:

在这里插入图片描述

广播表

指所有的分片数据源中都存在的表,表结构和表中的数据在每个数据库中均完全一致。适用于数据量不大且需要与海量数据的表进行关联查询的场景,如字典表。

在这里插入图片描述

Sharding-JDBC入门 目录`Sharding-JDBC` 简介简介架构支持功能 Sharding-JDBC 简介 简介 Sharding-JDBC 是当当网研发的开源分布式数据库中间件,从 3.0 开始 Sharding-JDBC 被包含在 Sharding-Sphere 中,之后该项目进入进入 Apache 孵化器,4.0 版本之后的版本为 Apache 版本 Sharding-JDBC 定位于轻量级的 Java 框架,它使用客户端直连数据库,可理解为增强版的 JDBC 驱动,完全兼容 JDBC 和各种 ORM 框架 Shar 阅读详情

相关推荐

sharding-JDBC快速入门

sharding-JDBC快速入门前言需求说明一、环境搭建?1 环境说明2 创建数据库3.引入maven依赖二.编写程序1 分片规则配置2.数据操作3.测试4.流程分析5.其他集成方式5.1 Spring Boot Yaml 配置 前言 需求说明 使用Sharding-JDBC完成对订单表的水平分表 ,通过快速入门程序的开发 ,快速体验Sharding-JDBC的使用 方法。 人工创建两张表 ,t_order_1和t_order_2 ,这两张表是订单表拆分后的表 ,通过Sharding-Jdbc向订单表

weixin_46158141的博客 1443

数据库分片(Sharding):分表+分库+分片+分区

在字段很多的情况下(例如一个大表有100多个字段),通过"大表拆小表",更便于开发与维护,也能避免跨页问题,MySQL底层是通过数据页存储的,一条记录占用空间过大会导致跨页,造成额外的性能开销。当业务高速发展,面临性能和存储的瓶颈时,才会考虑分片设计,此时就不可避免的需要考虑历史数据迁移的问题。但是如果取得页数很大,情况则变得复杂很多,因为各分片节点中的数据可能是随机的,为了排序的准确性,需要将所有节点的前N页数据都排序好做合并,最后再进行整体的排序,这样的操作时很耗费CPU和内存资源的,所以。...

weixin_41269279的博客 1万+

Sharding-JDBC快速入门demo

一.需求描述 使用Sharding-JDBC完成对订单表的水平分表,通过快速入门程序的开发,快速体验Sharding-JDBC的使用 方法; 通过Sharding-Jdbc向订单表插入数据, 按照一定的分片规则,主键为偶数的进入t_order_1,另一部分数据进入t_order_2,通过Sharding-Jdbc 查询数据,根据 SQL语句的内容从t_order_1或t_order_2查询数据。 二.环境搭建 1.sql CREATE DATABASE `order_db` CHARACTER SET 'u

m0_67266787的博客 638

数据库之Sharding分库分表操作详解

Sharding和,最早是由当当网开源,捐给了Apache,成为了Apache顶级项目,后来又升级成了是一款分布式SQL事务和查询引擎,可通过数据分片、弹性伸缩、加密等能力对任意数据库进行增强。需要实现接口System . out . println("自定义的id" + id);return id;} // 返回 自定义 算法类型表示 @Override public String getType() {} }

上善若泪 3843

Sharding-JDBC 系列专题 - 第一篇:简介与快速入门

Sharding-JDBC 是一个开源的数据库分片解决方案,通过客户端直连方式提供分库分表、读写分离和分布式事务等功能。它直接嵌入到应用程序中,无需额外的中间件部署,适合需要高性能和高扩展性的分布式数据库场景。在分库分表场景中,某些表的数据需要在所有分片数据库中保持一致,这些表称为广播表(Broadcast Tables)。广播表的写操作会同步到所有分片数据库,读操作只需访问一个分片数据库。本篇介绍了 Sharding-JDBC 的基本概念、核心功能和快速入门示例。

资深架构师分享:深入剖析软件架构,探讨云计算、微服务、大数据等前沿技术。分享实践经验,促进技术交流,共同构建卓越系统。 1067

Sharding中文文档.pdf

数据库(分库分表、读写分离)

Sharding-JDBC快速入门案例

本文主要使用​Sharding-JDBC做一个简单的单库分表入门案例。

weixin_46425661的博客 1794

【2022KaliLinux】openvas/gvm 没有scan configs 或者是 scan config error “XXXXXXXXXXX”

gvm/openvas的configuration的scan config为空

zbossz的学习小分队 3608

快速入门sharding-jdbc

一天足够学完分库分表

阳光宅男的博客 544

Windows 11下WSL2安装CUDA避坑指南:从驱动版本匹配到环境变量配置

本文详细解析了在Windows 11的WSL2中搭建CUDA开发环境的完整流程与核心避坑要点。关键在于理解“驱动在Windows,工具链在Linux”的独特架构,并确保显卡驱动与CUDA Toolkit版本严格匹配。指南涵盖了从驱动验证、WSL-Ubuntu专用仓库安装、环境变量配置到GCC版本冲突、GPU算力不匹配等常见问题的解决方案,帮助开发者高效构建稳定的深度学习与高性能计算环境。

smartcontract5的博客 476

图片边界矢量化-地理配准

无地理和投影信息的JPG图片,通过ArcGIS进行地理配准(Georeferencing)完成数字化边界。

u012727861的博客 1909

二、Sharding-JDBC 快速入门(只水平分表)

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

pkyShare 的博客 2885

步进电机选型避雷手册:为什么你的42HS电机总丢步?从相数、电流到散热全面拆解

本文深入剖析了42HS步进电机在高速或重载下易出现丢步问题的根本原因。文章指出,选型时不应仅关注静态保持转矩,而需重点分析动态矩频曲线、合理匹配驱动器电流与细分数、进行准确的机械传动惯量计算,并有效管理系统共振与散热。通过全面拆解这些关键因素,为工程师提供了实用的选型避雷指南与系统优化方案。

weixin_29275257的博客 97

Sharding-jdbc入门学习笔记

Sharding-jdbc入门学习笔记 文章目录Sharding-jdbc入门学习笔记一, Sharding-jdbc概念1.1 ShardingSphere簡介1.2 Sharding-jdbc簡介1.2.1 SQL1.2.2 分片1.2.3 改寫1.2.4 分佈式主鍵生出器二, 讀寫分離2.1 前期準備2.2 依賴文件2.3 配置文件2.4 啟動類2.5 MVC類2.5.1 模型層2.5.2 DAO層2.5.3 Service層2.5.4 Controller層2.6 配置類2.6.1 數據庫參數類2.

lmchhh的博客 1485

IFIX5.8在Win10系统下的安装避坑指南

本文提供了IFIX5.8在Windows 10系统下的详细安装教程与避坑指南。针对常见的驱动缺失、UAC拦截及兼容性报错等问题,文章从安装前准备、分步安装流程到安装后配置与驱动修复,给出了系统性的解决方案,帮助工控从业者顺利完成部署。

f6g7h8i9j的博客 364

C# WinForm和Sherlock进行对接

文章目录 前言 一、使用步骤 二、使用步骤 1.引入库 2.读入数据 总结 前言 本人公司最近在做一款瑕疵检测的视觉项目,项目中利用Sherlock从相机中取图和对图像进行视觉处理,然后将图像和数据传输到项目中。这过程中软件需要和Sherlock进行图像和数据的传递,这就需要WinForm和Sherlock进行对接,但我在网上查找了许久能用上的资料十分有限,所以我决定写下这篇文章,来做一次总结,同时也希望能帮助到同样在为此问题困扰的你。 一、使用步骤 废话不...

adminmmrt的博客 3221

Sharding-JDBC快速入门,环境搭建,实现,集成springboot

面对日益增加的系统访问量,数据库的吞吐量面临着巨大瓶颈。人工创建两张表,t_order_1和t_order_2,这两张表是订单表拆分后的表,通过Sharding-Jdbc向订单表插入数据, 按照一定的分片规则,主键为偶数的进入t_order_1,另一部分数据进入t_order_2,通过Sharding-Jdbc 查询数。定义t_order分片策略,order_id为偶数的数据落在t_order_1,为奇数的落在t_order_2,分表策略的表达式为t_order_$->{order_id % 2 + 1}

weixin_43939708的博客 597

Codex智能体从零搭建:环境配置、代码管理与MCP扩展实战

AI智能体(Agent)作为连接大语言模型与实际应用的关键技术,通过感知、决策与执行框架,将AI能力融入具体工作流。其核心原理在于利用提示工程、上下文管理与工具调用,将自然语言指令转化为可执行操作。在软件开发领域,AI智能体能够显著提升代码生成、项目管理和自动化任务的效率。通过Model Context Protocol(MCP)等标准化协议,智能体可以安全、结构化地集成外部工具与服务,实现能力扩展。本文聚焦于Codex这一AI驱动的代码助手平台,详细解析其环境配置、代码索引、记忆系统等核心模块,并深入探讨

weixin_34220179的博客 594

(基础)Sharding-JDBC 第一章 快速入门

概述 1.1.分库分表是什么 随着公司业务快速发展,数据库中的数据量猛增,访问性能也变慢了,优化迫在眉睫。分析一下问题出现在哪儿 呢? 关系型数据库本身比较容易成为系统瓶颈,单机存储容量、连接数、处理能力都有限。当单表的数据量达到 1000W或100G以后,由于查询维度较多,即使添加从库、优化索引,做很多操作时性能仍下降严重。 方案1: 通过提升服务器硬件能力来提高数据处理能力,比如增加存储容量 、CPU等,这种方案成本很高,并且如果瓶颈在 MySQL本身那么提高硬件也是有很的。 方案2: 把数据分散在不同

gonghaiyu的博客 1037

ubuntu 安装node和npm

在ubuntu中经常需要用到node ,npm,因为npm基本会和node同时安装,所以只需要安装node即可。可以使用 nvm(Node Version Manager)来管理你的 Node.js 版本。

风吹落叶的博客 2293

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

jdbc sharding yml配置_sharding-jdbc4.0入门

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

weixin_39779928的博客 669

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

sharding-jdbc oracle,Sharding-JDBC 使用入门和基本配置

一、什么是Sharding-JDBCSharding-JDBC定位为轻量级Java框架,在Java的JDBC层提供的额外服务。它使用客户端直连数据库,以jar包形式提供服务,无需额外部署和依赖,可理解为增强版的JDBC驱动,完全兼容JDBC和各种ORM框架。二、Sharding-JDBC能做什么分库 & 分表读写分离分布式主键分布式事务三、适用项目框架Sharding-JDBC适用于:任何...

weixin_42356139的博客 1166

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

Sharding-jdbc-入门

Sharding-jdbc 1.背景 传统将数据集中存储至单一数据节点的解决方案,在性能,可用性和运维成本这三方面已经难于满足互联网的海量数据场景 2.数据分片 2.1概念 数据分片指按照某个维度将存放在单一数据库中的数据分散的存放至多个数据库或表中以达到提升性能瓶颈以及 可用性的效果 2.2 手段 分库、分表 2.3 作用 分库 有效避免由数据量超过可承受阈值而产生的查询瓶颈 分散对数据库单...

XiangYida 383

# Sharding-JDBC从入门到精通(3)- Sharding-JDBC 入门程序

# Sharding-JDBC从入门到精通(3)- Sharding-JDBC入门程序 11-Sharding-JDBC入门程序(水平分表)-环境搭建 12-Sharding-JDBC入门程序(水平分表)-分片配置 13-Sharding-JDBC入门程序(水平分表)-插入订单 14-Sharding-JDBC入门程序(水平分表)-查询订单 15-Sharding-JDBC入门程序(水平分表)-执行流程分析

段子手168的博客 1476

Sharding-JDBC笔记01-分库分表概念与快速入门

本文介绍了分库分表概念与Sharding-JDBC快速入门示例

weixin_46425661的博客 995
上一篇: 数据库中间件设计理论
下一篇: RPC技术
一切还来得及
博客等级 码龄11年 50粉丝 19原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值