当前位置：文档之家 › Mina2.0工作原理以及配置注意事项

Mina2.0工作原理以及配置注意事项

  • 格式：pdf
  • 大小：247.92 KB
  • 文档页数：23

下载文档原格式

  / 23

合集下载

mina总结

mina总结

MINA框架简介Apache MINA(Multipurpose Infrastructure for Network Applications) 是用于开发高性能和高可用性的网络应用程序的基础框架，它对Java中的socket和NIO进行了有效和清晰的封装，方便开发人员开发TCP/UDP 程序，从而抛开在使用原始的socket时需要考虑的各种繁杂而又烦人问题（线程、性能、会话等），把更多精力专著在应用中的业务逻辑的开发上。

Mina 综述Multipurpose Infrastructure for Network Applications。

一个基于非阻塞I/O的网络框架。

高可维护性，高可复用性：网络I/O编码，消息的编/解码，业务逻辑互相分离。

与JMX结合。

使用sfj4作为log支持UDP,支持客户端API。

由Netty2的作者Trustin Lee开始开发的。

相对容易进行单元测试客户端通信过程1.通过SocketConnector同服务器端建立连接2.链接建立之后I/O的读写交给了I/O Processor线程，I/O Processor是多线程的3.通过I/O Processor读取的数据经过IoFilterChain里所有配置的IoFilter，IoFilter进行消息的过滤，格式的转换，在这个层面可以制定一些自定义的协议4.最后IoFilter将数据交给Handler进行业务处理，完成了整个读取的过程5.写入过程也是类似，只是刚好倒过来，通过IoSession.write写出数据，然后Handler进行写入的业务处理，处理完成后交给IoFilterChain，进行消息过滤和协议的转换，最后通过I/O Processor将数据写出到socket通道IoFilterChain作为消息过滤链1.读取的时候是从低级协议到高级协议的过程，一般来说从byte字节逐渐转换成业务对象的过程2.写入的时候一般是从业务对象到字节byte的过程IoSession贯穿整个通信过程的始终整个过程可以用一个图来表现消息箭头都是有NioProcessor-N线程发起调用，默认情况下也在NioProcessor-N线程中执行MINA2网络应用架构基于Apache MINA 的网络应用有三个层次，分别是I/O 服务、I/O 过滤器和I/O 处理器：∙I/O 服务：I/O 服务用来执行实际的I/O 操作。

Mina2.0阅读源码笔记(比较详细)

Mina2.0阅读源码笔记(比较详细)

Mina源码阅读笔记，详情请关注：/ielts0909/blog写了很多关于Apache Mina的文章，为了方便大家阅读，我将关于mina的一些文章做点儿索引。

Mina官网资料-----------------------------------------------------------------Mina官网是学习mina最重要的地方：Apache MinaMina官网上有教你快速上手的quick start：《Quick Start》Mina官网提供了User Guide，这个手册包含了很多概念和示例：《User Guide》Mina的应用博客--------------------------------------------------------------Mina基于NIO开发中间有个重要的桥梁缓冲区，了解两者不同：《IoBuffer和ByteBuffer》Mina实现自定义协议的通信、对通信的一些思考：《Mina实现自定义协议通信》、《Tcp 传输下的思考》、《NIO开发的思考》Mina提供状态机来实现复杂的业务控制：《Mina状态机State Machine》Mina源码解读-----------------------------------------------------------------《Mina源码阅读笔记（一）-整体解读》《Mina源码阅读笔记（二）- IoBuffer的封装》《Mina源码阅读笔记（三）-Mina的连接IoAccpetor》《Mina源码阅读笔记（四）—Mina的连接IoConnector》《Mina源码阅读笔记（五）—Mina对连接的操作IoSession》《Mina源码阅读笔记（六）—Mina异步IO的实现IoFuture》《Mina源码阅读笔记（七）—Mina的拦截器FilterChain》《Mina源码阅读笔记（八）—Mina拦截器器的末端IoHandler》题外话--------------------------------------------------------------------------Mina的系列就写到这里了，后面如果有心得体会还会再更新上去，接下来我主要想写的是分布式消息系统的内容。

