Java NIO框架Netty教程(八) Object对象传递

• 上一篇：Java NIO框架Netty教程(七)-再谈收发信息次数问题    http://www.it165.net/pro/html/201207/3287.html
  
  说了这么多废话，才提到对象的传输，不知道您是不是已经不耐烦了。一个系统内部的消息传递，没有对象传递是不太现实的。下面就来说说，怎么传递对象。

  如果，您看过前面的介绍，如果您善于专注本质，勤于思考。您应该也会想到，我们说过，Netty的消息传递都是基于流，通过ChannelBuffer传递的，那么自然，Object也需要转换成ChannelBuffer来传递。好在Netty本身已经给我们写好了这样的转换工具。ObjectEncoder和ObjectDecoder。

  工具怎么用？再一次说说所谓的本质，我们之前也说过，Netty给我们处理自己业务的空间是在灵活的可子定义的Handler上的，也就是说，如果我们自己去做这个转换工作，那么也应该在Handler里去做。而Netty，提供给我们的ObjectEncoder和Decoder也恰恰是一组Handler。于是，修改Server和Client的启动代码：

  
  
  view source print ?

  01. // 设置一个处理客户端消息和各种消息事件的类(Handler)

  02. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

  03. @Override

  04. public ChannelPipeline getPipeline() throws Exception {

  05. return Channels.pipeline(

  06. new ObjectDecoder(ClassResolvers.cacheDisabled(this

  07. .getClass().getClassLoader())),

  08. new ObjectServerHandler());

  09. }

  10. });// 设置一个处理服务端消息和各种消息事件的类(Handler)

  11. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

  12. @Override

  13. public ChannelPipeline getPipeline() throws Exception {

  14. return Channels.pipeline(new ObjectEncoder(),

  15. new ObjectClientHandler());

  16. }

  17. });
  
  

  要传递对象，自然要有一个被传递模型，一个简单的Pojo，当然，实现序列化接口是必须的。

  
  
  view source print ?

  01. /**

  02. * @author lihzh

  03. * @alia OneCoder

  04. * @blog http://www.it165.net

  05. */

  06. public class Command implements Serializable {

  07.  

  08. private static final long serialVersionUID = 7590999461767050471L;

  09.  

  10. private String actionName;

  11.  

  12. public String getActionName() {

  13. return actionName;

  14. }

  15.  

  16. public void setActionName(String actionName) {

  17. this.actionName = actionName;

  18. }

  19. }
  
  

  服务端和客户端里，我们自定义的Handler实现如下：

  
  
  view source print ?

  01. /**

  02. * 对象传递服务端代码

  03. *

  04. * @author lihzh

  05. * @alia OneCoder

  06. * @blog http://www.it165.net

  07. */

  08. public class ObjectServerHandler extends SimpleChannelHandler {

  09.  

  10. /**

  11. * 当接受到消息的时候触发www.it165.net

  12. */

  13. @Override

  14. public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)

  15. throws Exception {

  16. Command command = (Command) e.getMessage();

  17. // 打印看看是不是我们刚才传过来的那个

  18. System.out.println(command.getActionName());

  19. }

  20. }/**

  21. * 对象传递，客户端代码

  22. *

  23. * @author lihzh

  24. * @alia OneCoder

  25. * @blog http://www.it165.net

  26. */

  27. public class ObjectClientHandler extends SimpleChannelHandler {

  28.  

  29. /**

  30. * 当绑定到服务端的时候触发，给服务端发消息。

  31. *

  32. * @author lihzh

  33. * @alia OneCoder

  34. */

  35. @Override

  36. public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {

  37. // 向服务端发送Object信息

  38. sendObject(e.getChannel());

  39. }

  40.  

  41. /**

  42. * 发送Object

  43. *

  44. * @param channel

  45. * @author lihzh

  46. * @alia OneCoder

  47. */

  48. private void sendObject(Channel channel) {

  49. Command command = new Command();

  50. command.setActionName("Hello action.");

  51. channel.write(command);

  52. }

  53.  

  54. }
  
  

  启动后，服务端正常打印结果：Hello action.

  简单梳理一下思路：

  1. 通过Netty传递，都需要基于流，以ChannelBuffer的形式传递。所以，Object -> ChannelBuffer.
  2. Netty提供了转换工具，需要我们配置到Handler。
  3. 样例从客户端 -> 服务端，单向发消息，所以在客户端配置了编码，服务端解码。如果双向收发，则需要全部配置Encoder和Decoder。

  这里需要注意，注册到Server的Handler是有顺序的，如果你颠倒一下注册顺序：

  
  
  view source print ?

  01. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

  02. @Override

  03. public ChannelPipeline getPipeline() throws Exception {

  04. return Channels.pipeline(new ObjectServerHandler(),

  05. new ObjectDecoder(ClassResolvers.cacheDisabled(this

  06. .getClass().getClassLoader()))

  07. );

  08. }

  09. });
  
  

  结果就是，会先进入我们自己的业务，再进行解码。这自然是不行的，会强转失败。至此，你应该会用Netty传递对象了吧。
  
  阅读下一篇：Java NIO框架Netty教程(九) Object对象编/解码   http://www.it165.net/pro/html/201207/3328.html