【RPC 专栏】深入理解 RPC 之传输篇

Socket,NIO,Netty介绍 1. Socket回顾与I/0模型 1.1 Socket网络编程回顾 1.1.1 Socket概述 Socket,套接字就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议,主要解决数据如何在网络中传输,而HTTP是应用层协议,主要解决如何包装数据。 Socket是通信的基石,是支持TCP/IP协议的网络通信的基本操作单元。 它是网络通信过程中端点的抽象表示,包含进行网络通信必须的五种信息:连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。 1.1.2 阅读详情

点击上方“芋道源码”,选择“置顶公众号”

技术文章第一时间送达!

源码精品专栏

 
  • RpcRequest 和 RpcResponse

  • Socket传输

  • Netty 传输

  • 同步与异步 阻塞与非阻塞

  • 总结


RPC 被称为“远程过程调用”,表明了一个方法调用会跨越网络,跨越进程,所以传输层是不可或缺的。一说到网络传输,一堆名词就蹦了出来:TCP、UDP、HTTP,同步 or 异步,阻塞 or 非阻塞,长连接 or 短连接…

本文介绍两种传输层的实现:使用 Socket 和使用 Netty。前者实现的是阻塞式的通信,是一个较为简单的传输层实现方式,借此可以了解传输层的工作原理及工作内容;后者是非阻塞式的,在一般的 RPC 场景下,性能会表现的很好,所以被很多开源 RPC 框架作为传输层的实现方式。

RpcRequest 和 RpcResponse

传输层传输的主要对象其实就是这两个类,它们封装了请求 id,方法名,方法参数,返回值,异常等 RPC 调用中需要的一系列信息。

public class RpcRequest implements Serializable {
   private String interfaceName;
   private String methodName;
   private String parametersDesc;
   private Object[] arguments;
   private Map<String, String> attachments;
   private int retries = 0;
   private long requestId;
   private byte rpcProtocolVersion;
}
public class RpcResponse implements Serializable {
   private Object value;
   private Exception exception;
   private long requestId;
   private long processTime;
   private int timeout;
   private Map<String, String> attachments;// rpc协议版本兼容时可以回传一些额外的信息
   private byte rpcProtocolVersion;
}

Socket传输

Server

