Netty权威指南

2.3.3 NIO创建的TimeServer源码分析 31
2.3.4 NIO客户端序列图 36
2.3.5 NIO创建的TimeClient源码分析 39
2.4 AIO编程 45
2.4.1 AIO创建的TimeServer源码分析 46
2.4.2 AIO创建的TimeClient源码分析 52
2.4.3 AIO版本时间服务器运行结果 56
2.5 4种I/O的对比 58
2.5.1 概念澄清 58
2.5.2 不同I/O模型对比 60
2.6 选择Netty的理由 60
2.6.1 不选择Java原生NIO编程的原因 61
2.6.2 为什么选择Netty 62
2.7 总结 63
入门篇 Netty NIO开发指南
第3章 Netty入门应用 66
3.1 Netty开发环境的搭建 66
3.1.1 下载Netty的软件包 67
3.1.2 搭建Netty应用工程 67
3.2 Netty服务端开发 68
3.3 Netty客户端开发 73
3.4 运行和调试 76
3.4.1 服务端和客户端的运行 76
3.4.2 打包和部署 77
3.5 总结 78
第4章 TCP粘包/拆包问题的解决之道 79
4.1 TCP粘包/拆包 79
4.1.1 TCP粘包/拆包问题说明 80
4.1.2 TCP粘包/拆包发生的原因 80
4.1.3 粘包问题的解决策略 81
4.2 未考虑TCP粘包导致功能异常案例 82
4.2.1 TimeServer的改造 82
4.2.2 TimeClient的改造 83
4.2.3 运行结果 84
4.3 利用LineBasedFrameDecoder解决TCP粘包问题 88
4.3.1 支持TCP粘包的TimeServer 88
4.3.2 支持TCP粘包的TimeClient 90
4.3.3 运行支持TCP粘包的时间服务器程序 93
4.3.4 LineBasedFrameDecoder和StringDecoder的原理分析 98
4.4 总结 99
第5章 分隔符和定长解码器的应用 100
5.1 DelimiterBasedFrameDecoder应用开发 101
5.1.1 DelimiterBasedFrameDecoder服务端开发 101
5.1.2 DelimiterBasedFrameDecoder客户端开发 104
5.1.3 运行DelimiterBasedFrameDecoder服务端和客户端 106
5.2 FixedLengthFrameDecoder应用开发 108
5.2.1 FixedLengthFrameDecoder服务端开发 108
5.2.2 利用telnet命令行测试EchoServer服务端 110
5.3 总结 111
中级篇 Netty编解码开发指南
第6章 编解码技术 114
6.1 Java序列化的缺点 115
6.1.1 无法跨语言 115
6.1.2 序列化后的码流太大 115
6.1.3 序列化性能太低 118
6.2 业界主流的编解码框架 121
6.2.1 Google的Protobuf介绍 121
6.2.2 Facebook的Thrift介绍 123
6.2.3 JBoss Marshalling介绍 124
6.3 总结 125
第7章 Java序列化 126
7.1 Netty Java序列化服务端开发 126
7.2 Java序列化Netty客户端开发 132
7.3 运行结果 135
7.4 总结 137
第8章 Google Protobuf编解码 138
8.1 Protobuf的入门 139
8.1.1 Protobuf开发环境搭建 139
8.1.2 Protobuf编解码开发 141
8.1.3 运行Protobuf例程 143
8.2 Netty的Protobuf服务端开发 143
8.2.1 Protobuf版本的图书订购服务端开发 144
8.2.2 Protobuf版本的图书订购客户端开发 146
8.2.3 Protobuf版本的图书订购程序功能测试 149
8.3 Protobuf的使用注意事项 152
8.4 总结 153
第9章 JBoss Marshalling编解码 154
9.1 Marshalling开发环境准备 154
9.2 Netty的Marshalling服务端开发 155
9.3 Netty的Marshalling客户端开发 158
9.4 运行Marshalling客户端和服务端例程 160
9.5 总结 162
高级篇 Netty多协议开发和应用
第10章 HTTP协议开发应用 164
10.1 HTTP协议介绍 165
10.1.1 HTTP协议的URL 165
10.1.2 HTTP请求消息（HttpRequest） 165
10.1.3 HTTP响应消息（HttpResponse） 168
10.2 Netty HTTP服务端入门开发 169
10.2.1 HTTP服务端例程场景描述 170
10.2.2 HTTP服务端开发 170
10.2.3 Netty HTTP文件服务器例程运行结果 178
10.3 Netty HTTP+XML协议栈开发 182
10.3.1 开发场景介绍 183
10.3.2 HTTP+XML协议栈设计 186
10.3.3 高效的XML绑定框架JiBx 187
10.3.4 HTTP+XML编解码框架开发 195
10.3.5 HTTP+XML协议栈测试 211
10.3.6 小结 213
10.4 总结 214
第11章 WebSocket协议开发 215
11.1 HTTP协议的弊端 216
11.2 WebSocket入门 216
11.2.1 WebSocket背景 217
11.2.2 WebSocket连接建立 218
11.2.3 WebSocket生命周期 219
11.2.4 WebSocket连接关闭 220
11.3 Netty WebSocket协议开发 221
11.3.1 WebSocket服务端功能介绍 221
11.3.2 WebSocket服务端开发 222
11.3.3 运行WebSocket服务端 230
11.4 总结 231
第12章 UDP协议开发 233
12.1 UDP协议简介 234
12.2 UDP服务端开发 235
12.3 UDP客户端开发 238
12.4 运行UDP例程 240
12.5 总结 241
第13章 文件传输 242
13.1 文件的基础知识 243
13.1.1 文件的概念 243
13.1.2 文件路径 243
13.1.3 文件名称 244
13.1.4 FileChannel简介 244
13.2 Netty文件传输开发 245
13.3 运行Netty文件传输服务例程 248
13.4 总结 250
第14章 私有协议栈开发 251
14.1 私有协议介绍 251
14.2 Netty协议栈功能设计 253
14.2.1 网络拓扑图 253
14.2.2 协议栈功能描述 254
14.2.3 通信模型 254
14.2.4 消息定义 255
14.2.5 Netty协议支持的字段类型 256
14.2.6 Netty协议的编解码规范 257
14.2.7 链路的建立 259
14.2.8 链路的关闭 260
14.2.9 可靠性设计 260
14.2.10 安全性设计 262
14.2.11 可扩展性设计 262
14.3 Netty协议栈开发 263
14.3.1 数据结构定义 263
14.3.2 消息编解码 267
14.3.3 握手和安全认证 271
14.3.4 心跳检测机制 275
14.3.5 断连重连 278
14.3.6 客户端代码 279
14.3.7 服务端代码 281
14.4 运行协议栈 282
14.4.1 正常场景 282
14.4.2 异常场景：服务端宕机重启 283
14.4.3 异常场景：客户端宕机重启 286
14.5 总结 286
源码分析篇 Netty功能介绍和源码分析
第15章 ByteBuf和相关辅助类 290
15.1 ByteBuf功能说明 290
15.1.1 ByteBuf的工作原理 291
15.1.2 ByteBuf的功能介绍 296
15.2 ByteBuf源码分析 310
15.2.1 ByteBuf的主要类继承关系 311
15.2.2 AbstractByteBuf源码分析 312
15.2.3 AbstractReferenceCountedByteBuf源码分析 321
15.2.4 UnpooledHeapByteBuf源码分析 323
15.2.5 PooledByteBuf内存池原理分析 328
15.2.6 PooledDirectByteBuf源码分析 331
15.3 ByteBuf相关的辅助类功能介绍 334
15.3.1 ByteBufHolder 334
15.3.2 ByteBufAllocator 335
15.3.3 CompositeByteBuf 336
15.3.4 ByteBufUtil 338
15.4 总结 339
第16章 Channel和Unsafe 340
16.1 Channel 功能说明 340
16.1.1 Channel的工作原理 341
16.1.2 Channel的功能介绍 342
16.2 Channel源码分析 345
16.2.1 Channel的主要继承关系类图 345
16.2.2 AbstractChannel源码分析 346
16.2.3 AbstractNioChannel源码分析 349
16.2.4 AbstractNioByteChannel源码分析 352
16.2.5 AbstractNioMessageChannel源码分析 356
16.2.6 AbstractNioMessageServerChannel源码分析 357
16.2.7 NioServerSocketChannel源码分析 358
16.2.8 NioSocketChannel源码分析 360
16.3 Unsafe功能说明 366
16.4 Unsafe源码分析 367
16.4.1 Unsafe继承关系类图 367
16.4.2 AbstractUnsafe源码分析 367
16.4.3 AbstractNioUnsafe源码分析 377
16.4.4 NioByteUnsafe源码分析 380
16.5 总结 387
第17章 ChannelPipeline和ChannelHandler 389
17.1 ChannelPipeline功能说明 390
17.1.1 ChannelPipeline的事件处理 390
17.1.2 自定义拦截器 392
17.1.3 构建pipeline 393
17.1.4 ChannelPipeline的主要特性 394
17.2 ChannelPipeline源码分析 394
17.2.1 ChannelPipeline的类继承关系图 394
17.2.2 ChannelPipeline对ChannelHandler的管理 394
17.2.3 ChannelPipeline的inbound事件 397
17.2.4 ChannelPipeline的outbound事件 398
17.3 ChannelHandler功能说明 399
17.3.1 ChannelHandlerAdapter功能说明 400
17.3.2 ByteToMessageDecoder功能说明 400
17.3.3 MessageToMessageDecoder功能说明 401
17.3.4 LengthFieldBasedFrameDecoder功能说明 402
17.3.5 MessageToByteEncoder功能说明 405
17.3.6 MessageToMessageEncoder功能说明 406
17.3.7 LengthFieldPrepender功能说明 406
17.4 ChannelHandler源码分析 407
17.4.1 ChannelHandler的类继承关系图 407
17.4.2 ByteToMessageDecoder源码分析 408
17.4.3 MessageToMessageDecoder源码分析 411
17.4.4 LengthFieldBasedFrameDecoder源码分析 413
17.4.5 MessageToByteEncoder源码分析 417
17.4.6 MessageToMessageEncoder源码分析 418
17.4.7 LengthFieldPrepender源码分析 419
17.5 总结 420
第18章 EventLoop和EventLoopGroup 421
18.1 Netty的线程模型 421
18.1.1 Reactor单线程模型 422
18.1.2 Reactor多线程模型 423
18.1.3 主从Reactor多线程模型 424
18.1.4 Netty的线程模型 425
18.1.5 最佳实践 427
18.2 NioEventLoop源码分析 427
18.2.1 NioEventLoop设计原理 427
18.2.2 NioEventLoop继承关系类图 428
18.2.3 NioEventLoop 429
18.3 总结 440
第19章 Future和Promise 441
19.1 Future功能 441
19.2 ChannelFuture源码分析 446
19.3 Promise功能介绍 448
19.4 Promise源码分析 450
19.4.1 Promise继承关系图 450
19.4.2 DefaultPromise 450
19.5 总结 453
架构和行业应用篇 Netty高级特性
第20章 Java多线程编程在Netty中的应用 456
20.1 Java内存模型与多线程编程 456
20.1.1 硬件的发展和多任务处理 456
20.1.2 Java内存模型 457
20.2 Netty的并发编程实践 459
20.2.1 对共享的可变数据进行正确的同步 459
20.2.2 正确的使用锁 460
20.2.3 volatile的正确使用 462
20.2.4 CAS指令和原子类 465
20.2.5 线程安全类的应用 467
20.2.6 读写锁的应用 470
20.2.7 线程安全性文档说明 472
20.2.8 不要依赖线程优先级 473
20.3 总结 474
第21章 Netty架构剖析 475
21.1 Netty逻辑架构 475
21.1.1 Reactor通信调度层 476
21.1.2 职责链ChannelPipeline 476
21.1.3 业务逻辑编排层（Service ChannelHandler） 477
21.2 关键架构质量属性 477
21.2.1 高性能 477
21.2.2 可靠性 480
21.2.3 可定制性 483
21.2.4 可扩展性 483
21.3 总结 483
第22章 Netty行业应用 484
22.1 Netty在互联网行业的应用 485
22.1.1 传统垂直架构面临的问题 485
22.1.2 阿里分布式服务框架Dubbo 485
22.1.3 Dubbo的架构介绍 487
22.1.4 Netty在Dubbo中的应用 489
22.1.5 Dubbo框架集成Netty源码分析 491
22.2 Netty在大数据领域的应用 496
22.3 Netty在游戏行业的应用 497
22.3.1 游戏服务端架构介绍 498
22.3.2 Netty在游戏服务端的应用 501
22.4 总结 502
第23章 Netty未来展望 503
23.1 应用范围 503
23.2 技术演进 504
23.3 社区活跃度 504
23.4 Road Map 504
23.5 总结 505
附录A Netty参数配置表 506

