深入理解Apache Mina （3）---- 与IoHandler相关的几个类

在上一篇文档中我们已经了解了IoFilter的用法和其在Mina中的作用，作为Mina数据传输过程中比较重要的组件，IoFilter起到了承上启下的作用----接收数据，编/解码，将数据传递到逻辑层，当数据传递地到逻辑层时，IoFilter的使命就完成了，那么逻辑层的数据由谁来处理呢？如何处理的？这就是本文要讲述的内容----IoHandler。

 

在介绍IoFilter的时候，文中首先是从IoFilter的结构和其在Mina中的作用谈起的，最后添加了一个使用IoFilter的例子，之前我将其传给几个同学看时，感觉这种方式比较晦涩，应该将例子提到前面，由于时间的关系我不能在对IoFilter的介绍做过多的修改，所以在本篇文档中我就先以一个例子开头，介绍IoHandler，希望这种讲述方式能对你理解Mina有更多的帮助。

 

好了，言归正传，我们的例子还是以上篇文档中的IoFilter的例子为基础，在此基础上着重突出IoHandler的作用。

Java代码  

1. <span style="font-size: small;">ServerMain:  
2. public class ServerMain {  
3.  public static void main(String[] args) throws IOException {  
4.   SocketAddress address = new InetSocketAddress  
5.   
6. ("localhost", 4321);  
7.   IoAcceptor acceptor = new SocketAcceptor();  
8.   IoServiceConfig config = acceptor.getDefaultConfig  
9.   
10. ();  
11.   
12.   // 配置数据的编解码器  
13.   config.getFilterChain().addLast("codec",  
14.     new ProtocolCodecFilter(new   
15.   
16. ObjectSerializationCodecFactory()));  
17.   config.getFilterChain().addLast("logger", new   
18.   
19. LoggingFilter());  
20.     
21.   // 绑定服务器端口  
22.   acceptor.bind(address, new ServerHandler());  
23.   System.out.println("  服务器开始在 8000 端口监听   
24.   
25. .......");  
26.  }  
27. }   
28. ServerHandler:  
29. public class ServerHandler extends IoHandlerAdapter {  
30.  // 创建会话  
31.  public void sessionOpened(IoSession session) throws   
32.   
33. Exception {  
34.   System.out.println("  服务器创建了会话  ");  
35.   session.write("  服务器创建会话时发送的信息 。");  
36.  }  
37.   
38.  // 发送信息  
39.  public void messageSent(IoSession session, Object message)   
40.   
41. throws Exception {  
42.  }  
43.   
44.  // 接收信息  
45.  public void messageReceived(IoSession session, Object   
46.   
47. message)  
48.    throws Exception {  
49.  }  
50. }   
51. ClientMain:  
52. public class ClientMain {  
53.   
54.  public static void main(String[] args) {  
55.   SocketAddress address = new InetSocketAddress  
56.   
57. ("localhost", 4321);  
58.   IoConnector connector = new SocketConnector();  
59.   IoServiceConfig config =   
60.   
61. connector.getDefaultConfig();  
62.    
63.   // 配置数据的编解码器  
64.   config.getFilterChain().addLast("codec",  
65.     new ProtocolCodecFilter(new   
66.   
67. ObjectSerializationCodecFactory()));  
68.   config.getFilterChain().addLast("logger", new   
69.   
70. LoggingFilter());  
71.   
72.   // 连接到服务器  
73.   connector.connect(address, new ClientHandler());  
74.   System.out.println(" 已经连接到了服务器 " + address);  
75.  }  
76. }  
77.    
78. ClientHandler:  
79. public class ClientHandler extends IoHandlerAdapter {  
80.   
81.  // 发送信息  
82.  public void messageSent(IoSession session, Object message)   
83.   
84. throws Exception {    
85.  }  
86.   
87.  // 接收信息  
88.  public void messageReceived(IoSession session, Object   
89.   
90. message)  
91.    throws Exception {  
92.   System.out.println("  客户端接收到的服务器的信息是  "   
93.   
94. + message);  
95.  }  
96. }   
97. </span>  

 

上面给出里这个例子中的主要的代码，当先后启动服务器和客户端后，服务器会在客户端连接到服务器后发送一个字符串的消息。这个消息的发送就是在IoHandler中发送的。IoHandler在Mina中属于业务层，这里的IoHandler更相是J2EE中的Servlet的作用，在IoHandler中你可以不用考虑底层数据的封装和转换，前提是你已经在IoFilter中已经完成了数据的转换。这里需要提到的一个是，所谓数据的转换，是指将二进制数据转换成Java中的可用对象或者是基本类型的数据。由于网络传输中传输的都是二进制数据，这就需要有一个专门的数据转换层，就Mina中的编解码器来实现这个功能。如果使用RMI，对于这个问题应该不陌生，二进制和对象之间的转化过程其实就是对象的序列化和反序列化的过程。关于Mina中实现对象的序列化和反序列化会在后续的文档中详细介绍，在此不在赘述。

 

既然IoHandler是逻辑层，我们就用IoHandler实现一个简单的逻辑实现。先听一个小故事：一个淘气的小孩要去KFC买汉堡，由于KFC生意比较好，人比较多，服务员忙不过来，于是KFC专门设立了一个自动售汉堡的机器，这个机器只是一个简单的数据收发装置，（由于汉堡的价格时常变化，所以价格会实时更新，因此该机器需要和KFC的汉堡的价格服务器相连）小朋友买汉堡时只要向机器中投入硬币，机器就会查询服务器，看价格是否符合，若符合，则送给小朋友一个汉堡

，若不符合则提示小朋友钱不够，买不到这个汉堡。

 

上面是我自己虚构的一个小故事，我们先不管现实中的KFC是如何运作的，我们就当故事是真的了，那么现在这个小的项目分配给了我们，我们需要抽象出它的需求：

客户端要向服务器发送数据，查询价格，根据价格是否合理给出相应的显示服务器接收客户度的价格查询请求，根据服务器中存储的价格信息，返回响应的结果。

根据上面的需求，我们使用Mina来实现上面的服务器和客户端，程序的代码如下(完整代码在附件中)：

Java代码  

1. <span style="font-size: small;">KFCFoodPriceHandler(服务器句柄):  
2. public class KFCFoodPriceHandler extends IoHandlerAdapter {  
3.  // 创建会话  
4.  public void sessionOpened(IoSession session) throws   
5.   
6. Exception {  
7. //  System.out.println("  服务器创建了会话  ");  
8.  }  
9.   
10.  // 接收信息  
11.  public void messageReceived(IoSession session, Object   
12.   
13. message)  
14.    throws Exception {  
15.   HashMap<String, Object> map = (HashMap<String,   
16.   
17. Object>) message;  
18.   String buythings = (String) map.get("购买");  
19. //  System.out.println("  服务器接收到的信息 " +   
20.   
21. buythings);  
22.   if (buythings.equals("汉堡")) {  
23.    HashMap<String, Object> map2 = new   
24.   
25. HashMap<String, Object>();  
26.    map2.put("食品", "汉堡");  
27.    map2.put("价格", 4);  
28.    session.write(map2);  
29.   } else if (buythings.equals("鸡翅")) {  
30.    HashMap<String, Object> map2 = new   
31.   
32. HashMap<String, Object>();  
33.    map2.put("食品", "鸡翅");  
34.    map2.put("价格", 5);  
35.    session.write(map2);  
36.   } else {  
37.    session.write(" 该种物品已经出售完毕，谢谢  
38.   
39. 惠顾！");  
40.   }  
41.  }  
42. }  
43.    
44. KFCSellerHandler(客户端句柄):  
45. public class KFCSellerHandler extends IoHandlerAdapter {  
46.   
47.  private Integer childInputMoney_Ham = 4;  
48.  private Integer childInputMoney_Chick = 5;  
49.  // 创建会话  
50.  public void sessionOpened(IoSession session) throws   
51.   
52. Exception {  
53.   
54.   HashMap<String, Object> map = new   
55.   
56. HashMap<String, Object>();  
57.   map.put("购买", "汉堡");  
58.   session.write(map);  
59.  }  
60.   
61.  // 接收信息  
62.  public void messageReceived(IoSession session, Object   
63.   
64. message)  
65.    throws Exception {  
66. //  System.out.println("  客户端接收到的服务器的信息是  "  
67. //    + (HashMap<String, Object>)   
68.   
69. message);  
70.   HashMap<String, Object> priceInfor =   
71.   
72. (HashMap<String, Object>) message;  
73. //  System.out.println("============" +   
74.   
75. priceInfor.get("食品"));  
76.   String foodName = (String) priceInfor.get("食品");  
77.   if (foodName.equals("汉堡")) {  
78.    Integer foodPrice = (Integer) priceInfor.get  
79.   
80. ("价格");  
81.    if (foodPrice.equals  
82.   
83. (childInputMoney_Ham)) {  
84.     System.out.println("   您好，请收好  
85.   
86. 你的汉堡，欢迎下次光临！");  
87.    } else {  
88.     System.out.println("   对不起，你投  
89.   
90. 如的钱币数量不够，钱已经如数归还，请收好！");  
91.    }  
92.   } else if (foodName.equals("鸡翅")) {  
93.    Integer foodPrice = (Integer) priceInfor.get  
94.   
95. ("价格");  
96.    if (foodPrice.equals  
97.   
98. (childInputMoney_Chick)) {  
99.     System.out.println("   您好，请收好  
100.   
101. 你的汉堡，欢迎下次光临！");  
102.    } else {  
103.     System.out.println("   对不起，你投  
104.   
105. 如的钱币数量不够，钱已经如数归还，请收好！");  
106.    }  
107.   }  
108.  }  
109. }   
110. </span>  

 

通过上面的程序我们可以看出Mina的中业务逻辑处理都可以在IoHandler中，而不需要考虑对象的序列化和反序列化问题。关于IoHandler的简单用法就说这么多。下面再看看与IoHandler相关的几个中要的类。

 

按照惯例，还是先给出IoHandler及其相关类的类图:

从上面的类图我们可以清晰的看到IoHandler是一个接口，它有两个子类：

IoHandlerAdpater:它只是提供了IoHandler中定义的方法体，没有任何的逻辑处理，你可以根据你自己的需求重写该类中的相关方法。这个类在实际的开发中使用的是较多的。我们上面写的例子都是继承于这个类来实现的。

SingleSessionIoHandlerDelegate:这是一个服务器和客户端只有一个会话时使用的类，在该类的方法中没有提供session的参数，该类在实际的开发中使用的较少，如果需要对该类进行更深入的了解，请参考Mina 1.1.7的API文档。

 

在Mina提供的IoHandler的具体实现中，大部分的实现类都是继承与IoHandlerApater，IoHandlerAdpater在Mina 1.1.7中的子类有三个：

ChainedIoHandler:这个类主要是用于处理IoHandler的messageReceived事件，它和IoHandlerChain配合使用。当在业务逻辑中有多个IoHandler需要处理时，你可以将你的每个IoHandler添加到IoHandlerChain中，这个和过滤器

链比较相似，关于IoFilter和IoHandlerChain的具体用法和区别会在后续的文档中给出。

StreamIoHandler:该类也是用于处理IoHandler的messageReceived事件，它主要用于文件传输的系统中，比如FTP服务器中，如果需要对该类进行更深入的了解，请参考Mina 1.1.7的API文档。

DemuxingIoHandler:该类主要是用于处理多个IoHandler的messageReceived，由于在TCP/IP协议的数据传输中会出现数据的截断现象(由于socket传输的数据包的长度是固定的，当数据包大于该长度，数据包就会被截断)，所以提供这个类主要是保证IoHandler所处理的数据包的完整性，这个和编解码器中的CumulativeProtocolDecoder类似，关于这两个类的具体介绍会在后续的文档中给出。

 

至此，关于IoHandler的作用就讲述完了，希望对你能有所帮助。:)