Dubbo编解码(五)-Dubbo协议编码器

最新推荐文章于 2024-07-03 11:50:53 发布
最新推荐文章于 2024-07-03 11:50:53 发布
阅读量290 收藏
点赞数
分类专栏： Dubbo+Zookeeper 文章标签： dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38405646/article/details/115981449
版权

Dubbo编解码系列文章目录

Dubbo编解码(一)-原理
Dubbo编解码(二)-Codec2和AbstractCodec
Dubbo编解码(三)-TransportCodec
Dubbo编解码(五)-Dubbo协议编码器
Dubbo编解码(六)-Dubbo协议解码器

文章目录

ExchangeCodec#encode

覆写Codec2#encode实现

@Override
public void encode(Channel channel, ChannelBuffer buffer, Object msg) throws IOException {
	if (msg instanceof Request) {
		// 请求序列化
		encodeRequest(channel, buffer, (Request) msg);
	} else if (msg instanceof Response) {
		// 	响应序列化
		encodeResponse(channel, buffer, (Response) msg);
	} else {
		super.encode(channel, buffer, msg);
	}
}

encodeRequest-编码 请求对象

/**
  * 对 请求对象 进行编码，然后写入到buffer中
  *
  * @param channel 主要用于获取信息
  * @param buffer 最终要写入的通道缓存
  * @param req 请求对象
  * @throws IOException IOException
  */
protected void encodeRequest(Channel channel, ChannelBuffer buffer, Request req) throws IOException {
	// 根据通道channel获取序列化实例类
	// AbstractCodec#getSerialization
	Serialization serialization = getSerialization(channel, req);
	// header.
	// 构架header，长度16
	byte[] header = new byte[HEADER_LENGTH];
	// set magic number.
	// 设置魔法值，占用2个字节
	Bytes.short2bytes(MAGIC, header);

	// set request and serialization flag.
	// 在第3个字节设置 请求标识 + 序列化标识
	header[2] = (byte) (FLAG_REQUEST | serialization.getContentTypeId());
	// 双向传输
	if (req.isTwoWay()) {
		header[2] |= FLAG_TWOWAY;
	}
	// 心跳事件
	if (req.isEvent()) {
		header[2] |= FLAG_EVENT;
	}

	// set request id.
	// 设置requestId
	Bytes.long2bytes(req.getId(), header, 4);

	// encode request data.
	// writerIndex-写缓冲区首地址
	int savedWriteIndex = buffer.writerIndex();
	// 移动writeIndex，跳过buffer头部的16个字节，为的是下面往buffer写入请求体
	buffer.writerIndex(savedWriteIndex + HEADER_LENGTH);
	// 通道缓存输出流，在 ChannelBufferOutputStream类型对象 里面对buffer进行写入
	ChannelBufferOutputStream bos = new ChannelBufferOutputStream(buffer);

	// 心跳请求，写入一个空字节数组
	if (req.isHeartbeat()) {
		// heartbeat request data is always null
		// 通过getNullBytesOf获取一个空数组，再通过write方法写入到buffer中
		// ChannelBufferOutputStream#write 实际就是buffer#writeBytes
		bos.write(CodecSupport.getNullBytesOf(serialization));
	} else {
		// 对bos序列化，主要就是 把 ChannelBufferOutputStream类型对象 放到 ObjectOutput类型对象 中
		// 本质上就是把 OutputStream类型对象 放到 ObjectOutput类型对象 中
		ObjectOutput out = serialization.serialize(channel.getUrl(), bos);
		// 心跳事件
		if (req.isEvent()) {
			// 心跳事件请求体编码，向out中写入req.getData()
			// TODO 心跳事件请求体是什么？
			encodeEventData(channel, out, req.getData());
		} else {
			// 编码请求体，并写入out
			encodeRequestData(channel, out, req.getData(), req.getVersion());
		}
		// OutputStream#flush()
		out.flushBuffer();
		if (out instanceof Cleanable) {
			((Cleanable) out).cleanup();
		}
	}

	bos.flush();
	bos.close();
	// bos长度
	int len = bos.writtenBytes();
	// 校验长度是否符合协议规范
	checkPayload(channel, len);
	// 把body的长度(len)写入header的第12个字节
	Bytes.int2bytes(len, header, 12);

	// write
	// 定位指针到buffer开始的地方
	buffer.writerIndex(savedWriteIndex);
	// 写入header
	buffer.writeBytes(header); // write header.
	// 设置writerIndex到消息体结束的位置
	buffer.writerIndex(savedWriteIndex + HEADER_LENGTH + len);
}

