初识Apache MINA-CSDN博客

java.nio

java.nio全称java non-blocking IO，是指jdk1.4 及以上版本里提供的新api（New IO），为所有的原始类型（boolean类型除外）提供缓存支持的数据容器，NIO API 封装了 IO 非阻塞操作使用它可以提供非阻塞式的高伸缩性网络。

java.nio.* 包包含了以下关键构造

Buffers (缓冲) - 数据容器 Chartsets (字符集) - 字节和 Unicode 码的翻译容器 Channels (通道) - 表示实体 I/O 操作的连接 Selectors (选择器) - 提供可选择的、多路非阻塞 IO Regexps (正则表达式) - 提供一些操作正则表达式的工具我们在 MINA 框架中最感兴趣的是 Channels (通道)、_ Selectors_ (选择器) 以及 Buffers (缓冲)，除非我们想要对用户隐藏这些元素。

写网络应用常常被视作一种高负担但低水平的开发。这是一个不经常为程序员所学习或者了解的领域，这可能是因为这些内容是在很久以前在学校里学过但都忘光了，也可能是因为这一网络层的复杂性常常被更高层的传输层所隐藏以致你从来没有深入它。

补充一点，当涉及到异步 IO 时，一个额外的复杂的层出场了：时间。

BIO (Blocking IO，阻塞 IO) 和 NIO (Non-Blocking IO，非阻塞 IO) 之间的最大的区别在于在 BIO 中，你发送了一个请求，然后你将在得到回复之前一直等待。在服务器端，这意味着一个线程可能会涉及到任何进入的连接，因此你不需要应对多路复用连接的复杂性。另一方面，在 NIO 中，你必须应对非阻塞系统的同步特性，这意味着在一些事件发生时你的应用会被调用。在 NIO 中，你无需调用了以后等待一个结果，你发送一条命令之后，结果就绪了你会被通知。

为何使用 MINA？

考虑到这些不同，以及大多数应用程序在调用网络层的时候通常会期望一个阻塞模式，最好的解决方案就是通过写一个阻塞模式的模仿框架来隐藏掉这一表象。这就是 MINA 所做的事情！

但是 MINA 做的事情不仅于此。它为需要通过 TCP、UDP 或者任何机制通信的应用提供了一个通用 IO 视觉。如果我们仅仅考虑 TCP 或者 UDP，一个是有连接的协议 (TCP) 另一个是无连接的 (UDP)。MINA 将这种差异掩盖起来，以让你关注于对你的应用很重要的两部分：实用的代码和应用协议的编码/解码。

MINA 不仅仅处理 TCP 和 UDP，它也使用 VmpPipe 或者 APR 提供了一个串行通信 (RSC232) 之上的一层。

最后，很重要的是，MINA 是一个专门设计既能工作在客户端又能工作在服务器端的网络框架。写一个服务器的关键在于具有一个可扩展性的系统，这样可以灵活地满足服务器需求，根据性能和内存使用：这就是 MINA 的优势，使你的服务器开发变得容易。

种协议实现的网络传输层。MINA 近期要推出的新特性之一就是提供一个你可以使用现有的协议的集合。

Apache MINA

Apache MINA 是 Apache 组织一个较新的项目，它为开发高性能和高可用性的网络应用程序提供了非常便利的框架。当前发行的 MINA 版本支持基于 Java NIO 技术的 TCP/UDP 应用程序开发、串口通讯程序（只在最新的预览版中提供），MINA 所支持的功能也在进一步的扩展中。

总之：我们简单理解它是一个封装底层IO操作，提供高级操作API的通讯框架！

Minamina组件结构图

Mina框架被分成了主要的3个组件部分：

I/O Service，具体提供服务的组件。
I/O Filter Chain，过滤器链，用于支持各种切面服务。
I/O Handler，用于处理用户的业务逻辑。

Mina服务端结构

服务端的作用就是开启监听端口，等待请求的到来、处理他们、以及将发送对请求的响应。同时，服务端会为每个连接创建session，在session周期内提供各种精度的服务，比如连接创建时(sessionCreated(IoSession session))、连接等待时(sessionIdle(IoSession session, IdleStatus status))、连接销毁时(sessionClosed(IoSession session))等。mina的api为TCP/UDP提供的一致性Server端操作。