public class RpcServerSocketProvider {
   public static void main(String[] args) throws Exception {
       //序列化层实现参考之前的章节
       Serialization serialization = new Hessian2Serialization();
       ServerSocket serverSocket = new ServerSocket(8088);
       ExecutorService executorService = Executors.newFixedThreadPool(10);
       while (true) {
           final Socket socket = serverSocket.accept();
           executorService.execute(() -> {
               try {
                   InputStream is = socket.getInputStream();
                   OutputStream os = socket.getOutputStream();
                   try {
                       DataInputStream dis = new DataInputStream(is);
                       int length = dis.readInt();
                       byte[] requestBody = new byte[length];
                       dis.read(requestBody);
                       //反序列化requestBody => RpcRequest
                       RpcRequest rpcRequest = serialization.deserialize(requestBody, RpcRequest.class);
                       //反射调用生成响应 并组装成 rpcResponse
                       RpcResponse rpcResponse = invoke(rpcRequest);
                       //序列化rpcResponse => responseBody
                       byte[] responseBody = serialization.serialize(rpcResponse);
                       DataOutputStream dos = new DataOutputStream(os);
                       dos.writeInt(responseBody.length);
                       dos.write(responseBody);
                       dos.flush();
                   } catch (Exception e) {
                       e.printStackTrace();
                   } finally {
                       is.close();
                       os.close();
                   }
               } catch (Exception e) {
                   e.printStackTrace();
               } finally {
                   try {
                       socket.close();
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }
           });
       }
   }
   public static RpcResponse invoke(RpcRequest rpcRequest) {
       //模拟反射调用
       RpcResponse rpcResponse = new RpcResponse();
       rpcResponse.setRequestId(rpcRequest.getRequestId());
       //... some operation
       return rpcResponse;
   }
}

Client

public class RpcSocketConsumer {
   public static void main(String[] args) throws Exception {
       //序列化层实现参考之前的章节
       Serialization serialization = new Hessian2Serialization();
       Socket socket = new Socket("localhost", 8088);
       InputStream is = socket.getInputStream();
       OutputStream os = socket.getOutputStream();
       //封装rpc请求
       RpcRequest rpcRequest = new RpcRequest();
       rpcRequest.setRequestId(12345L);
       //序列化 rpcRequest => requestBody
       byte[] requestBody = serialization.serialize(rpcRequest);
       DataOutputStream dos = new DataOutputStream(os);
       dos.writeInt(requestBody.length);
       dos.write(requestBody);
       dos.flush();
       DataInputStream dis = new DataInputStream(is);
       int length = dis.readInt();
       byte[] responseBody = new byte[length];
       dis.read(responseBody);
       //反序列化 responseBody => rpcResponse
       RpcResponse rpcResponse = serialization.deserialize(responseBody, RpcResponse.class);
       is.close();
       os.close();
       socket.close();
       System.out.println(rpcResponse.getRequestId());
   }
}

dis.readInt() 和 dis.read(byte[] bytes) 决定了使用 Socket 通信是一种阻塞式的操作,报文头+报文体的传输格式是一种常见的格式,除此之外,使用特殊的字符如空行也可以划分出报文结构。在示例中,我们使用一个 int(4字节)来传递报问题的长度,之后传递报文体,在复杂的通信协议中,报文头除了存储报文体还会额外存储一些信息,包括协议名称,版本,心跳标识等。

在网络传输中,只有字节能够被识别,所以我们在开头引入了 Serialization 接口,负责完成 RpcRequest 和 RpcResponse 与字节的相互转换。(Serialization 的工作机制可以参考之前的文章)

使用 Socket 通信可以发现:每次 Server 处理 Client 请求都会从线程池中取出一个线程来处理请求,这样的开销对于一般的 Rpc 调用是不能够接受的,而 Netty 一类的网络框架便派上了用场。

Netty 传输

Server 和 ServerHandler

public class RpcNettyProvider {
   public static void main(String[] args) throws Exception{
       EventLoopGroup bossGroup = new NioEventLoopGroup();
       EventLoopGroup workerGroup = new NioEventLoopGroup();
       try {
           // 创建并初始化 Netty 服务端 Bootstrap 对象
           ServerBootstrap bootstrap = new ServerBootstrap();
           bootstrap.group(bossGroup, workerGroup);
           bootstrap.channel(NioServerSocketChannel.class);
           bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
               @Override
               public void initChannel(SocketChannel channel) throws Exception {
                   ChannelPipeline pipeline = channel.pipeline();
                   pipeline.addLast(new RpcDecoder(RpcRequest.class)); // 解码 RPC 请求
                   pipeline.addLast(new RpcEncoder(RpcResponse.class)); // 编码 RPC 响应
                   pipeline.addLast(new RpcServerHandler()); // 处理 RPC 请求
               }
           });
           bootstrap.option(ChannelOption.SO_BACKLOG, 1024);
           bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
           ChannelFuture future = bootstrap.bind("127.0.0.1", 8087).sync();
           // 关闭 RPC 服务器
           future.channel().closeFuture().sync();
       } finally {
           workerGroup.shutdownGracefully();
           bossGroup.shutdownGracefully();
       }
   }
}
public class RpcServerHandler extends SimpleChannelInboundHandler<RpcRequest> {
   @Override
   public void channelRead0(final ChannelHandlerContext ctx, RpcRequest request) throws Exception {
       RpcResponse rpcResponse = invoke(request);
       // 写入 RPC 响应对象并自动关闭连接
       ctx.writeAndFlush(rpcResponse).addListener(ChannelFutureListener.CLOSE);
   }
   private RpcResponse invoke(RpcRequest rpcRequest) {
       //模拟反射调用
       RpcResponse rpcResponse = new RpcResponse();
       rpcResponse.setRequestId(rpcRequest.getRequestId());
       //... some operation
       return rpcResponse;
   }
   @Override
   public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
       cause.printStackTrace();
       ctx.close();
   }
}

Client 和 ClientHandler

