编解码器指的是转换两种不同格式的数据，在网络编程中几乎是必不可少的。比如将String转成ByteBuf，将Student转成String等等。
netty中，编码器处理的是出站消息，因而会继承ChannelOutboundHandler，解码器处理的是入站消息，因而会继承CHannelnboundHandler。
编码器的抽象类MessageToMessageDecoder<I>，其中I是要对什么类型的消息编码。解码器的抽象类MessageToMessageDecoder<I>，其中I是要对什么类型的消息进行解码。还有一个抽象类MessageToMessageCodec<INBOUND_IN, OUTBOUND_IN>，表示既可以对消息进行编码，也可以进行解码。
在应用程序中，自定义的编码器或者解码器一般直接继承上述三者即可。比如netty内置的StringEncoder是将String类型转换为ByteBuf；StringDecoder是将ByteBuf转换为String。
下面用两个例子来演示下编解码器的处理方式
-
编码器的例子
应用程序将往channel写入一个Student对象，我们先定义一个编码器，将Student转换成String，再用netty内置的StringEncoder，将String转换成ByteBuf，再写入channel。
编码器.png
EmbeddedChannel channel = new EmbeddedChannel(
//记录日志
new LoggingHandler(LogLevel.DEBUG),
//字符串编码器，将String编码成ByteBuf
new StringEncoder(StandardCharsets.UTF_8),
//Student编码器，将Student转成String
new MessageToMessageEncoder<Student>() {
@Override
protected void encode(ChannelHandlerContext ctx, Student msg, List<Object> out) throws Exception {
out.add(new Gson().toJson(msg));
}
}
);
Student student = new Student(10, "zhangsan");
channel.writeOutbound(student);
-
解码器的例子
应用程序从channel接收数据后，先用netty内置的StringDecoder，将ByteBuf转换为String，再用自定义的解码器，将String转换为Student，这样应用程序的其他handler就可以直接对Student对象处理了
decoder.png
EmbeddedChannel channel = new EmbeddedChannel(
new LoggingHandler(LogLevel.DEBUG),
new StringDecoder(StandardCharsets.UTF_8),
new MessageToMessageDecoder<String>() {
@Override
protected void decode(ChannelHandlerContext ctx, String msg, List<Object> out) throws Exception {
out.add(new Gson().fromJson(msg, Student.class));
}
},
new SimpleChannelInboundHandler<Student>() {
@Override
protected void channelRead0(ChannelHandlerContext ctx, Student msg) throws Exception {
System.out.println("receive new msg " + msg);
}
}
);
Student student = new Student(10, "zhangsan");
String studentStr = new Gson().toJson(student);
channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes(studentStr.getBytes(StandardCharsets.UTF_8)));
接下来，我们来看下编码器的源码
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
CodecOutputList out = null;
try {
//判断msg的类型编码器是否支持
if (acceptOutboundMessage(msg)) {
out = CodecOutputList.newInstance();
@SuppressWarnings("unchecked")
//类型强转，因为在声明中已经明确指定I类型了
I cast = (I) msg;
try {
//调用具体实现，对消息进行编码，并放在out中
encode(ctx, cast, out);
} finally {
//cast如果是ReferenceType的需要将引用计数-1，因为传递给下一个handler已经不是cast对象了
ReferenceCountUtil.release(cast);
}
if (out.isEmpty()) {
throw new EncoderException(
StringUtil.simpleClassName(this) + " must produce at least one message.");
}
//如果当前msg的类型，编码器不支持对其进行编码，那么直接传递给下一个handler来处理
} else {
ctx.write(msg, promise);
}
} catch (EncoderException e) {
throw e;
} catch (Throwable t) {
throw new EncoderException(t);
} finally {
if (out != null) {
try {
final int sizeMinusOne = out.size() - 1;
if (sizeMinusOne == 0) {
//这里将编码后的对象传递给下一个handler处理
ctx.write(out.getUnsafe(0), promise);
} else if (sizeMinusOne > 0) {
// Check if we can use a voidPromise for our extra writes to reduce GC-Pressure
// See https://github.com/netty/netty/issues/2525
if (promise == ctx.voidPromise()) {
writeVoidPromise(ctx, out);
} else {
writePromiseCombiner(ctx, out, promise);
}
}
} finally {
out.recycle();
}
}
}
}
编码器对out的处理，有个地方不太理解，就是当out元素个数大于1的时候。
下面是解码器的源码
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
CodecOutputList out = CodecOutputList.newInstance();
try {
if (acceptInboundMessage(msg)) {
@SuppressWarnings("unchecked")
I cast = (I) msg;
try {
decode(ctx, cast, out);
} finally {
ReferenceCountUtil.release(cast);
}
} else {
out.add(msg);
}
} catch (DecoderException e) {
throw e;
} catch (Exception e) {
throw new DecoderException(e);
} finally {
try {
int size = out.size();
for (int i = 0; i < size; i++) {
ctx.fireChannelRead(out.getUnsafe(i));
}
} finally {
out.recycle();
}
}
}
解码器与编码器的逻辑大致相同，先判断要解码的类型当前的解码器是否支持，若支持的话，进行类型的转换。若不支持，直接将msg添加到out结果列表中，最后再对out列表循环，将列表元素传递给下一个handler处理。