IOAcceptor 监听来自网络的请求。
当新的连接建立时，一个新的session会被创建，该session用作对同一IP/端口组合的客户端提供服务。
数据包需经过一系列的过滤器，这些过滤器可用来修改数据包的内容（如转换对象、添加或修改信息等），其中将原始字节流转换成POJO对象是非常有用的。当然这需要解编码器提供支持。
最后这些数据包或转化后的对象将交由IOHandler处理，我们将实现IOHandler用于处理具体的业务逻辑。

(四). 下载资料

本篇文章的DEMO下载地址： 1.MINA服务端:https://github.com/wsm2015/CWMinaServer 2.MINA客户端:https://github.com/wsm2015/CWMinaClient

(五). 服务器搭建

第一步.下载使用的Jar包：

登录http://mina.apache.org/downloads.html下载最新 mina压缩包（我下的是apache-mina-2.0.13-bin.zip），解压获得mina-core-2.0.13.jar和slf4j-api-1.7.14.jar（注：slf4j-api-1.7.14.jar文件在apache-mina-2.0.13-bin.zip\apache-mina-2.0.13\lib目录下）

第二步.服务端程序

创建一个简单的服务端程序：(服务端绑定3344端口)


public class DemoServer {
    // 端口号，要求客户端与服务器端一致
    private static int PORT = 3344;
    public static void main(String[] args) {
        IoAcceptor acceptor = null;
        try {
            // 创建一个非阻塞的server端的Socket
            acceptor = new NioSocketAcceptor();
            // 设置过滤器（使用mina提供的文本换行符编解码器）
            acceptor.getFilterChain().addLast("codec",
                    new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"),
                            LineDelimiter.WINDOWS.getValue(), LineDelimiter.WINDOWS.getValue())));
            // 自定义的编解码器
            // acceptor.getFilterChain().addLast("codec", new
            // ProtocolCodecFilter(new CharsetCodecFactory()));
            // 设置读取数据的换从区大小
            acceptor.getSessionConfig().setReadBufferSize();
            // 读写通道10秒内无操作进入空闲状态
            acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, );
            // 为接收器设置管理服务
            acceptor.setHandler(new DemoServerHandler());
            // 绑定端口
            acceptor.bind(new InetSocketAddress(PORT));
            System.out.println("服务器启动成功... 端口号未：" + PORT);
        } catch (Exception e) {
            System.out.println("服务器启动异常...");
            e.printStackTrace();
        }
    }
}

package com.changwu;
import java.util.Date;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
public class DemoServerHandler extends IoHandlerAdapter {
    // 从端口接受消息，会响应此方法来对消息进行处理
    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        super.messageReceived(session, message);
        String msg = message.toString();
        if ("exit".equals(msg)) {
            // 如果客户端发来exit，则关闭该连接
            session.close(true);
        }
        // 向客户端发送消息
        Date date = new Date();
        session.write(date);
        System.out.println("服务器接受消息成功..." + msg);
    }
    // 向客服端发送消息后会调用此方法
    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        super.messageSent(session, message);
//      session.close(true);//加上这句话实现短连接的效果，向客户端成功发送数据后断开连接
        System.out.println("服务器发送消息成功...");
    }
    // 关闭与客户端的连接时会调用此方法
    @Override
    public void sessionClosed(IoSession session) throws Exception {
        super.sessionClosed(session);
        System.out.println("服务器与客户端断开连接...");
    }
    // 服务器与客户端创建连接
    @Override
    public void sessionCreated(IoSession session) throws Exception {
        super.sessionCreated(session);
        System.out.println("服务器与客户端创建连接...");
    }
    // 服务器与客户端连接打开
    @Override
    public void sessionOpened(IoSession session) throws Exception {
        System.out.println("服务器与客户端连接打开...");
        super.sessionOpened(session);
    }
    @Override
    public void sessionIdle(IoSession session, IdleStatus status) throws Exception {
        super.sessionIdle(session, status);
        System.out.println("服务器进入空闲状态...");
    }
    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        super.exceptionCaught(session, cause);
        System.out.println("服务器发送异常...");
    }
}

复制代码

第三步.运行DemoServer.java文件，成功后的效果图如下：

(六). Android客户端

第一步.导入下载后的客户端项目 MINA客户端项目结构图 1