public class RpcNettyConsumer {
   public static void main(String[] args) throws Exception{
       EventLoopGroup group = new NioEventLoopGroup();
       try {
           // 创建并初始化 Netty 客户端 Bootstrap 对象
           Bootstrap bootstrap = new Bootstrap();
           bootstrap.group(group);
           bootstrap.channel(NioSocketChannel.class);
           bootstrap.handler(new ChannelInitializer<SocketChannel>() {
               @Override
               public void initChannel(SocketChannel channel) throws Exception {
                   ChannelPipeline pipeline = channel.pipeline();
                   pipeline.addLast(new RpcEncoder(RpcRequest.class)); // 编码 RPC 请求
                   pipeline.addLast(new RpcDecoder(RpcResponse.class)); // 解码 RPC 响应
                   pipeline.addLast(new RpcClientHandler()); // 处理 RPC 响应
               }
           });
           bootstrap.option(ChannelOption.TCP_NODELAY, true);
           // 连接 RPC 服务器
           ChannelFuture future = bootstrap.connect("127.0.0.1", 8087).sync();
           // 写入 RPC 请求数据并关闭连接
           Channel channel = future.channel();
           RpcRequest rpcRequest = new RpcRequest();
           rpcRequest.setRequestId(123456L);
           channel.writeAndFlush(rpcRequest).sync();
           channel.closeFuture().sync();
       } finally {
           group.shutdownGracefully();
       }
   }
}
public class RpcClientHandler extends SimpleChannelInboundHandler<RpcResponse> {
   @Override
   public void channelRead0(ChannelHandlerContext ctx, RpcResponse response) throws Exception {
       System.out.println(response.getRequestId());//处理响应
   }
   @Override
   public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
       cause.printStackTrace();
       ctx.close();
   }
}

使用 Netty 的好处是很方便地实现了非阻塞式的调用,关键部分都给出了注释。上述的代码虽然很多,并且和我们熟悉的 Socket 通信代码大相径庭,但大多数都是 Netty 的模板代码,启动服务器,配置编解码器等。真正的 RPC 封装操作大多集中在 Handler 的 channelRead 方法(负责读取)以及 channel.writeAndFlush 方法(负责写入)中。

public class RpcEncoder extends MessageToByteEncoder {
   private Class<?> genericClass;
   Serialization serialization = new Hessian2Serialization();
   public RpcEncoder(Class<?> genericClass) {
       this.genericClass = genericClass;
   }
   @Override
   public void encode(ChannelHandlerContext ctx, Object in, ByteBuf out) throws Exception {
       if (genericClass.isInstance(in)) {
           byte[] data = serialization.serialize(in);
           out.writeInt(data.length);
           out.writeBytes(data);
       }
   }
}
public class RpcDecoder extends ByteToMessageDecoder {
   private Class<?> genericClass;
   public RpcDecoder(Class<?> genericClass) {
       this.genericClass = genericClass;
   }
   Serialization serialization = new Hessian2Serialization();
   @Override
   public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
       if (in.readableBytes() < 4) {
           return;
       }
       in.markReaderIndex();
       int dataLength = in.readInt();
       if (in.readableBytes() < dataLength) {
           in.resetReaderIndex();
           return;
       }
       byte[] data = new byte[dataLength];
       in.readBytes(data);
       out.add(serialization.deserialize(data, genericClass));
   }
}

使用 Netty 不能保证返回的字节大小,所以需要加上 in.readableBytes() < 4 这样的判断,以及 in.markReaderIndex() 这样的标记,用来区分报文头和报文体。

同步与异步 阻塞与非阻塞

这两组传输特性经常被拿来做对比,很多文章声称 Socket 是同步阻塞的,Netty 是异步非阻塞,其实有点问题。

其实这两组并没有必然的联系,同步阻塞,同步非阻塞,异步非阻塞都有可能(同步非阻塞倒是没见过),而大多数使用 Netty 实现的 RPC 调用其实应当是同步非阻塞的(当然一般 RPC 也支持异步非阻塞)。

同步和异步关注的是消息通信机制
所谓同步,就是在发出一个调用时,在没有得到结果之前,该调用就不返回。但是一旦调用返回,就得到返回值了。
换句话说,就是由调用者主动等待这个调用的结果。

而异步则是相反,调用在发出之后,这个调用就直接返回了,所以没有返回结果。换句话说,当一个异步过程调用发出后,调用者不会立刻得到结果。而是在调用发出后,被调用者通过状态、通知来通知调用者,或通过回调函数处理这个调用。

如果需要 RPC 调用返回一个结果,该结果立刻被使用,那意味着着大概率需要是一个同步调用。如果不关心其返回值,则可以将其做成异步接口,以提升效率。

阻塞和非阻塞关注的是程序在等待调用结果(消息,返回值)时的状态.

阻塞调用是指调用结果返回之前,当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前,该调用不会阻塞当前线程。