mina中文开发手册

mina中文开发手册
Apache Mina Server 2.0 中文参考手册
李海峰（QQ:61673110）-Andrew830314@
Apache Mina Server 是一个网络通信应用框架，也就是说，它主要是对基于 TCP/IP、UDP/IP 协议栈的通信框架（当然，也可以提供 JAVA 对象的序列化服务、虚拟机管道通信服务等）， Mina 可以帮助我们快速开发高性能、高扩展性的网络通信应用，Mina 提供了事件驱动、异 步（Mina 的异步 IO 默认使用的是 JAVA NIO 作为底层支持）操作的编程模型。 Mina 主要有 1.x 和 2.x 两个分支，这里我们讲解最新版本 2.0，如果你使用的是 Mina 1.x， 那么可能会有一些功能并不适用。学习本文档，需要你已掌握 JAVA IO、JAVA NIO、JAVA Socket、JAVA 线程及并发库(java.util.concurrent.*)的知识。 Mina 同时提供了网络通信的 Server 端、Client 端的封装，无论是哪端，Mina 在整个网通 通信结构中都处于如下的位置：
_______________________________________________________________________________ 2. 简单的 TCPClient： 这里我们实现 Mina 中的 TCPClient，因为前面说过无论是 Server 端还是 Client 端，在 Mina 中的执行流程都是一样的。唯一不同的就是 IoService 的 Client 端实现是 IoConnector。
可见 Mina 的 API 将真正的网络通信与我们的应用程序隔离开来，你只需要关心你要发送、 接收的数据以及你的业务逻辑即可。 同样的，无论是哪端，Mina 的执行流程如下所示：

MINA2实用手册

MINA2实用手册

MINA2实用手册作者：李庆丰Email:scholers@MINA框架是对java的NIO包的一个封装，简化了NIO程序开发的难度，封装了很多底层的细节，然开发者把精力集中到业务逻辑上来，最近做了一个相关的项目，为了备忘对MINA做一个总结。

一、服务端初始化及参数配置MINA2初始化很简单。

基本的初始化参数如下：//初始化Acceptor—可以不指定线程数量，MINA2里面默认是CPU数量+2 NioSocketAcceptor acceptor = new NioSocketAcceptor(5);java.util.concurrent.Executor threadPool =Executors.newFixedThreadPool(1500);//建立线程池//加入过滤器（Filter）到Acceptoracceptor.getFilterChain().addLast("exector", newExecutorFilter(threadPool));//编码解码器acceptor.getFilterChain().addLast("codec",new ProtocolCodecFilter(new WebDecoder()，newXmlEncoder()));//日志LoggingFilter filter = new LoggingFilter();filter.setExceptionCaughtLogLevel(LogLevel.DEBUG);filter.setMessageReceivedLogLevel(LogLevel.DEBUG);filter.setMessageSentLogLevel(LogLevel.DEBUG);filter.setSessionClosedLogLevel(LogLevel.DEBUG);filter.setSessionCreatedLogLevel(LogLevel.DEBUG);filter.setSessionIdleLogLevel(LogLevel.DEBUG);filter.setSessionOpenedLogLevel(LogLevel.DEBUG);acceptor.getFilterChain().addLast("logger", filter);acceptor.setReuseAddress(true);//设置的是主服务监听的端口可以重用acceptor.getSessionConfig().setReuseAddress(true);//设置每一个非主监听连接的端口可以重用MINA2中，当启动一个服务端的时候，要设定初始化缓冲区的长度，如果不设置这个值，系统默认为2048，当客户端发过来的消息超过设定值的时候，MINA2的机制是分段接受的，将字符是放入缓冲区中读取，所以在读取消息的时候，需要判断有多少次。

MINA 服务器开发文档

MINA 服务器开发文档

最近一直在看Mina的源码，用了Mina这么长时间，说实话，现在才开始对Mina有了一些深刻的理解，关于Mina的基本知识的介绍，这里就不多说了，网上已经有很多不错的文章都对Mina做了较深刻的剖析，现在就是想从Mina的最根本的地方来对Mina做一些深层次上的探讨。