CodecSupport#getNullBytesOf

/**
  * Get the null object serialize result byte[] of Serialization from the cache,
  * if not, generate it first.
  * 从缓存中获取 空对象序列化结果-字节数组，如果没有就生成一个
  *
  * @param s Serialization Instances
  * @return serialize result of null object
  */
public static byte[] getNullBytesOf(Serialization s) {
	return ID_NULLBYTES_MAP.computeIfAbsent(s.getContentTypeId(), k -> {
		//Pre-generated Null object bytes
		// 初始化一个容量为32的字节数组
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		byte[] nullBytes = new byte[0];
		try {
			ObjectOutput out = s.serialize(null, baos);
			// 就是写一个null到baos中
			out.writeObject(null);
			// OutputStream#flush()
			out.flushBuffer();
			nullBytes = baos.toByteArray();
			baos.close();
		} catch (Exception e) {
			logger.warn("Serialization extension " + s.getClass().getName() + " not support serializing null object, return an empty bytes instead.");
		}
		return nullBytes;
	});
}

DubboCodec#encodeRequestData-编码 请求对象体

/**
  * 向out中写入 请求体信息
  * 
  * @param channel 通道
  * @param out 要写入的输出对象
  * @param data 请求体数据
  * @param version 版本号
  * @throws IOException IOException
  */
@Override
protected void encodeRequestData(Channel channel, ObjectOutput out, Object data, String version) throws IOException {
	RpcInvocation inv = (RpcInvocation) data;
	// 写入版本号，用于支持 服务端版本隔离 和 服务端隐式参数 传递给客户端的特性
	out.writeUTF(version);
	// https://github.com/apache/dubbo/issues/6138
	// 写入调用接口
	String serviceName = inv.getAttachment(INTERFACE_KEY);
	if (serviceName == null) {
		serviceName = inv.getAttachment(PATH_KEY);
	}
	out.writeUTF(serviceName);
	// 写入接口指定的版本号
	out.writeUTF(inv.getAttachment(VERSION_KEY));
	// 写入方法名称
	out.writeUTF(inv.getMethodName());
	// 写入参数类型
	out.writeUTF(inv.getParameterTypesDesc());
	// 循环写入参数值
	Object[] args = inv.getArguments();
	if (args != null) {
		for (int i = 0; i < args.length; i++) {
			// encodeInvocationArgument TODO
			out.writeObject(encodeInvocationArgument(channel, inv, i));
		}
	}
	// 写入隐式参数
	out.writeAttachments(inv.getObjectAttachments());
}

encodeResponse-编码 响应对象

/**
  * 对 响应对象 进行编码，然后写入到buffer中
  *
  * @param channel 主要用于获取信息
  * @param buffer 最终要写入的通道缓存
  * @param res 响应对象
  * @throws IOException IOException
  */