在上述的例子中可以看出 Socket 通信我们显示声明了一个包含10个线程的线程池,每次请求到来,分配一个线程,等待客户端传递报文头和报文体的行为都会阻塞该线程,可以见得其整体是阻塞的。而在 Netty 通信的例子中,每次请求并没有分配一个线程,而是通过 Handler 的方式处理请求(联想 NIO 中 Selector),是非阻塞的。

使用同步非阻塞方式的通信机制并不一定同步阻塞式的通信强,所谓没有最好,只有更合适,而一般的同步非阻塞 通信适用于 1.网络连接数量多 2.每个连接的io不频繁 的场景,与 RPC 调用较为契合。而成熟的 RPC 框架的传输层和协议层通常也会提供多种选择,以应对不同的场景。

总结

本文堆砌了一些代码,而难点主要是对 Socket 的理解,和 Netty 框架的掌握。Netty 的学习有一定的门槛,但实际需要掌握的知识点其实并不多(仅仅针对 RPC 框架所涉及的知识点而言),学习 Netty ,个人推荐《Netty IN ACTION》以及 https://waylau.gitbooks.io/netty-4-user-guide/Getting%20Started/Before%20Getting%20Started.html 该网站的例子。

参考资料:

http://javatar.iteye.com/blog/1123915 – 梁飞

https://gitee.com/huangyong/rpc – 黄勇

666. 彩蛋

如果你对 RPC 并发感兴趣,欢迎加入我的知识一起交流。

知识星球