.　　内容介绍
　　本书涵盖了Netty NIO框架的绝大部分知识点，包括Java I/O的演进历史、传统BIO通信的弊端、Java 4种I/O通信模型的优缺点对比。以及Netty入门、Netty编解码框架、文件传输、多协议和私有协议栈定制和开发。在源码分析章节，详细介绍了ByteBuf、Channel和Unsafe、ChannelPipeline和ChannelHandler、NioEventLoop、ChannelFuture和ChannelPromise的设计原理和源码分析。在高级应用章节，介绍了Netty的逻辑架构模型、Netty的线程模型和行业应用。最后附录了Netty启动配置参数项说明。
　　联系方式
　　尽管我也有技术洁癖，希望诸事完美，但是由于Netty代码的庞杂和涉及到的知识点太多，一本书籍很难涵盖所有的功能点。如有遗漏或者错误，恳请大家能够及时批评和指正，如果你有好的建议或者想法，也可以联系我。我的联系方式如下：邮箱： neu_lilinfeng@sina.com 新浪微博: Nettying微信：Nettying。
　　致谢
　　如果说个人能够改变自己命运的话，对于程序员来说，唯有通过不断的学习和实践，努力提升自己的技能，才有可能找到更好的机会，充分发挥和体现自己的价值。我希望本书能够为你的成功助一臂之力。
　　感谢博文视点的策划编辑丁一琼和幕后的美编，正是你们的辛苦工作才保证了本书能够顺利出版；感谢华为Netty爱好者和关注本书的领导同事们的支持，你们的理解和鼓励为我提供了足够的勇气。感谢我的家人和老婆的支持，写书占用了我几乎所有的业余时间，没有你们的理解和支持，我很难安心写作。
　　最后感谢Netty中国社区的朋友，我的微博粉丝和所有喜欢Netty的朋友们，你们对技术的热情是鼓励我写书的最重要动力，没有你们，就没有本书。希望大家一如既往的喜欢NIO编程，喜欢Netty，以及相互交流和分享，共同推动整个国内异步高性能通信领域的技术发展。
　　李林锋 5月11日于南京紫轩阁
　　