还是先从Mina的入口程序来说，每当要启动一个Mina的程序（包括服务器和客户端）时候，这里只是对服务器重点做一些讲解，至于说Mina的客户端的应用，这里只是简单的涉及一点，不会对其做很深入的探讨。

但是Mina的服务器和客户端在很大的程度上都是一样，所以这里就“挂一漏万”的简单讲解一下。

在此之前我一直想找一种“串糖葫芦”的方式来讲解一下Mina，可是一直没有时间来看Mina的源码，真的是无从下手，虽然网上的很多关于Mina的一些文章，讲解的非常透彻了，但是可能对于初学者来说，显得有些深奥，在这里特别的提一下洞庭散人对Mina源码的透彻的分析，如果你对Mina已经有了一定的了解或者是正在学习Mina的源码，建议你去看看他的博客，里面有很多东西讲的是相当到位的。

在这里就不在多举例子了。

写这篇文档主要是想对刚接触Mina的人讲解一些Mina的基本知识，由浅入深，一步一步的学习Mina思想的精髓，我接触Mina的时间也比较长了，几乎天天在和它打交道，每当你发现一个新奇的用法的时候，你真的会被Mina所折服，我这里不是对Mina的吹捧，记得我曾经和同事开玩笑说，“等真正的懂得了Mina，你就知道什么叫Java了”，所以，我现在想急切的把现在所知道和了解的所有关于Mina的一些东西都想在这篇文章里面写出来，如果有写的不到位的地方还请各位同学多多指正，下面就开始对Mina做一个完整的介绍。

第一章Mina的几个类先说说Mina的几个类和接口(1) IoService(2) BaseIoService(3) BaseIoAcceptor(4) IoAcceptor(5) IoConnector这几个类和接口是整个服务器或客户端程序（IoConnector）的入口程序，其中就Mina 的整体上来说，IoService是所有IO通信的入口程序，下面的几个接口和类都是继承或者实现了IoService接口。

mina编码器详解