目前在知识星球(https://t.zsxq.com/2VbiaEu)更新了如下 Dubbo 源码解析如下:

01. 调试环境搭建
02. 项目结构一览
03. API 配置(一)之应用
04. API 配置(二)之服务提供者
05. API 配置(三)之服务消费者
06. 属性配置
07. XML 配置
08. 核心流程一览
...
一共 60 篇++

面试官:来,讲一下RPC 调用和 HTTP 调用的区别吧 OSI网络七层模型 在说RPC和HTTP的区别之前,我觉的有必要了解一下OSI的七层网络结构模型(虽然实际应用中基本上都是五层),它可以分为以下几层: (从上到下) 第一层:应用层。定义了用于在网络中进行通信和传输数据的接口; 第二层:表示层。定义不同的系统中数据的传输格式,编码和解码规范等; 第三层:会话层。管理用户的会话,控制用户间逻辑连接的建立和中断; 第四层:传输层。管理着网络中的端到端的数据传输; 第五层:网络层。定义网络设备间如何传输数据; 第六层:链路层。将上面的网络层的数据包封装成数据帧, 阅读详情

相关推荐

grpc-go源码剖析五十一之场景三:在同一条链路上,发起多次rpc调用时,为什么第二次之后的头帧字节数非常小呢?

本次我们要模拟的场景是: 在同一条链路上,发起多次rpc调用时,为什么第二次之后的头帧字节数非常小呢? 本次测试用例所需要的代码,已经上传到百度网盘了。 1、第1次调用SayHello方法时,抓取到的头帧情况? 2、第2次调用SayHello方法时,头帧是否压缩过? 3、第1次调用SayWorld方法时,头帧是否也是压缩过的? 4、第2次调用SayWorld方法时,头帧是否也是压缩过的? 5、在同一条链路上, 为什么第二次之后的rpc调用要比第一次效率高呢? 原因之一,就是传输头帧的字节数大幅降低

码二哥的技术池 2549

Netty对于Socket抽象

Netty对于Socket抽象 Socket通信与Netty各组件对应关系 模型图详解: Netty中NioEventLoop主要对应Socket中服务端while循环监听事件,这里的事件循环主要包括“新连接的接入”、“连接当前已存在的连接上的数据流读写”; Netty中Channel主要对应Socket连接,IO编程模型主要是Socket,NIO编程模型主要是SocketChanne...

泷泷养的乔小胖 1184

论文Agile Autonomy: Learning High-Speed Flight in the Wild开源代码运行记录

​ Agile Autonomy: Learning High-Speed Flight in the Wild Learning High-Speed Flight in the Wild 论文链接:https://www.science.org/doi/10.1126/scirobotics.abg5810 代码:https://github.com/uzh-rpg/agile_autonomy 国内复现:https://github.com/Howardcl/AgileAutonomyPX4

Hanamizukimr的博客 1491

网络通信协议的发展及socket/netty理解

诞生于冷战期间,起源于美国军方,发展行对成熟后,交予大学及商业机构,开发出民用网络。ARPANET(ARPA网) 最初的军事研究使用的网络,网络交换的核心是使用专门的小型计算机执行消息交换,专门的计算机被称为接口信息处理器(IMP)。IMP间使用电话线连接,同时期还有英国、法国等国家发展不同类型的计算机网络。NPC(网络控制协议) 随着网络的发展,互联的趋势增强。基于互联的需求,发展出了“数据包交换”的数学理论,使用数据包交换成为计算机之间通过网络通信的基本方式,如果进行具体的通信则涉及网络协议。最初的网络

Java后端技术栈 2462

静态与动态LACP链路聚合:原理、配置与排错实战指南

链路聚合技术是提升网络带宽与可靠性的核心方案,通过将多个物理端口逻辑捆绑,实现带宽叠加与链路冗余。其原理基于IEEE 802.3ad标准,通过负载均衡算法将数据流分布到不同物理链路,既避免了数据包乱序,又提升了整体吞吐量。该技术的核心价值在于消除单端口瓶颈、提供毫秒级故障切换,并能简化网络拓扑管理。在企业服务器接入、数据中心互联及虚拟化平台等场景中,链路聚合已成为构建高可用网络的基础。实践中,动态LACP模式通过协议报文协商,能主动检测链路故障并防止配置错误导致的网络环路,相比静态聚合更为可靠。本文将深入解

weixin_31412781的博客 270

S4HANA - Cost Elements成本要素

SAP这里面的配置逻辑很像,就是先建一个对象,然后不停给这个对象附加一些属性,给一个账户附加编号范围,附加账户组。所有模块的维度都在这个表里,看下图的GL,CO,COPA,AA,ML的都在ACDOCA里。要把这5个类型和六大要素对应,先得把六大要素和账户类型对应下(以下是个人理解,不知道对错):当然那个C是新来的,我觉得放在资产下面也行,就不画图了。S4的嵌入式分析是在业务逻辑都整套嵌入的情况下,预开发了数据模型,所以它能提供的就不仅是原始数据了,它能提供的是包含所有相关联的上下文的信息数据。

weixin_45689053的博客 2396

【RPC 专栏】深入理解 RPC 之协议篇

点击上方“芋道源码”,选择“置顶公众号”技术文章第一时间送达!源码精品专栏 中文详细注释的开源项目Java 并发源码合集RocketMQ 源码合集Sharding-JDB...

芋道源码 2587

Ubuntu20.04下Intel AX201网卡驱动安装全攻略:从内核升级到固件更新

本文详细介绍了在Ubuntu 20.04系统上解决Intel AX201无线网卡驱动问题的完整方案。针对戴尔游匣G15等新硬件,通过升级内核至HWE版本、从官方仓库获取最新固件文件,并调整BIOS设置,彻底解决Wi-Fi无法识别或连接不稳定的问题,为开发者提供了一套从诊断到修复的实践指南。

gpt4scribbler的博客 690

【RPC 专栏】深入理解 RPC 之动态代理篇

点击上方“芋道源码”,选择“置顶公众号”技术文章第一时间送达!源码精品专栏 中文详细注释的开源项目Java 并发源码合集RocketMQ 源码合集Sharding-JDB...

芋道源码 1820

细节增强卷积DEConv详解及代码复现

这种预训练模型能够捕捉图像的基本特征,为后续的端到端训练提供良好的初始参数。例如,在RESIDE和RESIDE-6K数据集上的实验结果表明,使用MSPLCK模块的MixDehazeNet-L模型在RESIDE-IN数据集上首次超过了42dB的PSNR指标,且在所有数据集上均优于先前的方法。例如,在RESIDE和RESIDE-6K数据集上的实验结果表明,使用MSPLCK模块的MixDehazeNet-L模型在RESIDE-IN数据集上首次超过了42dB的PSNR指标,且在所有数据集上均优于先前的方法。

hasakie的博客 1912

Anaconda报错no qt platform plugin could be initialized

今天因为在anaconda中安装了一个新包,安装成功后运行python 程序报错:no qt platform plugin could be initialized。 1.安装Anaconda3-4.2.0-Windows-x86_64,对应python版本为3.5.2,scikit learn版本是0.17。因为要用Isolation Forest算法,只有0.18以上版本scikit learn才包含此算法,所以想更新scikit learn。 conda install scikit-lear

zhang1806618的博客 1万+

【RPC 专栏】深入理解RPC之序列化篇 —— Kryo

点击上方“芋道源码”,选择“置顶公众号”技术文章第一时间送达!源码精品专栏 中文详细注释的开源项目Java 并发源码合集RocketMQ 源码合集Sharding-JDB...

芋道源码 1615

【深度解析TI InstaSPIN】无传感器FOC控制的核心方案

TI InstaSPIN通过“自动识别+通用观测器+开源工具链”的组合,解决了无传感器FOC控制开发难度大、周期长的核心痛点。其核心优势在于快速统一软件观测器的通用性与高精度,以及Fly Start闭环零速启动策略的高可靠性,可适配空调压缩机等家电电机的复杂运行需求。在空调外机双电机控制场景中,InstaSPIN与TI C2000系列MCU(F280013x/F28E12x)完美契合,借助MCU的高性能DSP内核与丰富外设,可实现双电机的精准同步控制,同时降低硬件成本与开发周期。

昔时扬尘处 329

聊聊 RPC 架构

大家好,我是不才陈某~当你在构建一个分布式系统时,势必需要考虑的一个问题是:如何实现服务与服务之间的调用?当然,你可以使用 Dubbo 或 Spring Cloud 等分布式服务框架来封装技术实现的复杂性,以此完成这个目标。不过,假如现在没有这些框架,需要你自己来实现远程调用,你会怎么做呢?很多人会选择实现一套 RPC 框架来调用远程服务。那么你了解 RPC 架构的基本结构吗?如果你想要自己实现 ...

码猿技术专栏 228

【考试大纲】中级多媒体应用设计师考试大纲

中级多媒体应用设计师考试大纲

邓邓子的博客 384

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

手写RPC框架(文末附代码)

目录 RPC是什么? 应用场景 RPC 优点 写RPC框架需要具备哪些知识? RPC原理(摘自:什么情况下使用 RPC ? - 知乎) Netty框架 具体代码 代码目录 api provider consumer proxy registry protocol 本地调用和远程调用 产生的对象有什么区别呢? RPC的调用速度如何? RPC是什么? RPC是远程过程调用(Remote Procedure Call)的缩写形式。通俗的理解就是我调用了一个函数func(args

trigger的博客 2494

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

33.服务之间的调用之RPC、Restful深入理解

33.服务之间的调用之RPC、Restful深入理解 2018年05月08日 01:52:42郑学炜阅读数 13577更多 分类专栏:6.框架 版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.youkuaiyun.com/u014590757/ar...

weixin_30853329的博客 188

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

【Protobuf系列】:从序列化与反序列化到消息类与Service:深入理解Protobuf以及RPC调用机制

本文从网络通信中的序列化需求出发,对比分析了HTTP、JSON和Protobuf三种数据组织方式。文章首先阐述了HTTP协议的文本格式特点,解释了如何通过特定格式实现消息边界判断;然后深入剖析了JSON文本序列化方式的优缺点,指出其可读性强但数据体积较大的特点;最后引入Protobuf二进制序列化方案,通过对比说明Protobuf采用字段编号替代字段名、使用紧凑编码等机制带来的性能优势,为后续深入讲解Protobuf的核心原理做铺垫。 【关键点】 网络通信本质传输字节流,需要序列化/反序列化机制 HTTP通

努力努力再努力wz的博客 269

[Ai Agent] 11 MCP进阶:手写客户端,让MCP连接万物 (Client)

本指南教你如何用Model Context Protocol (MCP) 解决AI工具孤岛问题。它不再需要为每个服务手写API,而是像插USB一样,让Agent通过通用客户端(Client)即插即用各种外部工具(Server)。

2401_87328929的博客 1371

深入理解零拷贝技术

点击上方“芋道源码”,选择“设为星标”管她前浪,还是后浪?能浪的浪,才是好浪!每天 10:33更新文章,每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路,很肝~...

芋艿V 144

构建可扩展 AI 系统:深入理解模型上下文协议(MCP)

本文深入介绍模型上下文协议(Model Context Protocol, MCP),展示其如何将语言模型与外部数据、工具和服务高效连接。文章解析了 MCP 的客户端-服务器架构、三大核心原语(资源、提示、工具)及通信流程,阐释了其在多集成、结构化访问和可维护性方面的优势。同时探讨了 MCP 的适用场景与局限,帮助开发者和企业在构建现代 AI 系统时做出合理选择,实现从孤立模型到集成化智能系统的转变。

等风来 1265
上一篇: 【Netty 专栏】Netty源码分析之NioEventLoop
下一篇: Java中高级面试题(5)
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值