Netty的客户端与服务端的通信

客户端——服务器连接

先啰嗦两句，如果你还不知道Netty是做什么的能做什么。那可以先简单的搜索了解一下。我只能说Netty是一个NIO的框架，可以用于开发分布式的Java程序。具体能做什么，各位可以尽量发挥想象。技术，是服务于人而不是局限住人的。

如果你已经万事具备，那么我们先从一段代码开始。程序员们习惯的上手第一步，自然是"Hello world"，不过Netty官网的例子却偏偏抛弃了"Hello world"。那我们就自己写一个最简单的"Hello world"的例子，作为上手。

​

1. 1. 
      
2. /**
3. * Netty 服务端代码
4. *
5. * @author lihzh
6. * @alia OneCoder
7. * @blog http://www.coderli.com
8. */
9. public class HelloServer {
10. 
    
11. public static void main(String args[]) {
12. // Server服务启动器
13. ServerBootstrap bootstrap = new ServerBootstrap(
14. new NioServerSocketChannelFactory(
15. Executors.newCachedThreadPool(),
16. Executors.newCachedThreadPool()));
17. // 设置一个处理客户端消息和各种消息事件的类(Handler)
18. bootstrap
19. .setPipelineFactory(new ChannelPipelineFactory() {
20. @Override
21. public ChannelPipeline getPipeline()
22. throws Exception {
23. return Channels
24. .pipeline(new HelloServerHandler());
25. }
26. });
27. // 开放8000端口供客户端访问。
28. bootstrap.bind(new InetSocketAddress(8000));
29. }
30. 
    
31. private static class HelloServerHandler extends
32. SimpleChannelHandler {
33. 
    
34. /**
35. * 当有客户端绑定到服务端的时候触发，打印"Hello world, I'm server."
36. *
37. * @alia OneCoder
38. * @author lihzh
39. */
40. @Override
41. public void channelConnected(
42. ChannelHandlerContext ctx,
43. ChannelStateEvent e) {
44. System.out.println("Hello world, I'm server.");
45. }
46. }
47. }
    1. 
       

1. /**
2. * Netty 客户端代码
3. *
4. * @author lihzh
5. * @alia OneCoder
6. * @blog http://www.coderli.com
7. */
8. public class HelloClient {
9. 
   
10. public static void main(String args[]) {
11. // Client服务启动器
12. ClientBootstrap bootstrap = new ClientBootstrap(
13. new NioClientSocketChannelFactory(
14. Executors.newCachedThreadPool(),
15. Executors.newCachedThreadPool()));
16. // 设置一个处理服务端消息和各种消息事件的类(Handler)
17. bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
18. @Override
19. public ChannelPipeline getPipeline() throws Exception {
20. return Channels.pipeline(new HelloClientHandler());
21. }
22. });
23. // 连接到本地的8000端口的服务端
24. bootstrap.connect(new InetSocketAddress(
25. "127.0.0.1", 8000));
26. }
27. 
    
28. private static class HelloClientHandler extends SimpleChannelHandler {
29. 
    
30. 
    
31. /**
32. * 当绑定到服务端的时候触发，打印"Hello world, I'm client."
33. *
34. * @alia OneCoder
35. * @author lihzh
36. */
37. @Override
38. public void channelConnected(ChannelHandlerContext ctx,
39. ChannelStateEvent e) {
40. System.out.println("Hello world, I'm client.");
41. }
42. }
43. }
    1. 
       

既然是分布式的，自然要分多个服务。Netty中，需要区分Server和Client服务。所有的Client都是绑定在Server上的，他们之间是不能通过Netty直接通信的。（自己采用的其他手段，不包括在内。）。白话一下这个通信过程，Server端开放端口，供Client连接，Client发起请求，连接到Server指定的端口，完成绑定。随后便可自由通信。其实就是普通Socket连接通信的过程。

Netty框架是基于事件机制的，简单说，就是发生什么事，就找相关处理方法。就跟着火了找119，抢劫了找110一个道理。所以，这里，我们处理的是当客户端和服务端完成连接以后的这个事件。什么时候完成的连接，Netty知道，他告诉我了，我就负责处理。这就是框架的作用。Netty，提供的事件还有很多，以后会慢慢的接触和介绍。

客户端————服务器传递对象

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

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

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

​​​​​

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

​​​​​

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

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

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. }
    1. 
       

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

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. }
    1. 
       

​​​​​

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

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

简单梳理一下思路：

通过Netty传递，都需要基于流，以ChannelBuffer的形式传递。所以，Object -> ChannelBuffer.

Netty提供了转换工具，需要我们配置到Handler。

样例从客户端 -> 服务端，单向发消息，所以在客户端配置了编码，服务端解码。如果双向收发，则需要全部配置Encoder和Decoder。

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

​​​​​

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