protected void encodeResponse(Channel channel, ChannelBuffer buffer, Response res) throws IOException {
	int savedWriteIndex = buffer.writerIndex();
	try {
		Serialization serialization = getSerialization(channel, res);
		// header.
		byte[] header = new byte[HEADER_LENGTH];
		// set magic number.
		Bytes.short2bytes(MAGIC, header);
		// set request and serialization flag.
		header[2] = serialization.getContentTypeId();
		if (res.isHeartbeat()) {
			header[2] |= FLAG_EVENT;
		}
		// set response status.
		// 在第4个字节存储响应状态
		byte status = res.getStatus();
		header[3] = status;
		// set request id.
		Bytes.long2bytes(res.getId(), header, 4);

		buffer.writerIndex(savedWriteIndex + HEADER_LENGTH);
		ChannelBufferOutputStream bos = new ChannelBufferOutputStream(buffer);

		// encode response data or error message.
		if (status == Response.OK) {
			if(res.isHeartbeat()){
				// heartbeat response data is always null
				bos.write(CodecSupport.getNullBytesOf(serialization));
			}else {
				ObjectOutput out = serialization.serialize(channel.getUrl(), bos);
				if (res.isEvent()) {
					encodeEventData(channel, out, res.getResult());
				} else {
					// 编码响应体
					encodeResponseData(channel, out, res.getResult(), res.getVersion());
				}
				out.flushBuffer();
				if (out instanceof Cleanable) {
					((Cleanable) out).cleanup();
				}
			}
		} else {
			// 写入失败信息
			ObjectOutput out = serialization.serialize(channel.getUrl(), bos);
			out.writeUTF(res.getErrorMessage());
			out.flushBuffer();
			if (out instanceof Cleanable) {
				((Cleanable) out).cleanup();
			}
		}

		bos.flush();
		bos.close();

		int len = bos.writtenBytes();
		checkPayload(channel, len);
		Bytes.int2bytes(len, header, 12);
		// write
		buffer.writerIndex(savedWriteIndex);
		buffer.writeBytes(header); // write header.
		buffer.writerIndex(savedWriteIndex + HEADER_LENGTH + len);
	} catch (Throwable t) {
		// clear buffer
		// 如果编码失败，则复位buffer
		buffer.writerIndex(savedWriteIndex);
		// send error message to Consumer, otherwise, Consumer will wait till timeout.
		// 将编码响应异常 发送给consumer，否则只能等到超时
		if (!res.isEvent() && res.getStatus() != Response.BAD_RESPONSE) {
			Response r = new Response(res.getId(), res.getVersion());
			r.setStatus(Response.BAD_RESPONSE);

			// 超过payload限制
			if (t instanceof ExceedPayloadLimitException) {
				logger.warn(t.getMessage(), t);
				try {
					r.setErrorMessage(t.getMessage());
					// 告知 客户端 数据包长度 超过限制
					channel.send(r);
					return;
				} catch (RemotingException e) {
					logger.warn("Failed to send bad_response info back: " + t.getMessage() + ", cause: " + e.getMessage(), e);
				}
			} else {
				// FIXME log error message in Codec and handle in caught() of IoHanndler?
				logger.warn("Fail to encode response: " + res + ", send bad_response info instead, cause: " + t.getMessage(), t);
				try {
					// 告知 客户端 编码失败的具体原因
					r.setErrorMessage("Failed to send response: " + res + ", cause: " + StringUtils.toString(t));
					channel.send(r);
					return;
				} catch (RemotingException e) {
					logger.warn("Failed to send bad_response info back: " + res + ", cause: " + e.getMessage(), e);
				}
			}
		}

		// Rethrow exception
		if (t instanceof IOException) {
			throw (IOException) t;
		} else if (t instanceof RuntimeException) {
			throw (RuntimeException) t;
		} else if (t instanceof Error) {
			throw (Error) t;
		} else {
			throw new RuntimeException(t.getMessage(), t);
		}
	}
}

DubboCodec#encodeResponseData-编码 响应对象体

/**
  * 向out中写入 响应体信息
  * 
  * @param channel 通道
  * @param out 要写入的输出对象
  * @param data 响应体数据
  * @param version 版本号
  * @throws IOException IOException
  */