.　　 23. headers.set(HttpHeaders.Names.HOST, InetAddress.getLocalHost()
　　 24. .getHostAddress());
　　 25. headers.set(HttpHeaders.Names.CONNECTION, HttpHeaders.Values.CLOSE);
　　 26. headers.set(HttpHeaders.Names.ACCEPT_ENCODING,
　　 27. HttpHeaders.Values.GZIP.toString() + ','
　　 28. + HttpHeaders.Values.DEFLATE.toString());
　　 29. headers.set(HttpHeaders.Names.ACCEPT_CHARSET,
　　 30. "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
　　 31. headers.set(HttpHeaders.Names.ACCEPT_LANGUAGE, "zh");
　　 32. headers.set(HttpHeaders.Names.USER_AGENT,
　　 33. "Netty xml Http Client side");
　　 34. headers.set(HttpHeaders.Names.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
　　 35. }
　　 36. HttpHeaders.setContentLength(request, body.readableBytes());
　　 37. out.add(request);
　　 38. }
　　 39. }
　　 第17行首先调用父类的encode0，将业务需要发送的POJO对象Order实例通过JiBx序列化为XML字符串，随后将它封装成Netty的ByteBuf。第18行对消息头进行判断，如果业务侧自定义和定制了消息头，则使用业务侧设置的HTTP消息头，如果业务侧没有设置，则构造新的HTTP消息头。
　　 第20～35行用来构造和设置默认的HTTP消息头，由于通常情况下HTTP通信双方更关注消息体本身，所以这里采用了硬编码的方式，如果要产品化，可以做成XML配置文件，允许业务自定义配置，以提升定制的灵活性。
　　 第36行很重要，由于请求消息消息体不为空，也没有使用Chunk方式，所以在HTTP消息头中设置消息体的长度Content-Length，完成消息体的XML序列化后将重新构造的HTTP请求消息加入到out中，由后续Netty的HTTP请求编码器继续对HTTP请求消息进行编码。
　　 下面我们来看父类AbstractHttpXmlEncoder的实现。
　　 代码清单10-9 HTTP+XML HTTP请求消息编码基类 AbstractHttpXmlEncoder
　　 14. public abstract class AbstractHttpXmlEncoder extends
　　 15. MessageToMessageEncoder {
　　 16. IBindingFactory factory = null;
　　 17. StringWriter writer = null;
　　 18. final static String CHARSET_NAME = "UTF-8"
　　 19. final static Charset UTF_8 = Charset.forName(CHARSET_NAME);
　　 20.
　　 21. protected ByteBuf encode0(ChannelHandlerContext ctx, Object body)
　　 22. throws Exception {
　　 23. factory = BindingDirectory.getFactory(body.getClass());
　　 24. writer = new StringWriter();
　　 25. IMarshallingContext mctx = factory.createMarshallingContext();
　　 26. mctx.setIndent(2);
　　 27. mctx.marshalDocument(body, CHARSET_NAME, null, writer);
　　 28. String xmlStr = writer.toString();
　　 29. writer.close();
　　 30. writer = null;
　　 31. ByteBuf encodeBuf = Unpooled.copiedBuffer(xmlStr, UTF_8);
　　 32. return encodeBuf;
　　 33. }
　　 34.
　　 35. @Override
　　 36. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
　　 37. throws Exception {
　　 38. // 释放资源
　　 39. if (writer != null) {
　　 40. writer.close();
　　 41. writer = null;
　　 42. }
　　 43. }
　　 44. }
　　 首先看下23～30行，代码很熟悉，在JiBx章节已经介绍了XML序列化和反序列化的相关类库使用，在此将业务的Order实例序列化为XML字符串。第31行将XML字符串包装成Netty的ByteBuf并返回，实现了HTTP请求消息的XML编码。
　　 下面继续看下HttpXmlRequest是如何实现的。
　　 代码清单10-10 HTTP+XML请求消息HttpXmlRequest
　　 9. public class HttpXmlRequest {
　　 10. private FullHttpRequest request;
　　 11. private Object body;
　　 12.
　　 13. public HttpXmlRequest(FullHttpRequest request, Object body) {
　　 14. this.request = request;
　　 15. this.body = body;
　　 16. }
　　 17.
　　 18. /**
　　 19. * @return the request
　　 20. */
　　 21. public final FullHttpRequest getRequest() {
　　 22. return request;
　　 23. }
　　 24.
　　 25. /**
　　 26. * @param request
　　 27. * the request to set
　　 28. */
　　 29. public final void setRequest(FullHttpRequest request) {
　　 30. this.request = request;
　　 31. }
　　 32.
　　 33. /**
　　 34. * @return the object
　　 35. */
　　 36. public final Object getBody() {
　　 37. return body;
　　 38. }
　　 39.
　　 40. /**
　　 41. * @param object
　　 42. * the object to set
　　 43. */
　　 44. public final void setBody(Object body) {
　　 45. this.body = body;
　　 46. }
　　 47. }
　　 它包含两个成员变量FullHttpRequest和编码对象Object，用于实现和协议栈之间的解耦。
　　 2．HTTP+XML请求消息解码类
　　 HTTP服务端接收到HTTP+XML请求消息后，需要从HTTP消息体中获取请求码流，通过JiBx框架对它进行反序列化，得到请求POJO对象，然后对结果进行封装，回调到业务handler对象，业务得到的就是解码后的POJO对象和HTTP消息头。
　　 下面就看下具体实现。
　　 代码清单10-11 HTTP+XML HTTP请求消息解码类 HttpXmlRequestDecoder
　　 20. public class HttpXmlRequestDecoder extends
　　 21. AbstractHttpXmlDecoder {
　　 22.
　　 23. public HttpXmlRequestDecoder(Class clazz) {
　　 24. this(clazz, false);
　　 25. }
　　 26.
　　 27. public HttpXmlRequestDecoder(Class clazz, boolean isPrint) {
　　 28. super(clazz, isPrint);
　　 29. }
　　 30.
　　 31. @Override
　　 32. protected void decode(ChannelHandlerContext arg0, FullHttpRequest arg1,
　　 33. List arg2) throws Exception {
　　 34. if (!arg1.getDecoderResult().isSuccess()) {
　　 35. sendError(arg0, BAD_REQUEST);
　　 36. return;
　　 37. }
　　 38. HttpXmlRequest request = new HttpXmlRequest(arg1, decode0(arg0,
　　 39. arg1.content()));
　　 40. arg2.add(request);
　　 41. }
　　 42.
　　 43. private static void sendError(ChannelHandlerContext ctx,
　　 44. HttpResponseStatus status) {
　　 45. FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1,
　　 46. status, Unpooled.copiedBuffer("Failure: " + status.toString()
　　 47. + "\
　　", CharsetUtil.UTF_8));
　　 48. response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8");
　　 49. ctx.writeAndFlush(response).addListener(ChannelFutureListener. CLOSE);
　　 50. }
　　 51. }
　　 HttpXmlRequestDecoder有两个参数，分别为需要解码的对象的类型信息和是否打印HTTP消息体码流的码流开关，码流开关默认关闭。第34～37行首先对HTTP请求消息本身的解码结果进行判断，如果已经解码失败，再对消息体进行二次解码已经没有意义。
　　 第43～50行，如果HTTP消息本身解码失败，则构造处理结果异常的HTTP应答消息返回给客户端。作为演示程序，本例程没有考虑XML消息解码失败后的异常封装和处理，在商用项目中需要统一的异常处理机制，提升协议栈的健壮性和可靠性。
　　 第38行通过HttpXmlRequest和反序列化后的Order对象构造HttpXmlRequest实例，最后将它添加到解码结果List列表中。
　　 继续看下它的父类AbstractHttpXmlDecoder的实现。
　　 代码清单10-12 HTTP+XML HTTP请求消息解码类 AbstractHttpXmlDecoder
　　 18. public abstract class AbstractHttpXmlDecoder extends
　　 19. MessageToMessageDecoder {
　　 20. private IBindingFactory factory;
　　 21. private StringReader reader;
　　 22. private Class clazz;
　　 23. private boolean isPrint;
　　 24. private final static String CHARSET_NAME = "UTF-8"
　　 25. private final static Charset UTF_8 = Charset.forName(CHARSET_NAME);
　　 26.
　　 27. protected AbstractHttpXmlDecoder(Class clazz) {
　　 28. this(clazz, false);
　　 29. }
　　 30.
　　 31. protected AbstractHttpXmlDecoder(Class clazz, boolean isPrint) {
　　 32. this.clazz = clazz;
　　 33. this.isPrint = isPrint;
　　 34. }
　　 35.
　　 36. protected Object decode0(ChannelHandlerContext arg0, ByteBuf body)
　　 37. throws Exception {
　　 38. factory = BindingDirectory.getFactory(clazz);
　　 39. String content = body.toString(UTF_8);
　　 40. if (isPrint)
　　 41. System.out.println("The body is : " + content);
　　 42. reader = new StringReader(content);
　　 43. IUnmarshallingContext uctx = factory.createUnmarshallingContext();
　　 44. Object result = uctx.unmarshalDocument(reader);
　　 45. reader.close();
　　 46. reader = null;
　　 47. return result;
　　 48. }
　　 49. @Override
　　 50. public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
　　 51. throws Exception {
　　 52. // 释放资源
　　 53. if (reader != null) {
　　 54. reader.close();
　　 55. reader = null;
　　 56. }
　　 57. }
　　 58. }
　　 第38～47行从HTTP的消息体中获取请求码流，然后通过JiBx类库将XML转换成POJO对象。最后，根据码流开关决定是否打印消息体码流。增加码流开关往往是为了方便问题定位，在实际项目中，需要打印到日志中。
　　 第53～55行，如果解码发生异常，要判断StringReader是否已经关闭，如果没有关闭，则关闭输入流并通知JVM对其进行垃圾回收。
　　 3．HTTP+XML响应消息编码类
　　 对于响应消息，用户可能并不关心HTTP消息头之类的，它将业务处理后的POJO对象丢给HTTP+XML协议栈，由基础协议栈进行后续的处理。为了降低业务的定制开发难度，我们首先封装一个全新的HTTP XML应答对象，它的实现如下。
　　 代码清单10-13 HTTP+XML HTTP XML应答消息 HttpXmlResponse
　　 9. public class HttpXmlResponse {
　　 10. private FullHttpResponse httpResponse;
　　 11. private Object result;
　　 12.
　　 13. public HttpXmlResponse(FullHttpResponse httpResponse,Object result){
　　 14. this.httpResponse = httpResponse;
　　 15. this.result = result;
　　 16. }
　　 17.
　　 18. /**
　　 19. * @return the httpResponse
　　 20. */
　　 21. public final FullHttpResponse getHttpResponse() {
　　 22. return httpResponse;
　　 23. }
　　 24.
　　 25. /**
　　 26. * @param httpResponse
　　 27. * the httpResponse to set
　　 28. */
　　 29. public final void setHttpResponse(FullHttpResponse httpResponse) {
　　 30. this.httpResponse = httpResponse;
　　 31. }
　　 32.
　　 33. /**
　　 34. * @return the body
　　 35. */
　　 36. public final Object getResult() {
　　 37. return result;
　　 38. }
　　 39.
　　 40. /**
　　 41. * @param body
　　 42. * the body to set
　　 43. */
　　 44. public final void setResult(Object result) {
　　 45. this.result = result;
　　 46. }
　　 47. }
　　 它包含两个成员变量：FullHttpResponse和Object，Object就是业务需要发送的应答POJO对象。
　　 下面继续看应答消息的XML编码类实现。
　　 代码清单10-14 HTTP+XML 应答消息编码类 HttpXmlResponseEncoder
　　 17. public class HttpXmlResponseEncoder extends
　　 18. AbstractHttpXmlEncoder {
　　 19.
　　 20. /*
　　 21. * (non-Javadoc)
　　 22. *
　　 ……