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

说了这么多废话,才提到对象的传输,不知道您是不是已经不耐烦了。一个系统内部的消息传递,没有对象传递是不太现实的。下面就来说说,怎么传递对象。

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

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

[java]  view plain  copy
  1. // 服务端设置一个处理客户端消息和各种消息事件的类(Handler)  
  2. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {  
  3.     @Override  
  4.     public ChannelPipeline getPipeline() throws Exception {  
  5.         return Channels.pipeline(  
  6.                 new ObjectDecoder(ClassResolvers.cacheDisabled(this.getClass().getClassLoader())),  
  7.                 new ObjectServerHandler());  
  8.     }  
  9. });  

[java]  view plain  copy
  1. // 客户端设置一个处理服务端消息和各种消息事件的类(Handler)  
  2. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {  
  3.     @Override  
  4.     public ChannelPipeline getPipeline() throws Exception {  
  5.         return Channels.pipeline(new ObjectEncoder(), new ObjectClientHandler());  
  6.     }  
  7. });  

要传递对象,自然要有一个被传递模型,一个简单的Pojo,当然,实现序列化接口是必须的。
[java]  view plain  copy
  1. public class Command implements Serializable {  
  2.   
  3.     private static final long serialVersionUID = 7590999461767050471L;  
  4.   
  5.     private String actionName;  
  6.   
  7.     public String getActionName() {  
  8.         return actionName;  
  9.     }  
  10.   
  11.     public void setActionName(String actionName) {  
  12.         this.actionName = actionName;  
  13.     }  
  14. }  

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

[java]  view plain  copy
  1. /** 
  2.  * 对象传递服务端代码 
  3.  * 
  4.  */  
  5. public class ObjectServerHandler extends SimpleChannelHandler {  
  6.   
  7.     /** 
  8.      * 当接受到消息的时候触发 
  9.      */  
  10.     @Override  
  11.     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)  
  12.             throws Exception {  
  13.         Command command = (Command) e.getMessage();  
  14.         // 打印看看是不是我们刚才传过来的那个  
  15.         System.out.println(command.getActionName());  
  16.     }  
  17. }  

[java]  view plain  copy
  1. /** 
  2.  * 对象传递,客户端代码 
  3.  * 
  4.  */  
  5. public class ObjectClientHandler extends SimpleChannelHandler {  
  6.   
  7.     /** 
  8.      * 当绑定到服务端的时候触发,给服务端发消息。 
  9.      */  
  10.     @Override  
  11.     public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) {  
  12.         // 向服务端发送Object信息  
  13.         sendObject(e.getChannel());  
  14.     }  
  15.   
  16.     /** 
  17.      * 发送Object 
  18.      * 
  19.      */  
  20.     private void sendObject(Channel channel) {  
  21.         Command command = new Command();  
  22.         command.setActionName("Hello action.");  
  23.         channel.write(command);  
  24.     }  
  25.   
  26. }  

启动后,服务端正常打印结果:Hello action.

简单梳理一下思路:

通过Netty传递,都需要基于流,以ChannelBuffer的形式传递。所以,Object -> ChannelBuffer.
Netty提供了转换工具,需要我们配置到Handler。
样例从客户端 -> 服务端,单向发消息,所以在客户端配置了编码,服务端解码。如果双向收发,则需要全部配置Encoder和Decoder。
这里需要注意,注册到Server的Handler是有顺序的,如果你颠倒一下注册顺序:

[java]  view plain  copy
  1. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {  
  2.     @Override  
  3.     public ChannelPipeline getPipeline() throws Exception {  
  4.         return Channels.pipeline(  
  5.                 new ObjectServerHandler(),  
  6.                 new ObjectDecoder(ClassResolvers.cacheDisabled(this.getClass().getClassLoader())));  
  7.     }  
  8. });  

结果就是,会先进入我们自己的业务,再进行解码。这自然是不行的,会强转失败。至此,你应该会用Netty传递对象了吧。

你可能感兴趣的:(Netty)