NIO框架之MINA源码解析（五）：NIO超级陷阱和使用同步IO与MINA通信

1、NIO超级陷阱

之所以说NIO超级陷阱，就是因为我在本系列开头的那句话，因为使用缺陷导致客户业务系统瘫痪。当然，我对这个问题进行了很深的追踪，包括对MINA源码的深入了解，但其实之所以会出现这个问题，它的根不是MINA的原因，而是JDK底层的问题。

JDK底层在实现nio时，为了能够唤醒等待在io上的线程，在windows平台使用了两个端口建立连接发消息实现。看如下代码：

1. public class NIOTest {
2. @Test
3. public void test1(){
4. final int MAXSIZE=1000;
5. Selector [] sels = new Selector[ MAXSIZE];
6. try{
7. for( int i = 0 ;i< MAXSIZE ;++i ) {
8. sels[i] = Selector.open();
9. Thread.sleep(1000*10);
10. }
11. }catch( Exception ex ){
12. ex.printStackTrace();
13. }
14. }
15. }

也就是说每调用一次Selector.open()，就会占用两个随机可用端口，相互通信--这就是问题的根源。

当然对于我们的项目来说，这个问题的解决需要分两步，首先限制端口数到用户可接受范围内，这个比较容易，我们可用只调用一次Selector.open()方法即可，使用单利模式；第二步，因为Selector.open()方法每次都是使用的系统当前可用的随机端口，所以就有可能导致占用客户业务端口的情况，因此我们必须把Selector.open()所开的端口限制在一定范围内，最好可以通过代码指定使用哪几个端口，但是直到现在我们都没有找到，如果亲们有方法的话，很感谢能够告诉我....，。

Selector总结如下：
Windows下，Selector.open()会自己和自己建立两条TCP链接。不但消耗了两个TCP连接和端口，同时也消耗了文件描述符。
Linux下，Selector.open()会自己和自己建两条管道。同样消耗了两个系统的文件描述符。
来源于：http://blog.csdn.net/haoel/article/details/2224055

所以，现在我们现在就干脆用传统IO与MINA server通信吧。

2、使用同步IO与MINA通信

其实非常简单，唯一的难点就在于使用同步IO与MINA通信时，怎么编码和解码，还是看下面代码吧。

server 端（用的MINA）

1. /**
2. * 初始化设置，启动服务
3. */
4. public void startServer() {
5. logger.debug("mina server start");
6. int port = SysEvnVar.managerPort;
7. logger.debug("manager端口号:" + port);
8. IoAcceptor acceptor = new NioSocketAcceptor();
9. /** 日志设置 */
10. acceptor.getFilterChain().addLast("logger", new LoggingFilter());
11. //编码与解码工厂，使用的技术就是JDK提供的ObjectOutStream
12. ObjectSerializationCodecFactory objsCodec=new ObjectSerializationCodecFactory();
13. objsCodec.setDecoderMaxObjectSize(DEFAULTDECODER);
14. objsCodec.setEncoderMaxObjectSize(DEFAULTDECODER);
15. /** 数据转换，编码设置 */
16. acceptor.getFilterChain().addLast(
17. "codec",
18. new ProtocolCodecFilter(objsCodec));
19. /** 设置业务处理类 */
20. acceptor.setHandler(serverHandler);
21. /** 设置buffer容量 */
22. acceptor.getSessionConfig().setReadBufferSize(DEFAULTBUFFERSIZE);
23. /** 设置空闲时间 */
24. acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, DEFAULTIDLETIME);
25. try {
26. /** 绑定端口 */
27. acceptor.bind(new InetSocketAddress(port));
28. logger.info("mina server bind port ("+port+") sucess");
29. } catch (IOException e) {
30. logger.error("mina server bind port ("+port+") fail:" + e.getMessage(),e);
31. }
32. }

client端（使用同步IO）

1. public void sendMessageToManager(HyRequest request) {
2. Socket socket = null;
3. BufferedInputStream inBuff = null;
4. OutputStream outBuff = null;
5. try {
6. Integer port = Integer.parseInt(hyGlobalConfigureCacheImpl.get(
7. "managerPort").toString());
8. String host = hyGlobalConfigureCacheImpl.get("managerIp")
9. .toString();
10. socket = new Socket(host, port);
11. inBuff = new BufferedInputStream(new DataInputStream(
12. socket.getInputStream()));
13. outBuff = socket.getOutputStream();
14. String json = HyJsonUtil.reqeustToJsonStr(request);
15. //编码开始，使MINA能够解析
16. IoBuffer buf = IoBuffer.allocate(64);
17. buf.setAutoExpand(true);
18. buf.putObject(json);
19. buf.flip();
20. byte[] bytes =new byte[buf.limit()];
21. buf.get(bytes);
22. //编码结束，直接输出到客户端
23. outBuff.write(bytes);
24. outBuff.flush();
25. if(request.getOperation() != null && !"quit".equals(request.getOperation())){
26. String allreadstr = new String();
27. byte[] b = new byte[512 * 1024];
28. int len;
29. byte[] tmp = new byte[0];
30. if ((len = inBuff.read(b)) != -1) {
31. tmp = new byte[len];
32. System.arraycopy(b, 0, tmp, 0, len);
33. }
34. loger.debug("len:"+len);
35. //解码开始，byte[]为MINA传过来的数据
36. IoBuffer in = IoBuffer.wrap(tmp);
37. Object obj = null;
38. try {
39. loger.debug("in:"+in);
40. obj = in.getObject();
41. //解码结束
42. loger.debug("parse success");
43. } catch (Exception e) {
44. // TODO Auto-generated catch block
45. e.printStackTrace();
46. loger.debug("go to exception");
47. loger.warn("nio parse exception",e);
48. obj = "exception";
49. }
50. allreadstr = (String) obj;
51. loger.info("receive message from "
52. + socket.getRemoteSocketAddress().toString() + ",message:"
53. + allreadstr);
54. // 请求消息转换为HyResponse对象
55. HyResponse response = HyJsonUtil.getHyResponse(allreadstr);
56. HyRequest hyrequest = new HyRequest();
57. hyResponseDispatcher = hyClientHandler.getHyResponseDispatcher();
58. hyResponseDispatcher.responseProcess(hyrequest, response);
59. if (hyrequest.getOperation() != null) {
60. sendMessageToManager2(hyrequest);
61. }
62. }
63. } catch (Exception e) {
64. e.printStackTrace();
65. } finally {
66. try {
67. if(null != outBuff)
68. outBuff.close();
69. } catch (IOException e1) {
70. // TODO Auto-generated catch block
71. e1.printStackTrace();
72. }
73. try {
74. if(null != inBuff)
75. inBuff.close();
76. } catch (IOException e1) {
77. // TODO Auto-generated catch block
78. e1.printStackTrace();
79. }
80. if (socket != null) {
81. try {
82. socket.close();
83. } catch (IOException e) {
84. }
85. }
86. }
87. }

看代码里面的注释，怎么编码和解码，其实我是直接看MINA源码，把MINA的编码和解码方法工具类直接拷到了我们的client端，这样就轻松的实现使用同步IO和MINA进行通信。