@Override
protected void encodeResponseData(Channel channel, ObjectOutput out, Object data, String version) throws IOException {
	Result result = (Result) data;
	// currently, the version value in Response records the version of Request
	// 判断 客户端请求的版本 是否支持 服务端 参数返回
	boolean attach = Version.isSupportResponseAttachment(version);
	// 获取 结果中的异常信息
	Throwable th = result.getException();
	if (th == null) {
		// 提取正常返回结果
		Object ret = result.getValue();
		if (ret == null) {
			out.writeByte(attach ? RESPONSE_NULL_VALUE_WITH_ATTACHMENTS : RESPONSE_NULL_VALUE);
		} else {
			// 在 编码结果 前，先写一个 字节标志
			out.writeByte(attach ? RESPONSE_VALUE_WITH_ATTACHMENTS : RESPONSE_VALUE);
			// 写调用结果
			out.writeObject(ret);
		}
	} else {
		// 标记调用异常，序列化异常
		out.writeByte(attach ? RESPONSE_WITH_EXCEPTION_WITH_ATTACHMENTS : RESPONSE_WITH_EXCEPTION);
		out.writeThrowable(th);
	}

	if (attach) {
		// returns current version of Response to consumer side.
		// 返回dubbo的版本给消费端
		result.getObjectAttachments().put(DUBBO_VERSION_KEY, Version.getProtocolVersion());
		// 返回服务隐式参数
		out.writeAttachments(result.getObjectAttachments());
	}
}
星光之子0317
关注
专栏目录
Dubbo协议的编解码实现
Gemini的博客
09-27 256
dubbo协议的编码 我们先回顾一下netty server端的handler链条初始化。从这里我们可以知道在NettyCodecAdapter里面实现了2个内部类，分别是encoder和decoder，对应着编码和解码的操作。而编码就是直接使用DubboCodec的encode方法，严格按照dubbo协议的格式，将数据编码成二进制数据。decoder则是除了严格按照dubbo协议的格式，读取header和data之外，还需要对拆包的情况进行处理
源码分析Dubbo编码解码实现原理---Dubbo协议编码
2401_84048034的博客
04-22 302
做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
Dubbo 源码分析之编解码
历史上的今天
03-09 1937
本文为 Qunar 技术沙龙投稿，版权归原作者所有，未经允许，请勿转载。 原文地址：http://mp.weixin.qq.com/s/POHfCj4ioO072S-DcNeM2Q 作者：张雷，2014年加入 Qunar，目前在去哪儿网大住宿事业部用户订单组担任后端开发工程师，从事酒店交易相关研发工作。 【CSDN 有奖征稿啦】技术之路，共同进步，有优质移动开发、VR/A...
Dubbo 源码解析 - 网络编解码
最新发布
qq_33240556的博客
07-03 171
在Dubbo中，网络通信是通过Netty实现的，而Netty中的网络编解码则是由Decoder和Encoder组件完成的。在具体实现上，Dubbo使用了Google的Protocol Buffers（protobuf）作为默认的序列化工具，它提供了高效的二进制编码，并且支持跨语言的互操作性。这两个类分别实现了Decoder和Encoder接口，它们负责将接收到的字节流解码为DubboMessage对象，以及将DubboMessage对象编码为字节流。其中，消息头包含了诸如序列化方式、服务接口名等信息；
Dubbo编解码(六)-Dubbo协议解码器
星光之子的博客
04-23 478
Dubbo编解码系列文章目录 Dubbo编解码(一)-原理 Dubbo编解码(二)-Codec2和AbstractCodec Dubbo编解码(三)-TransportCodec Dubbo编解码(五)-Dubbo协议编码器 文章目录Dubbo编解码系列文章目录
Dubbo源码分析之编解码
06-13 468
编码器 private class InternalEncoder extends MessageToByteEncoder { @Override protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception { org.apache.d...
dubbo源码分析-编解码
yangxiaobo118的博客
12-05 446
dubbo源码分析-编解码编解码入口编码入口解码入口消费者请求编码服务提供者解码总结 编解码保证消息能被正常的解析，从而保证服务消费的正确性。dubbo使用定长消息头的方式解决半包等通信过程中的问题。 编解码入口 NettyCodecAdapter里维护了编码解码器，在构建netty pipeline里构造NettyCodecAdapter，并传入相应的handler。 NettyCodecAda...
Dubbo源码分析十六、dubbo编解码
vinylon的博客
12-29 521
单独分析一下dubbo的编解码过程。默认情况下使用dubbo自己定义的编码协议。 我们先来看一下 Dubbo 数据包结构。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vh5EtRPv-1609227698562)(.\imgs\data-format.jpg)] Dubbo 数据包分为消息头和消息体，消息头用于存储一些元信息，比如魔数（Magic），数据包类型（Request/Response），消息体长度（Data Length）等。消息体中用于存储具体的调用消息，比如
dubbo-remoting-netty4:dubbo项目的netty远程模块
06-13
3. **自定义协议支持**：Dubbo有自己的RPC协议，Netty4提供了灵活的编解码器，使得Dubbo能够轻松实现自己的协议解析。通过ChannelHandler，Dubbo可以定制自己的消息处理器，处理各种复杂的业务逻辑。 4. **心跳检测...
DUBBO源码分析八---服务调用过程
qq_51562781的博客
12-06 1998
"2021SC@SDUSC" 2.3.2.2 调用服务 本小节，我们从 ChannelEventRunnable 开始分析，该类的主要代码如下： public class ChannelEventRunnable implements Runnable { private final ChannelHandler handler; private final Channel channel; private final ChannelState state;
DUBBO源码分析七---服务调用过程
qq_51562781的博客
11-24 949
"2021SC@SDUSC" 1. 简介 在前面的文章中，我们分析了 Dubbo SPI、服务导出与引入、以及集群容错方面的代码。经过前文的铺垫，本篇文章我们终于可以分析服务调用过程了。Dubbo 服务调用过程比较复杂，包含众多步骤，比如发送请求、编解码、服务降级、过滤器链处理、序列化、线程派发以及响应请求等步骤。限于篇幅原因，本篇文章无法对所有的步骤一一进行分析。本篇文章将会重点分析请求的发送与接收、编解码、线程派发以及响应的发送与接收等过程，至于服务降级、过滤器链和序列化大家自行进行分析，也可以
dubbo 协议编解码详解
eve_z的博客
02-15 1217
protected void encodeRequest(Channel channel, ChannelBuffer buffer, Request req) throws IOException { Serialization serialization = getSerialization(channel); // header. byte[] header = new byte[HEADER_LENGTH];//16个字节 //
深入理解Dubbo远程调用编解码器原理：Dubbo协议编码器+解码器
2401_83384536的博客
03-23 1028
上一篇主要给出了 Dubbo目前的协议格式，有了标准协议约束，我们需要再探讨Dubbo是怎么实现编解码的。在讲解编解码实现前，先熟悉一下编解码设计关系，如图6-4所示。在图6-4中,AbstractCodec主要提供基础能力，比如校验报文长度和查找具体编解码器等。TransportCodec主要抽象编解码实现，自动帮我们去调用序列化、反序列实现和自动cleanup流。
24. Dubbo原理解析-编码解码之编码解码流程
斩秋的专栏
12-03 5621
这里把ExchangeCodec和DubboCodec放一起来讲解dubbo传输的底层协议组成以及它的编码解码过程。   传输协议 协议格式 协议头 ：header 是16个字节的定长数据    =  2 //short类型的MAGIC = (short) 0xdabb + 1 //一个字节的消息标志位，用来表示消息是request还是//response,twoway还是oneway
Dubbo 编解码那些事
vivo互联网技术
04-13 466
一、背景 笔者在一次维护基础公共组件的过程中，不小心修改了类的包路径。糟糕的是，这个类被各业务在facade中进行了引用、传递。幸运的是，同一个类，在提供者和消费者的包路径不一致，没有引起各业务报错。 怀揣着好奇，对于Dubbo的编解码做了几次的Debug学习，在此分享一些学习经验。 1.1 RPC的爱与恨 Dubbo作为Java语言的RPC框架，优势之一在于屏蔽了调用细节，能够像调用本地方法一样调用远程服务，不必为数据格式抓耳饶腮。正是这一特性，也引入来了一些问题。 比如引入facade包.
dubbo网络通信的编解码过程解析
xiaovfight的专栏
03-24 462
写这篇文章的初衷是最近被别人问到dubbo的通信协议及底层序列化过程，发现自己比较欠缺这一块的知识。所以这个周末，结合了dubbo源码和一些网络教程，总结了一下。 编码和解码 首先做一下名词解释 编码：序列化，它将对象序列化为字节数组，用于网络传输，数据持久化或者其他用途。 解码：反序列化，把从网络，磁盘等读取的字节数还原成原始对象，以方便后续的业务逻辑操作。 dubbo在IP和TCP协议之上，又...
Dubbo篇：基于Netty实现Dubbo协议编解码源码分析
走在路上
07-26 1055
Dubbo协议设计参考了TCP/IP协议，包括协议头和协议体两部分。16字节报文头主要携带了魔法数（0xdabb，用于分割两个不同请求），以及当前请求报文是否是Request、Response、心跳和事件的信息，请求时也会携带当前报文体内序列化协议编号，另外还有请求状态、请求唯一表示和报文体长度。 ...
dubbo rpc解码配置
07-25
在Dubbo中，RPC结果的解码由Dubbo的序列化/反序列化...另外，具体的RPC结果解码逻辑可能还涉及到其他配置或代码，例如Dubbo的编码器、解码器等。如果你遇到了特定的问题，请提供更多详细信息，以便我更好地帮助你解决。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值