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

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

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

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

 

view sourceprint?

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 sourceprint?

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 sourceprint?

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 sourceprint?

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传递对象了吧。