关于Apache Mina
Servlet,Tomcat,Jetty,Netty,Mina对比
Servlet,Tomcat,Jetty,Netty,Mina对⽐Servlet, Tomcat, Jetty, Netty,Mina结论先说结论吧： Servlet是⼀种Java EE规范，Tomcat & Jetty是Servlet容器，Tomcat包含了Servlet。
Servlet本⾝并不能处理外部请求，需要Servlet容器的配合，Netty和MINA是⽹络框架，我们可以使⽤Netty造出⾃⼰类似Tomcat的web服务器。
简单的关系的话 Tomcat = Jetty > Netty & MINA > Servlet。
Servletwiki上的定义：Servlet 是⽤ Java 编写的服务器端程序。
其主要功能在于交互式地浏览和修改数据，⽣成动态 Web 内容。
狭义的 Servlet 是指Java 语⾔实现的⼀个接⼝，⼴义的 Servlet 是指任何实现了这个 Servlet 接⼝的类，⼀般情况下，⼈们将 Servlet 理解为后者。
Tomcatwiki的定义：Tomcat 是由 Apache 软件基⾦会下属的 Jakarta 项⽬开发的⼀个 Servlet 容器，按照 Sun Microsystems 提供的技术规范，实现了对 Servlet 和 JavaServer Page（JSP）的⽀持，并提供了作为 Web 服务器的⼀些特有功能，如 Tomcat 管理和控制平台、安全域管理和 Tomcat 阀等。
由于 Tomcat 本⾝也内含了⼀个 HTTP 服务器，它也可以被视作⼀个单独的 Web 服务器。
但是，不能将 Tomcat 和 Apache HTTP 服务器混淆，Apache HTTP 服务器是⼀个⽤C语⾔实现的 HTTPWeb服务器；这两个 HTTP web server 不是捆绑在⼀起的。
Apache Tomcat 包含了⼀个配置管理⼯具，也可以通过编辑XML格式的配置⽂件来进⾏配置。
XMPP与MINA1
openfire和mina（一）2009-06-04 17:51 2144人阅读评论(3) 收藏举报看了几天的openfire，网上的资料太少了，只有一个国外的网站不错，/，其他的只能自己摸索了。
openfire启动：ServerStarter会加载org.jivesoftware.openfire.XMPPServer在XMPPServer会加载一系列模块其中的ConnectionManagerImpl 是连接模块// Load this module always last since we don't want to start listening for clients // before the rest of the modules have been startedloadModule(ConnectionManagerImpl.class.getName());ConnectionManagerImpl 会启动一系列的监听。
其中的createClientListeners和startClientListeners是我比较关心的，先看看再这里面openfire都做了什么！private void createClientListeners() {// Start clients plain socket unless it's been disabled.if (isClientListenerEnabled()) {// Create SocketAcceptor with correct number of processorssocketAcceptor = buildSocketAcceptor();// Customize Executor that will be used by processors to process incoming stanzasExecutorThreadModel threadModel = ExecutorThreadModel.getInstance("client" );int eventThreads = JiveGlobals.getIntProperty("xmpp.client.processing.threads" , 16);ThreadPoolExecutor eventExecutor =(ThreadPoolExecutor)threadModel.getExecutor();eventExecutor.setCorePoolSize(eventThreads + 1);eventExecutor.setMaximumPoolSize(eventThreads + 1);eventExecutor.setKeepAliveTime(60, TimeUnit.SECONDS );socketAcceptor .getDefaultConfig().setThreadModel(threadModel);// Add the XMPP codec filtersocketAcceptor .getFilterChain().addFirst("xmpp" , new ProtocolCodecFilter(new XMPPCodecFactory()));// Kill sessions whose outgoing queues keep growing and fail to send trafficsocketAcceptor .getFilterChain().addAfter("xmpp" , "outCap ", new StalledSessionsFilter());}}对了这里就是和用的mian框架去做联网处理,首先设置mina框架的线程池，然后把由XMPPCodecFactory做为ProtocolCodecFilter的chain添加到FilterChain中！然后private void startClientListeners(String localIPAddress) {// Start clients plain socket unless it's been disabled.if (isClientListenerEnabled()) {int port = getClientListenerPort();try {// Listen on a specific network interface if it has been set.String interfaceName = JiveGlobals.getXMLProperty("network.interface");InetAddress bindInterface = null;if (interfaceName != null) {if (interfaceName.trim().length() > 0) {bindInterface = InetAddress.getByName(interfaceName);}}// Start accepting connectionssocketAcceptor.bind(new InetSocketAddress(bindInterface, port), new ClientConnectionHandler(serverName));ports.add(new ServerPort(port, serverName, localIPAddress, false, null, ServerPort.Type.client));List<String> params = new ArrayList<String>();params.add(Integer.toString(port));(LocaleUtils.getLocalizedString("startup.plain", params));}catch (Exception e) {System.err.println("Error starting XMPP listener on port " + port + ": " +e.getMessage());Log.error(LocaleUtils.getLocalizedString("admin.error.socket-setup"), e);}}}socketAcceptor.bind(new InetSocketAddress(bindInterface, port), new ClientConnectionHandler(serverName));将ClientConnectionHandler作为数据处理服务器去监听5222端口去了，mina真方便！关于MINA框架可以去网上找找资料，这里就不说了。
服务器框架MINA使用经验总结
最近做的一个项目用到了开源的C/S应用的服务器框架MINA，当初做的时候资料非常少，只能自己不停的测试，总结出了一些规律经验。
从网上看的资料上看，这个服务器框架还是比较稳定和支持的并发数还是很不错的，不过没有准确的数据，而且我做完的时候也没有拿到真正的实际环境中测试过，用的时候也发现了很多优点和缺点，使用者可以自己去根据自己的使用需求去衡量是否使用该框架。
服务器是商业系统很重要的一部分，主要负责数据采集，文件分发，与端机的通信，和自动作业等任务，服务器大多是24小时运行的，因此服务器的实现必须强壮、稳定、安全，而速度虽然也是很重要，不过最重要的还是前三者。
服务器框架MINA就是要为这样的服务器提供了一个网络应用框架，当然这样的服务器框架也可以自己去实现。
MINA为我们封装了socket的底层通信实现，提供了日志，线程池等功能，使用起来非常简单、方便。
MINA是一个异步框架，是通过网络事件激发的，它包含两层：IO层和协议层。
首先介绍IO 层，要说明的是我用的版本是0.8.2，可能不同版本会稍有不同。
Client产生一个底层IO事件，比如说连接和发送数据包，IoAcceptor执行所有底层IO，将他们翻译成抽象的IO事件，接着这里可以添加（也可以部添加）一个IoFilters对IO事件进行过滤，并把翻译过的事件或过滤过的事件和关联的IoSession 发送给IoHandler。
IoSession是一个有效的网络连接会话，此会话将一直保持连接，除非网络断开或用户主动断开连接（session.close()），用户可以通过IoSession获得有关该会话连接的信息和配置会话的对象和属性；IoHandler是网络事件的监听器，也就是说当有网络事件发生时会通知IoHandler，用户不用去主动接受数据。
用户只要实现此接口爱干吗干吗去吧。
IoFilter：Io过滤器，对Io 事件进行过滤，比如添加日志过滤器和线程池过滤器。
mina中文开发手册
李海峰（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 的执行流程如下所示：
ApacheMina入门（完成版）
Apache Mina入门目录一：说明 (1)二、实践：传送字符串的简单c/s (1)三、总结： (6)四、使用Mina 直接传送对象： (8)五、结论： (9)Mina是什么？考，上/己看啊，一句话就是“一个简洁易用的基于Tcp/IP通信的java框架“，什么？什么是框架？再问你就不要向下看了。
Mina能干什么？先拉出来溜一下：我们用它做两个小程序，一个为服务器，收到客户机的消息后，就回送给客户机；一个是简单的客户机，一连上服务器，就发一条消息报到，然后将从服务器接到的消息再发给服务器。
嗯，你是否意识到这是一个死循环的C/S通信？折腾机器这叫，编程就是要先能折腾！二、实践：传送字符串的简单c/s第一步：当然是下载Mina，然后在ec里建个项目，将下载后的mina-core-2.0.0-M1.jar 这个包加到你的新建的Project的lib中。
第二步编，写服务器代码：服务器端由两个类组成，一个是Min.java,启动服务器的主类；另一个是SamplMinaServerHandler.java,这个类负责处理连结上来的客户机，即消息处理器。
看代码了：处理器是是我们重写了mon.IoHandlerAdapter的一个类，其中被重写的方法，你根据方法名应可以想到这些方法的用途吧？！编程还有一点很重要，就是要会连猜带蒙。
意思是org.slf4j.LoggerFactory 这个类找不到？怎么办？google啊！slf4j也是一个开源的项目，专用做日志记录，到/上面去下载后，将log4j-over-slf4j-1.5.0.jar、和slf4j-nop-1.5.0.jar这两个jsr包加到项目中，再运行！如果还报错，那烦请你告诉我，我再去google!如果运行成功，就进行下一步吧：第三步：测试服务器：非要编写客户端代码才能测试吗？N！，启动服务器，我们使用命令行的Telnet测试：现在你只要按一下回车，命令行的telnet就会做为一个client连上我们编写的服务器：如果能像上图那样收发消息，（不要忘了，在命令行输入消息后要qiao回车，消息才会发送到服务器），就证明你的服务器编写成功了！总是用telnet不行吧，用Mina编写客户机，跟服务器是一样的简单！go on!第四步：实现Mina的客户机：就不废话了，还是两个类，一个启动主类，一个消息处理器：编写完成，启动服务器，再启动客户机，让你的机器狂奔吧！！！三、总结：所谓总结，是我们这两个程序中用到了Mina包中的几个API，我们分析其用途而己，其实这个总结应该你自己查看Mina的文档来完成：开发一个Mina应用，简单的说，就是创建连结，设定过滤规则，编写自己的消息处理器这三步！比我们直接用Socket/ServerSocket思路清晰得多了吧。
MINA
APACHE MINA 介绍一个高性能的NIO框架•MINA 的用途•MINA 选择MINA的理由•MINA 的快速入门•MINA 的高级话题讲座目标背景，用途以及所支持的功能的一个简略介绍，让大家认识MINA，对它有个初步概念。
这就是本章的目的。
在java世界中，框架繁多，就网络框架而言，我们为什么要选择MINA2这确实值得我们探讨一下。
下面的小节中将本着对软件开发最基本的两点出发进行对比：1.性能的对比2.程序实现的复杂性对比在传统I/O中，最简单实现高并发服务器的编程方式就是对每一个客户开启一个线程。
但是这种方式有如下几个弊端：•客户端上限很大的情况下不能及时响应•服务器硬件资源受限，性能也会急剧下降•受制于操作系统的限制优点还是有的:•编码简单，实现容易•一定数量的连接性能比较好。
参见实例:TraditionalIOServer0从图中可见，每一个线程维护了一组用户，然后每一个线程不断的轮询用户，哪个用户可读就读取相应的可读字节数，也就是这种方式避免了读的阻塞。
但是这种方式是一种被动的方式，也就是说不管用户是否可读，都需要去轮询。
为了解决这一问题,异步的NIO就成了不二之选选择MINA的理由NIO简单介绍JDK1.4提供的无阻塞I/O（NIO）有效解决了多线程服务器存在的线程开销问题，又同时避免了轮询问题，但在使用上略显得复杂一些。
NIO的核心思想就是多路复用，与模型二类似。
但是它是基于事件机制，所以这就是能避开轮询的原因。
但是需要注意的是，他们本质上是不同的，模型二只能算是一个模拟的多路复用，而NIO则是利用OS底层以及一些别的技术来达到异步多路复用的目的。
看完几个实际的MINA例子后可以很轻易的总结出利用MINA编程的几个大致步骤：1.创建一个实现了IoService接口的类2.设置一个实现了IoFilter接口的过滤器（如果有需要的情况下）3.设置一个IoHandler接口实现的处理类，用于处理事件（必须）4.对IoService绑定一个端口开始工作IoProcessor是处理请求的分配，包括选择Selector，超时验证，状态记录等。
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。
深入理解Apache_Mina_(4)----_IoFilter和IoHandler的区别和联系
深入理解Apache Mina----IoFilter和IoHandler的区别和联系在《与IoFilter相关的几个类》和《与IoHandler相关的几个类》两篇文档中我们了解了IoFilter 和IoHandler的基本用法，以及其相关类的作用和用途。
在本文中主要探讨IoFilter和IoHandler的主要区别和联系。
在上面的两篇文档中都提到了IoFilter和IoHandler都是对服务器或客户端(IoAcceptor/IoConnector)接收到的数据进行处理。
在Mina的官方文档《The high-performance protocol construction toolkit》给出了IoFilter和IoHandler在Mina数据传输中的执行顺序，如下图：上图显示了IoService进行数据读写时，各主要组件的执行顺序：（1）IoService读取数据时个组件的执行顺序是：IoProcessor-->IoFilter-->IoHandl e r。
（2）IoService发送数据时的执行数顺序：IoHandler-->IoFilter-->IoProcessor。
IoProcessor是一个处理线程，它的主要作用是根据当前连接的状态的变化(创建会话、开启会话、接收数据、发送数据、发生异常等等)，来将数据或事件通知到IoFilter，当IoFilter 的相应的方法接收到该状态的变化信息是会对接收到的数据进行处理，处理完毕后会将该事件转发到IoHandler中，有IoHandler完成最终的处理。
在这里IoProcessor的主要功能是创建资源(创建/分配线程给IoFilter)和数据转发（转发到IoFilter），IoFilter对数据进行基本的分类（如编解码），IoHandler则负责具体的逻辑实现。
也就是说IoFilter对接收到的数据包的具体内容不做处理，而是有IoHandler来对所接收到的数据包进行处理，根据数据包的内容向客户端返回响应的信息。
MINA 框架简介
MINA 框架简介2011-02-12 9:35Apache 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、JAVASocket、JAVA 线程及并发库(java.util.concurrent.*)的知识。
Mina 同时提供了网络通信的Server 端、Client 端的封装，无论是哪端，Mina 在整个网通通信结构中都处于如下的位置：1。
MINA 框架简介当客户首次访问采用MINA编写的程序时，IoAcceptor作为线程运行，负责接受来自客户的请求。
当有客户请求连接时，创建一个 Session，该Session与IoProcessor、SocketChannel以及IOService联系起来。
IoProcessor也作为另外一个线程运行，定时检查客户是否有数据到来，并对客户请求进行处理，依次调用在IOService注册的各个IoFilter，最后调用 IoHandler进行最终的逻辑处理，再将处理后的结果Filter后返回给客户端。
2。
IoSessionSession可以理解为服务器与客户端的特定连接，该连接由服务器地址、端口以及客户端地址、端口来决定。
客户端发起请求时，指定服务器地址和端口，客户端也会指定或者根据网络路由信息自动指定一个地址、自动分配一个端口。
这个地址、端口对构成一个Session。
MINA2官方教程翻译.
MINA2官方教程翻译(1)2.x与1.x的变化文章分类:Java编程一、包与命名所有的类和方法严格使用驼峰法命名。
例如SSLFilter被更名为SslFilter，其它很多类也是如此。
所有NIO传输类在命名时增加‘Nio’前缀。
因为NIO并不只是socket/datagram传输的实现，所有‘Nio’前缀加在了所有的NIO传输类上。
改变之前：Java代码1.SocketAcceptor acceptor=new SocketAcceptor();改变之后：Java代码1.SocketAcceptor acceptor=new NioSocketAcceptor();Filter类被重新整理进多重子包内。
随着框架自带的filter实现的数量的增加，所有的filter都被移动到适当的子包中(例如，StreamWriteFilter移至org.apache.mina.filter.stream)。
*.support的所有包被移动到了其父包(或者其他包)中。
为了避免循环依赖，*.support包中的所有类都被移至其父包或者其他包中。
你可以在IDE(例如Eclipse)中简单的修正这些包的导入从而避免编译错误。
二、BuffersMINA ByteBuffer被重命名为IoBuffer。
因为MINA ByteBuffer与JDK中NIO ByteBuffer同名，很多用户发现与其组员沟通时存在很多困难。
根据用户的反馈，我们将MINA ByteBuffer重命名为IoBuffer，这不仅使类名称简化，也是类名称更加明晰。
放弃Buffer池，默认使用IoBuffer.allocate(int)来分配heap buffer。
•acquire()与release()两个方法将不再是容易发生错误的。
如果你愿意，你可以调用free()方法，但这是可选的。
请自己承担使用这个方法的风险。
•在大多数JVM中，框架内置的IoBuffer性能更加强劲、稳定。
Mina使用详细教程
Mina使用详细教程1Mina简介：Apache MINA(Multipurpose Infrastructure for Network Applications) 是Apache 组织一个较新的项目，它为开发高性能和高可用性的网络应用程序提供了非常便利的框架。
当前发行的MINA 版本支持基于Java NIO 技术的TCP/UDP 应用程序开发、串口通讯程序（只在最新的预览版中提供），MINA 所支持的功能也在进一步的扩展中。
本文将通过官方网站上的快速入门程序来介绍MINA 的基础架构的同时演示如何使用MINA 开发网络应用程序。
2环境准备：首先到官方网站下载最新的MINA 版本，地址是：/downloads.html。
下载之前先介绍一下MINA 的两个版本：1.0.x 适合运行环境为JDK1.4，1.1.x 适合JDK1.5 的版本，两者的编译环境都需要JDK1.5。
JDK1.5 已经是非常普遍了，本文中使用 1.1.5 版本的MINA，编译和运行所需的文件是mina-core-1.1.7.jar。
下载MINA 的依赖包slf4j。
MINA 使用此项目作为日志信息的输出，而MINA 本身并不附带此项目包，请到/download.html地址下载slf4j 包，slf4j 项目解压后有很多的文件，本例中只需要其中的slf4j-api-1.5.2.jar 和 slf4j-simple-1.5.2.jar 这两个jar 文件。
如果没有这两个文件就会导致启动例子程序的时候报org/slf4j/LoggerFactory 类没找到的错误。
当然要求机器上必须装有 1.5 或者更新版本的JDK。
最好你应该选择一个顺手的Java 开发环境例如Eclipse 或者NetBeans 之类的，可以更方便的编码和调试。
3MINA 基本类的描述：3.1 IoService应用程序入口IoService负责底层通讯接入，IoAcceptor（服务器端）和IoConnector（客户端）是IoService 的扩展接口。
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 发送字符串给服务器，服务器读取的例子，两个文件package test2;import java.io.IOException;import .InetSocketAddress;import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;import org.apache.mina.filter.codec.ProtocolCodecFilter;import org.apache.mina.filter.codec.textline.TextLineCodecFactory;import org.apache.mina.transport.socket.SocketAcceptor;import org.apache.mina.transport.socket.nio.NioSocketAcceptor;public class MainServer {public static void main(String args[]) throws IOException{//创建一个非阻塞的Server端socket 用NIOSocketAcceptor acceptor = new NioSocketAcceptor();//创建接收数据的过滤器DefaultIoFilterChainBuilder chain= acceptor.getFilterChain();//设定这个过滤器一行一行的(/r/n)的读取数据chain.addLast(";myChin";, new ProtocolCodecFilter(new TextLineCodecFactory()));//设定服务器端的消息处理器 new 一个对象acceptor.setHandler(new SamplMinaServerHandler());//服务器绑定的端口int bindport=9988;//绑定端口，启动服务器acceptor.bind(new InetSocketAddress(bindport));System.out.println(";start ok,listen on:=";+bindport);}}package test2;import org.apache.mina.core.service.IoHandlerAdapter;import org.apache.mina.core.session.IdleStatus;import org.apache.mina.core.session.IoSession;public class SamplMinaServerHandler extends IoHandlerAdapter {public SamplMinaServerHandler() {// TODO Auto-generated constructor stub}@Overridepublic void sessionOpened(IoSession session )throws Exception{System.out.println(";sessionOpened incomming client :";+session.getRemoteAddress());}@Overridepublic void exceptionCaught(IoSession session, Throwable cause)throws Exception {System.out.println(";exceptionCaught";);}@Overridepublic void messageReceived(IoSession session, Object message)throws Exception {//需要设定服务器解析消息规则是一行一行的读取，这里可以转为stringString str=(String)message;System.out.println(";收到客户端信息：";+str);//将消息会送到客户端session.write(str);System.out.println(";messageReceived";);}@Overridepublic void messageSent(IoSession session, Object message) throws Exception { // TODO Auto-generated method stubSystem.out.println(";messageSent";);}@Overridepublic void sessionClosed(IoSession session) throws Exception { System.out.println(";sessionClose";);}@Overridepublic void sessionCreated(IoSession session) throws Exception { // TODO Auto-generated method stubSystem.out.println(";sessionCreate";);}@Overridepublic void sessionIdle(IoSession session, IdleStatus status) throws Exception {// TODO Auto-generated method stubSystem.out.println(";sessionIdle";);}}这两个是客户端，用于连接服务器package client;import .InetSocketAddress;import .SocketAddress;import java.nio.charset.Charset;import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder; import org.apache.mina.core.future.ConnectFuture;import org.apache.mina.core.service.IoConnector;import org.apache.mina.filter.codec.ProtocolCodecFilter;import org.apache.mina.filter.codec.textline.LineDelimiter;import org.apache.mina.filter.codec.textline.TextLineCodecFactory; import org.apache.mina.transport.socket.nio.NioSocketConnector;public class MyClient {public static void main(String args[]){//create tcp/ip connectorIoConnector connector = new NioSocketConnector();//创建接受数据的过滤器DefaultIoFilterChainBuilder chain=connector.getFilterChain();//设定这个过滤器一行一行(/r/n)的读取数据chain.addLast(";myChin";, new ProtocolCodecFilter(new TextLineCodecFactory()));//或者如下//connector.getFilterChain().addLast(";codec";, new ProtocolCodecFilter(newTextLineCodecFactory(Charset.forName(";UTF-8";),LineDelimiter.WINDOWS.getValue() ,LineDelimiter.WINDOWS.getValue())));//设定服务器端的消息处理器：new 一个clinethandler对象connector.setHandler(new SamplMinaClientHandler());//set connect timeoutconnector.setConnectTimeoutMillis(30000);//或者connector.setConnectTimeout(30);//连接到服务器ConnectFuture cf= connector.connect(new InetSocketAddress(";localhost";,9988));//wait for the connection attem to be finishedcf.awaitUninterruptibly();cf.getSession().getCloseFuture().awaitUninterruptibly();connector.dispose();}}package client;import org.apache.mina.core.service.IoHandler;import org.apache.mina.core.service.IoHandlerAdapter;import org.apache.mina.core.session.IdleStatus;import org.apache.mina.core.session.IoSession;public class SamplMinaClientHandler extends IoHandlerAdapter implements IoHandler {@Overridepublic void exceptionCaught(IoSession session, Throwable cause)throws Exception {// TODO Auto-generated method stubsuper.exceptionCaught(session, cause);}@Overridepublic void messageReceived(IoSession session, Object message)throws Exception {//我们已经设定了服务器的解析消息，（规则是一行一行的读取。
mina-2-tutor_1
**反应器** （ Reactor ）模型，就是利用多路分用器在 I/O 设备就绪时
Level-Triggered (LT) Reactor
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Edge-Triggered (ET) Reactor
~~~~~~~~~~~~~~~~~~~~~~~~~~~
，但直接使用 Java NIO API 进行编程，仍然是件麻烦的工作。开发人员不得不花费大量
精力来 处理底层的 I/O 操作以及繁琐的协议编解码相关的打包、拆包等工作。如果能够
借助一个通用的网络 I/O 框架，将 I/O 、协议编解码、应用业务逻辑良好地解耦，并让
开发人员得以将注意力集中到应用逻辑的开发上来，那就再好不过了。
设置为 ``EWOULDBLOCK`` 或 ``EAGAIN`` ，这也就是在说：“缓冲区还没数据，待会儿再
试试。”
不难发现，以上的两种策略走了两个极端：阻塞 I/O 导致调用线程阻塞而空等；非阻塞
I/O 则导致调用线程必须不停得重复进行 I/O 调用并检查执行结果直至 I/O 调用成功，
MINA_ API 当前主要有三个分支，分别是：
- 2.0.x (trunk)
目前处于 SVN trunk 上的版本， MINA_ 社区对该版本的 API 进行了全新的设计。
- 1.1.x
为当前用于产品开发的版本，适用于 5.0 以上的 JDK ，最新版本为 1.1.5 。
制解决了并发问题，这也是在 Java NIO 出现之前 使用 Java 进行并发服务器编程的唯一
途径。然而，在面对 C10K_ 这样的高并发量场合下，过多的线程将占用大量内存作为线
mina中的cumulativeprotocoldecoder -回复
mina中的cumulativeprotocoldecoder -回复Cumulative Protocol Decoder in MINA: A Step-by-Step GuideIntroduction:In the realm of network programming, decoders play a crucial role in parsing and interpreting incoming data. Apache MINA, an event-based framework for building scalable network applications, provides a powerful decoding mechanism through its CumulativeProtocolDecoder. This article will provide a step-by-step guide to understanding and implementing the CumulativeProtocolDecoder in MINA, focusing on its features, configuration, and usage.Understanding the CumulativeProtocolDecoder:1. What is a CumulativeProtocolDecoder?A CumulativeProtocolDecoder is a specialized decoder in MINA that enables the parsing of variable-length messages. Unlike other decoders, which rely on fixed-length message structures, the CumulativeProtocolDecoder allows for decoding multi-part messages that may arrive in chunks or fragments.2. Features of the CumulativeProtocolDecoder:- Cumulative buffering: The CumulativeProtocolDecoder buffers incoming data until a complete message can be decoded. This eliminates the need for manual buffering of fragmented data.- Multiple message support: It can handle multiple messages within a single TCP/IP packet or across multiple packets, making it robust and efficient.- Configuration flexibility: The CumulativeProtocolDecoder provides configuration options for handling different message formats, such as delimiters, message length fields, or custom logic for message identification.- Reusability: The CumulativeProtocolDecoder can be reused across multiple applications since it is not tied to specific message types or formats.Implementing the CumulativeProtocolDecoder:1. Setting up the project:To begin implementing the CumulativeProtocolDecoder, create a new MINA project or add the required dependencies to an existing project. Ensure that MINA's core and transport modules areincluded in your project dependencies.2. Creating a decoder class:Create a new class that extends the CumulativeProtocolDecoder abstract class provided by MINA. Implement the decode() and finishDecode() methods to handle message decoding.3. Overriding the decode() method:Within the decode() method, write the logic to parse incoming data fragments. The decode() method takes a ProtocolDecoderOutput object as a parameter, which is used to output the decoded messages. Use the ByteIoBuffer provided by MINA to read the incoming data and check for the presence of a complete message. If a complete message is found, write it to the ProtocolDecoderOutput.4. Overriding the finishDecode() method:The finishDecode() method is called when the decoder reaches the end of the input data. Here, you can handle any remaining data that could not be processed in the decode() method, such as incomplete or partial messages.5. Configuring the CumulativeProtocolDecoder:Depending on your specific message format, you may need to configure the CumulativeProtocolDecoder. MINA provides options like delimiters, length fields, or custom message identification logic. Override the appropriate methods, such as getDelimiter(), getMinReadSize(), or doDecode(), to align with your message format requirements.6. Registering and using the decoder:Once the CumulativeProtocolDecoder is implemented, register it with MINA's IoAcceptor or IoConnector, depending on your use case, by adding it to the filter chain. Specify the decoder class during the registration process.7. Handling decoded messages:To access the decoded messages in your application, implement a message handler that listens for the decoded events triggered by the CumulativeProtocolDecoder. The handler can then process and utilize the received messages as required.Conclusion:Apache MINA's CumulativeProtocolDecoder provides a robust and efficient solution for handling variable-length messages in network applications. By following the step-by-step guide mentioned above, you can implement this decoder and seamlessly parse multi-part data without worrying about message fragmentation. The flexibility and reusability of the CumulativeProtocolDecoder make it an essential tool in any network programming toolkit.。
Mina
Apache MINA是一个网络应用程序框架， 用来帮助用户简单地开发高性能和高可靠性的 网络应用程序。它提供了一个通过Java NIO在 不同的传输例如TCP/IP和UDP/IP上抽象的事件 驱动的异步API 。
Mina整体结构图
Mina通信流程图
Mina重要的接口
IoService IoAcceptor IoConnector IoServiceListener IoProcessor IoSession IoSessionConfig IoFilter IoHandler
Mina通信核心类类图
IoService
IoService这个服务是对于服务器端的接受连接和客户端发起 连接这两种行为的抽象。 底层的元数据信息TransportMetadata，比如底层的网络服务提供 者（NIO,ARP,RXTX等 ） 通过这个服务创建一个新会话时，新会话的默认配置 IoSessionConfig 获取此服务所管理的所有会话 与这个服务相关所产生的事件所对应的监听者 （IoServiceListener） 处理这个服务所管理的所有连接的处理器(IoHandler) 每个会话都有一个过滤器链（IoFilterChain），每个过滤器链通 过其对应的IoFilterChainBuilder来负责构建 服务创建的会话（IoSession）集，以及广播的方法
SimpleIoProcessorPool
IoProcessor接口的基本实现类SimpleIoProcessorPool，它的 泛型参数是AbstractIoSession的子类，表示此Processor管理的具 体会话类型。并且这个类还实现了池化，它会将多个IoSession分 布到多个IoProcessor上去管理。注意一个 一个processor是可以同时 一个 是可以同时 管理多个session的 的 管理多个
微信小程序在政务值班管理平台中的应用
66 •电子技术与软件工程 Electronic Technology & Software Engineering软件应用• Software Application【关键词】政务值班 微信小程序 信息化政务值班作为应急管理体系建设的基础环节，既是常态条件下政务工作运转的保障，更是非常态下突发事件处置的关键，如何有效提高政务值班人员的应急值守能力，与信息处置效率成为值班管理者应该思考的问题。
1 政务值班特征近年来，随着上级部门对值班工作提出的新要求，我局的值班工作由单一型向综合型，由事务型向政务型转变。
“值守”和“应急”已成为我局值班工作的两大核心任务。
目前我局每天有包括带班局领导、值班处长在内的5个岗位值班（包括两个业务值班）；如遇特殊时段，值班岗位、人数还会增加。
某些值班角色会有学术活动、出差、会议等其他临时安排，值班管理工作的现有工作模式是由各部门统计按照一定顺序编排相应岗位的值班人员，并询问确认是否有换班情况，手工排班，将纸质版值班表交送值班管理部门再统一编排，最终管理部门将总体值班情况汇总表返还到各部门供查阅使用并上报至上级部门。
如遇值班的特殊要求和重要事项需要人工电话通知或由上一个岗位依次向下传达。
这种方式管理成本高、工作效率低、信息滞后且容易出现错漏。
2 微信小程序概述2.1 小程序2017年1月9日，微信小程序正式发布。
其最初起名为“应用号”，即运行在微信之上的应用。
按照微信之父张小龙的定义，小程序是一种不需要下载安装即可使用的应用，微信小程序在政务值班管理平台中的应用文/张孟怡 李悦 王晓磊它是订阅号和服务号的延展，微信团队希望通过它接棒n 服务号，以连接更多的服务和场景。
这种类似于React Native 的应用，提供了比HTML5更出色的使用体验，开发成本却与HTML5相差无几。
2.2 基于微信小程序的政务值班系统优势微信小程序有使用方便、兼容性强的优势，无需安装。
Mina使用教程
Mina使⽤教程Mina框架简介⼀、Mina基本概念1、BIO、NIO、AIOJava BIO ：同步并阻塞，服务器实现模式为⼀个连接⼀个线程，即客户端有连接请求时服务器端就需要启动⼀个线程进⾏处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
使⽤API：ServerSocket、SocketJava NIO ：同步⾮阻塞，服务器实现模式为⼀个请求⼀个线程，即客户端发送的连接请求都会注册到多路复⽤器上，多路复⽤器轮询到连接有I/O请求时才启动⼀个线程进⾏处理。
使⽤API：ServerSocketChannel、SocketChannel、SelectorJava AIO(NIO.2) ：异步通道提供⽀持连接、读取、以及写⼊之类⾮锁定操作的连接，并提供对已启动操作的控制机制。
Java 7 中⽤于Java Platform（NIO.2）的More New I/O APIs，通过在 java.nio.channels 包中增加四个异步通道，从⽽增强了Java 1.4 中的New I/O APIs（NIO）。
使⽤API：AsynchronousServerSocketChannel、AsynchronousSocketChannel、CompletionHandler2、NIO线程模型单⼀线程单⼀Selector模型：与多线程处理BIO相⽐减少了线程数量，⽤⼀个线程循环处理ACCEPT、READ、WRITE。
但是如果某⼀次READ 或者WRITE处理时间过长，都会影响后⾯的事件响应。
3、Mina2.0的线程模型与单⼀线程处理单⼀Selector相⽐，Mina采⽤三种线程：IoAcceptor/IoConnector线程、IoProcessor线程、IoHandler线程在服务器端，bind⼀个端⼝后，会创建⼀个Acceptor线程来负责监听⼯作。
这个线程的⼯作只有⼀个：调⽤Java NIO接⼝在该端⼝上select connect事件，获取新建的连接后，封装成IoSession，交由后⾯的Processor线程处理。
Openfire源码分析—图文兼备
Openfire源码分析1. OpenfireOpenfire是开源的实时协作服务器（R TC）,它是基于公开协议XMPP（也成为Jabber）消息的。
Openfire的核心功能可以概括为：连接管理、消息解析、消息路由、消息发送。
1.1 框架Openfire核心功能由Module组成,上图中的各个模块绝大多数也是基于Module实现的。
为了动态的管理这些Module，Openfire使用了自己的类加载器JiveClassLoader，这样就可以在不重新启动系统的前提下进行Module的安装、卸载和重新加载。
1.2 ModuleOpenfire在启动时就加载了所有的Module，这些Module提供了Openfire的核心功能。
所有Module都需要实现Module接口，该接口中定义了模块生命周期中需要调用的方法，如下图所示：1.3 数据流2. Openfire与MIMAMINA是Apache组织下的一个项目，它可以帮助用户轻松的开发高性能和高扩展性的网络应用。
MINA提供了一个抽象的、支持各种传输协议的（如TCP/IP、UDP/IP）、基于Java NIO的异步事件驱动的API。
Openfire的ConnectionHandler类继承了MINA的IoHandlerAdaper，他主要负责连接的创建、销毁，以及接收到XML数据包的投递。
ConnectionHandler有三个子类，其中ClientConnectionHandler负责客户端与服务器端的连接，Com ponentConnectionHandler负责组件与服务器端的连接。
3. Multi-User-Chat多人聊天的消息是绑定在子域conference上的，对应的Com ponent是MultiUserChatServiceIm pl。
在多人聊天中，涉及到的实体与关系有：用户、聊天室、用户与聊天室的关系，MultiUserChatServiceIm pl就负责这些实体与关系的维护以及消息的投递。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
关于Apache Mina一、介绍MINA(Multipurpose Infrastructure for Network Applications)是用于开发高性能和高可用性的网络应用程序的基础框架。
通过使用MINA框架可以可以省下处理底层I/O和线程并发等复杂工作，开发人员能够把更多的精力投入到业务设计和开发当中。
MINA框架的应用比较广泛，应用的开源项目有Apache Directory、AsyncWeb、Apache Qpid、QuickFIX/J、Openfire、SubEthaSTMP、red5等。
MINA框架的特点有：基于java NIO类库开发；采用非阻塞方式的异步传输；事件驱动；支持批量数据传输；支持TCP、UDP协议；控制反转的设计模式（支持Spring）；采用优雅的松耦合架构；可灵活的加载过滤器机制；单元测试更容易实现；可自定义线程的数量，以提高运行于多处理器上的性能；采用回调的方式完成调用，线程的使用更容易。
二、调用过程在图中的模块链中，IoService 便是应用程序的入口，相当于代码中的 IoAccepter，IoAccepter 便是 IoService 的一个扩展接口。
IoService 接口可以用来添加多个 IoFilter，这些 IoFilter 符合责任链模式并由 IoProcessor 线程负责调用。
而 IoAccepter 在 ioService 接口的基础上还提供绑定某个通讯端口以及取消绑定的接口。
在上图中最右端也就是 IoHandler，这便是业务处理模块。
在业务处理类中不需要去关心实际的通讯细节，只管处理客户端传输过来的信息即可。
编写 Handler 类就是使用 MINA 开发网络应用程序的重心所在，相当于 MINA 已经帮你处理了所有的通讯方面的细节问题。
为了简化 Handler 类，MINA 提供了 IoHandlerAdapter 类，此类仅仅是实现了 IoHandler 接口，但并不做任何处理。
IoHandler 接口中具有如下一些方法:Java代码1.public interface IoHandler {2. void sessionCreated(IoSession session) throws Exception;//会话创建3. void sessionOpened(IoSession session) throws Exception;//打开会话,与sessionCreated最大的区别是它是从另一个线程处调用的4. void sessionClosed(IoSession session) throws Exception;//会话结束，当连接关闭时被调用5. void sessionIdle (IoSession session, IdleStatus status) throws Exception;//会话空闲6. void exceptionCaught(IoSession session, Throwable cause) throws Exception;//异常捕获，Mina会自动关闭此连接7. void messageReceived(IoSession session, Object message) throws Exception;//接收到消息8. void messageSent(IoSession session, Object message) throws Exception;//发送消息9.}IoService 是负责底层通讯接入，而 IoHandler 是负责业务处理的。
那么 MINA 架构图中的IoFilter 作何用途呢？答案是你想作何用途都可以。
但是有一个用途却是必须的，那就是作为IoService 和 IoHandler 之间的桥梁。
IoHandler 接口中最重要的一个方法是 messageReceived，这个方法的第二个参数是一个 Object 型的消息，众所周知，Object 是所有 Java 对象的基础，那到底谁来决定这个消息到底是什么类型呢？答案也就在这个 IoFilter 中。
在下面使用的例子中，我们添加了一个 IoFilter 是 new ProtocolCodecFilter(new TextLineCodecFactory())，这个过滤器的作用是将来自客户端输入的信息转换成一行行的文本后传递给 IoHandler，因此我们可以在messageReceived 中直接将 msg 对象强制转换成 String 对象。
而如果我们不提供任何过滤器的话，那么在 messageReceived 方法中的第二个参数类型就是一个 byte 的缓冲区，对应的类是 mon.ByteBuffer。
虽然你也可以将解析客户端信息放在 IoHandler 中来做，但这并不是推荐的做法，使原来清晰的模型又模糊起来，变得IoHandler 不只是业务处理，还得充当协议解析的任务。
MINA自身带有一些常用的过滤器，例如LoggingFilter（日志记录）、BlackListFilter（黑名单过滤）、CompressionFilter（压缩）、SSLFilter（SSL加密）等。
三、使用示例1.服务器端Java代码1.package com.logcd.mina2;2.3.import java.io.IOException;4.import .InetSocketAddress;5.import java.nio.charset.Charset;6.7.import org.apache.mina.core.service.IoAcceptor;8.import org.apache.mina.filter.codec.ProtocolCodecFilter;9.import org.apache.mina.filter.codec.textline.TextLineCodecFactory;10.import org.apache.mina.filter.logging.LoggingFilter;11.import org.apache.mina.transport.socket.nio.NioSocketAcceptor;12.13./**14. * 服务端主程序15. */16.public class MinaServer{17.18. private static final int PORT = 8901;// 定义监听端口19.20. public static void main(String[] args) throws IOException21. {22. // 创建服务端监控线程23. IoAcceptor acceptor = new NioSocketAcceptor();24. // 设置日志记录器25. acceptor.getFilterChain().addLast("logger", new LoggingFilter());26. // 设置编码过滤器27. acceptor.getFilterChain().addLast("codec",new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));28. // 指定业务逻辑处理器29. acceptor.setHandler(new ServerHandler());30. // 设置端口号31. acceptor.setDefaultLocalAddress(new InetSocketAddress(PORT));32. // 启动监听线程33. acceptor.bind();34. }35.}Java代码1.package com.logcd.mina2;2.3.import org.apache.mina.core.service.IoHandlerAdapter;4.import org.apache.mina.core.session.IoSession;5.6./**7. * 服务端逻辑控制类8. */9.public class ServerHandler extends IoHandlerAdapter{10.11. @Override12. /**13. * 连接创建事件14. */15. public void sessionCreated(IoSession session)16. {17. // 显示客户端的ip和端口18. System.out.println(session.getRemoteAddress().toString());19. }20.21. @Override22. /**23. * 消息接收事件24. */25. public void messageReceived(IoSession session, Object message) throws Exception26. {27. String str = message.toString();28. if (str.trim().equalsIgnoreCase("quit"))29. {30. // 结束会话31. session.close(true);32. return;33. }34. // 返回消息字符串35. session.write("Hi Client!");36. // 打印客户端传来的消息内容37. System.out.println("Message written..." + str);38. }39.}2.客户端Java代码1.package com.logcd.mina2;2.3.import .InetSocketAddress;4.import java.nio.charset.Charset;5.6.import org.apache.mina.core.future.ConnectFuture;7.import org.apache.mina.filter.codec.ProtocolCodecFilter;8.import org.apache.mina.filter.codec.textline.TextLineCodecFactory;9.import org.apache.mina.filter.logging.LoggingFilter;10.import org.apache.mina.transport.socket.nio.NioSocketConnector;11.12./**13. * 客户端主程序14. */15.public class MinaClient16.{17.18. public static void main(String[] args)19. {20. // 创建客户端连接器.21. NioSocketConnector connector = new NioSocketConnector();22. // 设置日志记录器23. connector.getFilterChain().addLast("logger", new LoggingFilter());24. // 设置编码过滤器25. connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(newTextLineCodecFactory(Charset.forName("UTF-8"))));26. // 设置连接超时检查时间27. connector.setConnectTimeoutCheckInterval(30);28. // 设置事件处理器29. connector.setHandler(new ClientHandler());30. // 建立连接31. ConnectFuture cf = connector.connect(new InetSocketAddress("195.2.199.170", 8901));32. // 等待连接创建完成33. cf.awaitUninterruptibly();34. // 发送消息35. cf.getSession().write("Hi Server!");36. // 发送消息37. cf.getSession().write("quit");38. // 等待连接断开39. cf.getSession().getCloseFuture().awaitUninterruptibly();40. // 释放连接41. connector.dispose();42. }43.}Java代码1.package com.logcd.mina2;2.3.import org.apache.mina.core.service.IoHandlerAdapter;4.import org.apache.mina.core.session.IoSession;5.6./**7. * 客户端逻辑控制类8. */9.public class ClientHandler extends IoHandlerAdapter {10.11. @Override12. /**13. * 消息接收事件14. */15. public void messageReceived(IoSession session, Object message)16. throws Exception {17. System.out.println("server message:" + message.toString());// 显示接收到的消息18. }19.}。