第二步.客户端程序

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    public void click(View v) {
        MinaThread mThread = new MinaThread();
        mThread.start();
    }
}
public class MinaThread extends Thread {
    private IoSession session = null;
    private IoConnector connector = null;
    @Override
    public void run() {
        super.run();
        // TODO Auto-generated method stub]
        System.out.println("客户端链接开始...");
        connector = new NioSocketConnector();
        System.out.println();
        // 设置链接超时时间
        connector.setConnectTimeoutMillis();
        System.out.println();
        // 添加过滤器
        // connector.getFilterChain().addLast("codec", new
        // ProtocolCodecFilter(new CharsetCodecFactory()));
        connector.getFilterChain().addLast("codec",
                new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"),
                        LineDelimiter.WINDOWS.getValue(), LineDelimiter.WINDOWS.getValue())));
        System.out.println(110);
        connector.setHandler(new MinaClientHandler());
        System.out.println();
        connector.setDefaultRemoteAddress(new InetSocketAddress(ConstantUtil.OUT_MATCH_PATH, ConstantUtil.WEB_MATCH_PORT));
        // 监听客户端是否断线
        connector.addListener(new IoListener() {
            @Override
            public void sessionDestroyed(IoSession arg0) throws Exception {
                // TODO Auto-generated method stub
                super.sessionDestroyed(arg0);
                try {
                    int failCount = 0;
                    while (true) {
                        Thread.sleep();
                        System.out.println(((InetSocketAddress) connector.getDefaultRemoteAddress()).getAddress()
                                .getHostAddress());
                        ConnectFuture future = connector.connect();
                        System.out.println("断线2");
                        future.awaitUninterruptibly();// 等待连接创建完成
                        System.out.println("断线3");
                        session = future.getSession();// 获得session
                        System.out.println("断线4");
                        if (session != null && session.isConnected()) {
                            System.out.println("断线5");
                            System.out.println("断线重连["
                                    + ((InetSocketAddress) session.getRemoteAddress()).getAddress().getHostAddress()
                                    + ":" + ((InetSocketAddress) session.getRemoteAddress()).getPort() + "]成功");
                            session.write("start");
                            break;
                        } else {
                            System.out.println("断线重连失败---->" + failCount + "次");
                        }
                    }
                } catch (Exception e) {
                    // TODO: handle exception
                }
            }
        });
        //开始连接
        try {
            System.out.println();
            ConnectFuture future = connector.connect();
            System.out.println(113);
            future.awaitUninterruptibly();// 等待连接创建完成
            System.out.println();
            session = future.getSession();// 获得session
            System.out.println();
            if (session != null && session.isConnected()) {
                session.write("start");
            } else {
                System.out.println("写数据失败");
            }
            System.out.println(11);
        } catch (Exception e) {
            System.out.println("客户端链接异常...");
        }
        System.out.println(118);
        if (session != null && session.isConnected()) {
            session.getCloseFuture().awaitUninterruptibly();// 等待连接断开
            System.out.println("客户端断开111111...");
            // connector.dispose();//彻底释放Session,退出程序时调用不需要重连的可以调用这句话，也就是短连接不需要重连。长连接不要调用这句话，注释掉就OK。
        }
    }
}
public class MinaClientHandler extends IoHandlerAdapter {
    @Override
    public void exceptionCaught(IoSession session, Throwable cause) throws Exception {
        Log.i("TEST", "客户端发生异常");
        super.exceptionCaught(session, cause);
    }
    @Override
    public void messageReceived(IoSession session, Object message) throws Exception {
        String msg = message.toString();
        Log.i("TEST", "i客户端接收到的信息为:" + msg);
        super.messageReceived(session, message);
    }
    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        // TODO Auto-generated method stub
        super.messageSent(session, message);
    }
}

public class IoListener implements IoServiceListener{
    @Override
    public void serviceActivated(IoService arg0) throws Exception {
        // TODO Auto-generated method stub
    }
    @Override
    public void serviceDeactivated(IoService arg0) throws Exception {
        // TODO Auto-generated method stub
    }
    @Override
    public void serviceIdle(IoService arg0, IdleStatus arg1) throws Exception {
        // TODO Auto-generated method stub
    }
    @Override
    public void sessionClosed(IoSession arg0) throws Exception {
        // TODO Auto-generated method stub
    }
    @Override
    public void sessionCreated(IoSession arg0) throws Exception {
        // TODO Auto-generated method stub
    }
    @Override
    public void sessionDestroyed(IoSession arg0) throws Exception {
        // TODO Auto-generated method stub
    }
}
public class ConstantUtil {
    /** 本地局域网IP地址 **/
    public final static String  WEB_MATCH_PATH="192.168.1.102";
    /** 用花生壳转换本地局域网后的IP地址，可供外网访问 **/
    public final static String  OUT_MATCH_PATH="15zr163427.iask.in";
    /** 用花生壳转换本地局域网后的端口号 **/
    public final static int WEB_MATCH_PORT=25400;
}

复制代码