mina编码器详解
这样做可以分离协议逻辑和事务逻辑(IoHandler)。
怎样使用 ProtocolCodecFilter 呢？
应用程序基本上就是接收一串字节并且将这串字节转化为消息(较高级别的对象)。
有三种常用方法可以将字节流分离成消息：
. 使用固定长度的消息。 . 使用固定长度的标头指出消息内容主体的长度。 . 使用分隔符；例如很多基于文本的消息在消息的后面追加换行(或者 CR LF 组合)
this.height = height; this.numberOfCharacters = numberOfCharacters; }
public int getWidth() { return width;
}
public int getHeight() { return height;
}
public int getNumberOfCharacters() { return numberOfCharacters;
public class ImageRequestDecoder extends CumulativeProtocolDecoder {
protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out) throws Exception {
概述一下我们需要的编解码请求和响应类：
. ImageRequest：一个简单 POJO，表示向服务端的请求。 . ImageRequestEncoder：将请求对象编码成特定协议的数据(客户端使用) . ImageRequestDecoder：将特定协议的数据解码成请求对象(服务端使用) . ImageResponse：一个简单 POJO，表示来自服务端的响应。 . ImageResponseEncoder：服务端用来编码响应对象。 . ImageResponseDecoder：客户端用来解码响应对象。 . ImageCodecFactory：这个类用来创建必要的编码器和解码器。

Mina2.0工作原理以及配置注意事项

public static void main(String[] args){ IoAcceptor acceptor=new NioSocketAcceptor(); acceptor.getSessionConfig().setReadBufferSize(2048); acceptor.getSessionConfig.setIdleTime(IdleStatus.BOTH_IDLE,10); acceptor.bind(new InetSocketAddress(9123));
其中 Reads 操作是指 server/clinet 端从网络上收到 Message 的过程；Writes 操作是指 server/clinet 端将 Message 写到网路上的过程。
(1) IoService：这个接口在一个线程上负责套接字的建立，拥有自己的 Selector，监听是否有连接被建立。
(3) IoFilter：这个接口定义一组拦截器，这些拦截器可以包括日志输出、黑
名单过滤、数据的编码（write 方向）与解码（read 方向）等功能，其中数据的 encode 与 decode 是最为重要的、也是你在使用 Mina 时最主要关注的地方。
(4) IoHandler：这个接口负责编写业务逻辑，也就是接收、发送数据的地方。 这也是实际开发过程中需要用户自己编写的部分代码。
throws Exception {
String str = message.toString();
("The message received is [" + str + "]");
if (str.endsWith("quit")) {
session.close(true);

深入理解Apache_Mina_(5)----_配置Mina的线程模型

深入理解Apache Mina----配置Mina的线程模型在Mina的使用中，线程池的配置一个比较关键的环节，同时它也是Mina性能提高的一个有效的方法，在Mina的2.0以上版本中已经不再需要对Mina线程池的配置了，本系列文章都是基于当前的稳定版本Mina1.1.7版来进行讲述的，Mina的2.0以上版本现在还都是M(millestone,即里程碑)版的，在1.5版本上2.0M版为稳定版本，但是在1.5+以上则为非稳定版本，所以，为了更好的进行讨论和学习，还是基于Mina1.1.7版本进行讨论，如果使用Mina2.0进行开发要注意JDK的版本问题，当然如果有能力的话也可以自行修改和编译Mina的2.0版本，这里对此就不再多说，使用2.0版本的同学可以不用理会本文的内容。

上面的内容都是基于Apache Mina提供的文档讲述，如有需要，请自行查找相关资料，在此不再赘述。

下面开始对Mina的线程模型的配置、使用、及ExcutorFilter的基本原理进行简单的讲解。

（一）配置Mina的三种工作线程在Mina的NIO模式中有三种I/O工作线程（这三种线程模型只在NIO Socket中有效，在NIO数据包和虚拟管道中没有，也不需要配置）：(1)Acceptor thread该线程的作用是接收客户端的连接，并将客户端的连接导入到I/O processor线程模型中。

所谓的I/O processor线程模型就是Mina的I/O processor thread。

Acceptor thread在调用了Acceptor.bind()方法后启动。

每个Acceptor只能创建一个Acceptor thread，该线程模型不能配置，它由Mina自身提供。

(2)Connector thread该线程模型是客户端的连接线程模型，它的作用和Acceptor thread类似，它将客户端与服务器的连接导入到I/O processor线程模型中。

mina原理

客户端通信过程1.通过SocketConnector同服务器端建立连接2.链接建立之后I/O的读写交给了I/O Processor线程，I/O Processor是多线程的3.通过I/O Processor读取的数据经过IoFilterChain里所有配置的IoFilter，IoFilter进行消息的过滤，格式的转换，在这个层面可以制定一些自定义的协议4.最后IoFilter将数据交给Handler进行业务处理，完成了整个读取的过程5.写入过程也是类似，只是刚好倒过来，通过IoSession.write写出数据，然后Handler进行写入的业务处理，处理完成后交给IoFilterChain，进行消息过滤和协议的转换，最后通过I/O Processor将数据写出到socket通道IoFilterChain作为消息过滤链1.读取的时候是从低级协议到高级协议的过程，一般来说从byte字节逐渐转换成业务对象的过程2.写入的时候一般是从业务对象到字节byte的过程IoSession贯穿整个通信过程的始终整个过程可以用一个图来表现消息箭头都是有NioProcessor-N线程发起调用，默认情况下也在NioProcessor-N线程中执行类图/class-diagrams.html#ClassDiagrams-ProtocolDeco derclassdiagramConnector作为连接客户端，SocketConector用来和服务器端建立连接，连接成功，创建IoProcessor Thread（不能超过指定的processorCount），Thread由指定的线程池进行管理，IoProcessor 利用NIO框架对IO进行处理，同时创建IoSession。

连接的建立是通过Nio的SocketChannel进行。

NioSocketConnector connector = new NioSocketConnector(processorCount); ConnectFuture future = connector.connect(new InetSocketAddress(HOSTNAME, PORT));建立一个I/O通道Acceptor作为服务器端的连接接受者，SocketAcceptor用来监听端口，同客户端建立连接，连接建立之后的I/O操作全部交给IoProcessor进行处理IoAcceptor acceptor = new NioSocketAcceptor();acceptor.bind( new InetSocketAddress(PORT) );Protocol利用IoFilter，对消息进行解码和编码，如以下代码通过 MyProtocolEncoder 将java对象转成byte串，通过MyProtocalDecoder 将byte串恢复成java对象Java代码1.connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MyProtocalFactory()));2.......3.public class MyProtocalFactory implements ProtocolCodecFactory{4. ProtocolEncoderAdapter encoder = new MyProtocolEncoder();5. ProtocolDecoder decoder = new MyProtocalDecoder() ;6. public ProtocolDecoder getDecoder(IoSession session) throws Exception {7. return decoder;8. }9. public ProtocolEncoder getEncoder(IoSession session) throws Exception {10. return encoder;11. }12.}13.......14.public class MyProtocalDecoder extends ProtocolDecoderAdapter{15.16. public void decode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)17. throws Exception {18.19. int id = in.getInt();20. int len = in.getInt();21. byte[] dst = new byte[len];22.23. in.get(dst);24.25. String name = new String(dst,"GBK");26.27. Item item = new Item();28. item.setId(id);29. item.setName(name);30. out.write(item);31. }32.}33.......34.public class MyProtocolEncoder extends ProtocolEncoderAdapter {35.36. public void encode(IoSession session, Object message,37. ProtocolEncoderOutput out) throws Exception {38. Item item = (Item)message;39. int byteLen = 8 + item.getName().getBytes("GBK").length ;40. IoBuffer buf = IoBuffer.allocate(byteLen);41. buf.putInt(item.getId());42. buf.putInt(item.getName().getBytes("GBK").length);43. buf.put(item.getName().getBytes("GBK"));44. buf.flip();45. out.write(buf);46.47. }48.}handler具体处理事件，事件包括：sessionCreated、sessionOpened、sessionClosed、sessionIdle、exceptionCaught、messageReceived、messageSent。

Java 远程通讯_MINA

第一章MINA前述1.1线程模型MINA线程模型采用了Reactors in threads模型，即Main Reactor + Sub Reactors的模式。

由main reactor处理连接相关的任务：accept、connect等，当连接处理完毕并建立一个socket连接（称之为session）后，给每个session分配一个sub reactor，之后该session的所有IO、业务逻辑处理均交给了该sub reactor。

每个reactor均是一个线程，sub reactor中只靠内核调度，没有任何通信且互不打扰。

现在来讲讲我对线程模型演进的一些理解：Thread per Connection:在没有nio之前，这是传统的java网络编程方案所采用的线程模型。

即有一个主循环，socket.accept阻塞等待，当建立连接后，创建新的线程/从线程池中取一个，把该socket连接交由新线程全权处理。

这种方案优缺点都很明显，优点即实现简单，缺点则是方案的伸缩性受到线程数的限制。

Reactor in Single Thread:有了nio后，可以采用IO多路复用机制了。

我们抽取出一个单线程版的reactor模型，时序图见下文，该方案只有一个线程，所有的socket连接均注册在了该reactor上，由一个线程全权负责所有的任务。

它实现简单，且不受线程数的限制。

这种方案受限于使用场景，仅适合于IO密集的应用，不太适合CPU密集的应用，且适合于CPU资源紧张的应用上。

Reactor + Thread Pool:方案2由于受限于使用场景，但为了可以更充分的使用CPU资源，抽取出一个逻辑处理线程池。

reactor仅负责IO任务，线程池负责所有其它逻辑的处理。

虽然该方案可以充分利用CPU资源，但是这个方案多了进出thread pool的两次上下文切换。

Reactors in threads: 基于方案3缺点的考虑，将reactor分成两个部分。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
3.基于 Mina 的应用程序的开发步骤
接上节，介绍基于 mina 开发的一般步骤： 简单的 TCPServer 第一步：编写 IoService 按照上面的执行流程，我们首先需要编写 IoService，IoService 本身既是服
务端，又是客户端，我们这里编写服务端，所以使用 IoAcceptor 实现，由于 IoAcceptor 是 与 协 议 无 关 的 ， 因 为 我 们 要 编 写 TCPServer ， 所 以 我 们 使 用 IoAcceptor 的 实 现 NioSocketAcceptor ， 实 际 上 底 层 就 是 调 用 java.nio.channels.ServerSocketChannel 类。当然，如果你使用了 Apache 的 APR 库，那么你可以选择使用 AprSocketAcceptor 作为 TCPServer 的实现，据传说 Apache APR 库的性能比 JVM 自带的本地库高出很多。 IoProcessor 是由指定的 IoService 内部创建并调用的，我们并不需要关心。 public class MyServer {
private final static Logger log = LoggerFactory .getLogger(MyIoHandler.class);
@Override public void messageReceived(IoSession session, Object message)
(3) IoFilter：这个接口定义一组拦截器，这些拦截器可以包括日志输出、黑
名单过滤、数据的编码（write 方向）与解码（read 方向）等功能，其中数据的 encode 与 decode 是最为重要的、也是你在使用 Mina 时最主要关注的地方。
(4) IoHandler：这个接口负责编写业务逻辑，也就是接收、发送数据的地方。 这也是实际开发过程中需要用户自己编写的部分代码。
4.线程机制
Mina 中的很多执行环节都使用了多线程机制，用于提高性能，图 3 所示为 Mina 的线程模型图。
图 3 是 Mina 的 Server 端内部运行图，Client 处表示外部的客户端通过 Socket 建立连接。
图中 IoAcceptor 对应 NioSocketAcceptor 类，是用来接受 Socket 请求的。 图中用灰色的齿轮表示，小齿轮表示它一直可以干活，运转不息。黄色的小 齿轮则表示一个运行在线程池上的任务，表示它是运转在线程池之上的。 1、服务端在创建 NioSocketAcceptor 实现时，会生成一个线程池，此线程 池用来执行一个接受请求的任务，这个任务叫 Acceptor(可以在 AbstractPollingIoAcceptor 类中找到其实现类)，Acceptor 会开一个 Selector， 用来监听 NIO 中的 ACCEPT 事件。任务初始化时并没有执行，而在调用 NioSocketAcceptor 实例的 bind 方法时，则会启动对指定端口的 ACCEPT 事件的 监听。
throws Exception {
String str = message.toString();
("The message received is [" + str + "]");
if (str.endsWith("quit")) {
session.close(true);
return;
public class MyClient { mainmainmainmain 方法：
IoConnector connector=new NioSocketConnector();
connector.setConnectTimeoutMillis(30000); connector.getFilterChain().addLast("codec",
session.write(values); }
} 注册 IoHandler：
connector.setHandler(new ClientHandler("你好！\r\n 大家好！")); 然后我们运行 MyClient，你会发现 MyServer 输出如下语句： The message received is [你好！] The message received is [大家好！] 我们看到服务端是按照收到两条消息输出的，因为我们用的编解码器是以换 行符判断数据是否读取完毕的。
}
}
} 然后我们把这个 IoHandler 注册到 IoService：
acceptor.setHandler(new MyIoHandler()); 当然这段代码也要在 acceptor.bind()方法之前执行。 然后我们运行 MyServer 中的 main 方法，你可以看到控制台一直处于阻塞 状态，此时，我们用 telnet 127.0.0.1 9123 访问，然后输入一些内容，当按下回 车键，你会发现数据在 Server 端被输出，但要注意不要输入中文，因为 Windows 的命令行窗口不会对传输的数据进行 UTF-8 编码。当输入 quit 结尾的字符串时， 连接被断开。 这里注意你如果使用的操作系统，或者使用的 Telnet 软件的换行符是什么， 如果不清楚，可以删掉第二步中的两个红色的参数，使用 TextLineCodec 内部 的自动识别机制。 2.简单的 TCPClient 这里我们实现 Mina 中的 TCPClient，因为前面说过无论是 Server 端还是 Client 端，在 Mina 中的执行流程都是一样的。唯一不同的就是 IoService 的 Client 端实现是 IoConnector。 第一步：编写 IoService 并注册过滤器
2. 框架架构和执行流程
框架同时提供了网络通信的 server 端和 client 的封装，无论在哪端，mina 都 处于用户应用程序和底层实现的中间层，起到了软件分层的作用。在实际开发过
程中，用户只需要关心要发送的数据和处理逻辑就可以了。
mina 的执行流程如下：
图 1 mina 架构图
图 2 mina 工作流程图
.getLogger(ClientHandler.class); private final Strin values) {
this.values = values; } @Override public void sessionOpened(IoSession session) {
public static void main(String[] args){ IoAcceptor acceptor=new NioSocketAcceptor(); acceptor.getSessionConfig().setReadBufferSize(2048); acceptor.getSessionConfig.setIdleTime(IdleStatus.BOTH_IDLE,10); acceptor.bind(new InetSocketAddress(9123));
} }
这段代码我们初始化了服务端的 TCP/IP 的基于 NIO 的套接字，然后调用 IoSessionConfig 设置读取数据的缓冲区大小、读写通道均在 10 秒内无任何操作
就进入空闲状态。 第二步：编写过滤器 这 里 我 们 处 理 最 简 单 的 字 符 串 传 输 ， Mina 已 经 为 我 们 提 供 了
Mina 2.0 工作原理以及配置中的注意事项
1. Mina 是什么?
Apache MINA 是一个网络应用程序框架，用来帮助用户简单地开发高性能 和高可靠性的网络应用程序。它提供了一个通过 Java NIO 在不同的传输例如 TCP/IP 和 UDP/IP 上抽象的事件驱动的异步 API。
Apache MINA 也称为: ● NIO 框架库 ● 客户端服务器框架库 ● 一个网络套接字库
其中 Reads 操作是指 server/clinet 端从网络上收到 Message 的过程；Writes 操作是指 server/clinet 端将 Message 写到网路上的过程。
(1) IoService：这个接口在一个线程上负责套接字的建立，拥有自己的 Selector，监听是否有连接被建立。
SSL·TLS·StartTLS 支持 ● 超载保护和传输流量控制 ● 利用模拟对象进行单元测试 ● JMX 管理能力 ● 通过 StreamIoHandler 提供基于流的 I/O 支持 ● 和知名的容器(例如 PicoContainer、Spring)集成 ● 从 Netty 平滑的迁移到 MINA， Netty 是 MINA 的前辈。
TextLineCodecFactory 编解码器工厂来对字符串进行编解码处理。 acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter( new TextLineCodecFactory( Charset.forName("UTF-8"), LineDelimeter. WINDOWS.getValue(), LineDelimiter. WINDOWS.getValue() ) ) ); 这段代码要在 acceptor.bind()方法之前执行，因为绑定套接字之后就不能再做
MINA 虽然简单但是仍然提供了全功能的网络应用程序框架： ● 为不同的传输类型提供了统一的 API: ○ 通过 Java NIO 提供 TCP/IP 和 UDP/IP 支持 ○ 通过 RXTX 提供串口通讯(RS232) ○ In-VM 管道通讯 ○ 你能实现你自己的 API! ● 过滤器作为一个扩展特性; 类似 Servlet 过滤器 ● 低级和高级的 API: ○ 低级: 使用字节缓存(ByteBuffers) ○ 高级: 使用用户定义的消息对象(objects)和编码(codecs) ● 高度定制化线程模型: ○ 单线程 ○ 一个线程池 ○ 一个以上的线程池(也就是 SEDA) ● 使用 Java5 SSL 引擎提供沙盒(Out-of-the-box)