lyunabc

浏览: 529773 次
性别:

最近访客更多访客>>

u012363178

jacktan123

403304773

shang2012

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

Mina网络应用框架及TCP/UDP开发范例(编著)

1 Mina基本开发知识

1.1 非阻塞模式

Java　NIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等，这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源(传统socket通讯服务器设计模式)的。

　　Java NIO非堵塞技术实际是采取Reactor模式，或者说是Observer模式为我们监察I/O端口，如果有内容进来，会自动通知我们，这样，我们就不必开启多个线程死等，从外界看，实现了流畅的I/O读写，不堵塞了。

　　Java NIO出现不只是一个技术性能的提高，你会发现网络上到处在介绍它，因为它具有里程碑意义，从JDK1.4开始，Java开始提高性能相关的功能，从而使得Java在底层或者并行分布式计算等操作上已经可以和C或Perl等语言并驾齐驱。

　　如果你至今还是在怀疑Java的性能，说明你的思想和观念已经完全落伍了，Java一两年就应该用新的名词来定义。从JDK1.5开始又要提供关于线程、并发等新性能的支持，Java应用在游戏等适时领域方面的机会已经成熟，Java在稳定自己中间件地位后，开始蚕食传统C的领域。

NIO 有一个主要的类Selector,这个类似一个观察者，只要我们把需要探知的socketchannel告诉Selector,我们接着做别的事情，当有事件发生时，他会通知我们，传回一组 SelectionKey,我们读取这些Key,就会获得我们刚刚注册过的socketchannel,然后，我们从这个Channel中读取数据，放心，包准能够读到，接着我们可以处理这些数据。　　Selector内部原理实际是在做一个对所注册的channel的轮询访问，不断的轮询(目前就这一个算法)，一旦轮询到一个channel有所注册的事情发生，比如数据来了，他就会站起来报告，交出一把钥匙，让我们通过这把钥匙(SelectionKey表示 SelectableChannel 在 Selector 中的注册的标记。 )来读取这个channel的内容.

1.2 什么是mian

现在已经是World Wide Web的时代，无数的web应用框架被创造出来从而大大的提高了web开发的速度。抛开WWW的这个优势，我们知道还有很多协议是HTTP协议所无法替代的。有时，我们仍然需要构造c/s应用来实现适当的协议。

你有没有曾经使用java或者其他语言实现过某个协议栈？就像你所经历过的那样，编写网络应用即使对于有经验的开发者也不是容易的事情。这归咎于以下几个方面：

* 没有为开发者设计的合适的网络应用框架.

* 使你无法在有限的时间内创建你的应用.

* 网络I/O编码，消息的编/解码，业务逻辑常常纠缠在一起.

* 使程序失去可维护性和可复用性

* 网络应用难于进行单元测试

* 你失去了敏捷性

MINA是一个网络应用框架，在不牺牲性能和可扩展性的前提下用于解决上面的所有问题。

1.3 几个接口

IoAcceptor执行所有底层IO，将他们翻译成抽象的IO事件，并把翻译过的事件和关联的IoSession发送给IoHandler。

1.3.1 IoSession

一个代表了IoSession程序同一个远程实体的IO连接。通过IoSession，你可以写出message到远程实体，访问session的配置，并且更改session的属性。

1.3.2 IoHandler

* sessionCreated: 当一个IO连接建立时被调用，这个方法在任何IO操作之前被调用，以便socket参数或session属性能够最先被设置。

* sessionOpened: 在sessionCreated调用之后被调用。

* sessionClosed: 当IO连接被关闭时被调用。

* sessionIdle: 当在远程实体和用户程序之间没有数据传输的时候被调用。

* exceptionCaught: 当IoAcceptor 或者你的IoHandler.中出现异常时被调用。

* messageReceived: 当接收到新的协议消息时被调用。可以在这里实现你的控制流程。

* messageSent: 当用户请求的消息通过 IoSession#write(Object) 确实发送后被调用。

1.4 编制一个ECHO服务器

1.4.1 业务逻辑

package org.apache.mina.examples.echoserver;

import org.apache.mina.common.ByteBuffer;

import org.apache.mina.common.IoHandlerAdapter;

import org.apache.mina.common.IoSession;

import org.apache.mina.common.TransportType;

import org.apache.mina.transport.socket.nio.SocketSessionConfig;

public class EchoProtocolHandler extends IoHandlerAdapter

{

public void sessionCreated( IoSession session )

{

if (session.getTransportType() == TransportType.SOCKET) {

((SocketSessionConfig)session.getConfig()).setReceiveBufferSize(2048);

}

public void exceptionCaught( IoSession session, Throwable cause )

{

session.close();

}

public void messageReceived( IoSession session, Object message )

{

if (!(message instanceof ByteBuffer))

return;

ByteBuffer rb = (ByteBuffer)message;

// Write the received data back to remote peer

ByteBuffer wb = ByteBuffer.allocate( rb.remaining() );

wb.put( rb );

wb.flip();

session.write( wb );

}

1.4.2 控制逻辑

1.4.2.1 主程序

刚刚我们使用MINA实现echo协议，现在我们将handler绑定到一个server端口上。

import java.net.InetSocketAddress;

import org.apache.mina.transport.socket.nio.SocketAcceptor;

import org.apache.mina.transport.socket.nio.SocketAcceptorConfig;

public class Main

{

/** Choose your favorite port number. */

private static final int PORT = 8080;

public static void main( String[] args ) throws Exception

{

SocketAcceptor acceptor = new SocketAcceptor();

SocketAcceptorConfig defaultConfig = new SocketAcceptorConfig();

defaultConfig.setReuseAddress(true);

// Bind

acceptor.bind(new InetSocketAddress(PORT), new EchoProtocolHandler(), defaultConfig);

System.out.println( "Listening on port " + PORT );

}

1.4.2.2 扩展逻辑

IoFilter提供了更加有力的方式来扩展MINA。它拦截所有的IO事件进行事件的预处理和后处理。你可以把它想象成Servlet的filters。IoFilter能够实现以下几种目的：

* 事件日志

* 性能检测

* 数据转换(e.g. SSL support)

* 防火墙…等等

1.4.2.2.1 日志filter

我们的echo协议handler不对任何IO事件进行日志。我们可以通过添加一个filter来增加日志能力。MINA提供了IoLoggingFilter来进行日志。我们只要添加日志filter到ServiceRegistry即可。 .

DefaultIoFilterChainBuilder chain = config.getFilterChain();

addLogger(chain);

private static void addLogger( DefaultIoFilterChainBuilder chain ) throws Exception

{

chain.addLast( "logger", new LoggingFilter() );

}

1.4.2.2.2 SSL的filter

想使用SSL？MINA也提供了一个SSL的filter，但它需要JDK1.5。 .

DefaultIoFilterChainBuilder chain = config.getFilterChain();

addLogger(chain);

private static void addSSLSupport( DefaultIoFilterChainBuilder chain )

throws Exception

{

SSLFilter sslFilter =

new SSLFilter( BogusSSLContextFactory.getInstance( true ) );

chain.addLast( "sslFilter", sslFilter );

System.out.println( "SSL ON" );

}

1.5 实现反转Echo协议服务器

在上面我们通过简单的echo server的例子学习了如何使用IO层，但是如果想实现复杂的如LDAP这样的协议怎么办呢？它似乎是一个恶梦，因为IO层没有帮助你分离‘message解析’和‘实际的业务逻辑（比如访问一个目录数据库）’。MINA提供了一个协议层来解决这个问题。协议层将ByteBuffer事件转换成高层的POJO事件:

使用协议层必须实现5个接口：ProtocolHandler, ProtocolProvider, ProtocolCodecFactory,ProtocolEncoder, 和 ProtocolDecoder。可能看上去有点麻烦，但是请注意ProtocolCodecFactory, ProtocolEncoder, 和ProtocolDecoder是可以完全复用的；Apache的ASN1项目为MINA提供了ASN.1解码器，更通用的解码器如：XML、java对象序列化和简单的文本将在MINA的下一个版本中提供。一旦你实现了一个灵活的解码器，你可以在未来的应用中复用它，即使你不打算复用你的解码器，MINA也提供了一个很简单的方法来实现复杂的协议。(请参考高级主题)在这一章中，我们添加一个‘反转’server，它用于反转它接到的所有文本，我们通过它来示范如何编写一个协议层。

ProtocolSession同IO层的IoSession同样继承自Session。就像前面提到的，你只需撰写面向POJO的message而不是ByteBuffer的。ProtocolEncoder将message对象解释成ByteBuffers以便IO层能够将他们输出到socket。ProtocolHandler类似于IO层的IoHandler.dataRead和dataWritten方法被替换成messageReceived和messageSent。这是因为ProtocolDecoder已经将IO层接收到的 ByteBuffers转换成了message对象。

1.5.1 业务逻辑

package org.apache.mina.examples.reverser;

import org.apache.mina.common.IoHandler;

import org.apache.mina.common.IoHandlerAdapter;

import org.apache.mina.common.IoSession;

public class ReverseProtocolHandler extends IoHandlerAdapter

{

public void exceptionCaught( IoSession session, Throwable cause )

{

// Close connection when unexpected exception is caught.

session.close();

}

public void messageReceived( IoSession session, Object message )

{

// Reverse received string

String str = message.toString();

StringBuffer buf = new StringBuffer( str.length() );

for( int i = str.length() 1; i >= 0; i )

{

buf.append( str.charAt( i ) );

}

// and write it back.

session.write( buf.toString() );

}

1.5.2 对象转换方式

ProtocolEncoder 和ProtocolDecoder只有一个方法。ProtocolEncoder将message对象转换成一个ByteBuffer，而ProtocolDecoder将一个ByteBuffer转换成message对象。下面我们将学习如何实现这些接口。要实现反转协议要实作的唯一接口就是ProtocolProvider。它非常简单：(注：Provider用于在一个统一的类中提供该协议相关的Handler、Decoder和Encoder。)

import org.apache.mina.protocol.*;

/**

* {@link ProtocolProvider} implementation for reverser server protocol.

public class ReverseProtocolProvider implements ProtocolProvider

{

// Protocol handler is usually a singleton.

private static ProtocolHandler HANDLER =

new ReverseProtocolHandler();

// Codec factory is also usually a singleton.

private static ProtocolCodecFactory CODEC_FACTORY =

new ProtocolCodecFactory()

{

public ProtocolEncoder newEncoder()

{

// Create a new encoder.

return new TextLineEncoder();

}

public ProtocolDecoder newDecoder()

{

// Create a new decoder.

return new TextLineDecoder();

}

};

public ProtocolCodecFactory getCodecFactory()

{

return CODEC_FACTORY;

}

public ProtocolHandler getHandler()

{

return HANDLER;

}

1.5.3 控制逻辑

1.5.3.1 主程序

package org.apache.mina.examples.reverser;

import org.apache.mina.common.*;

import org.apache.mina.protocol.*;

import org.apache.mina.registry.*;

/**

* (<b>Entry point</b>) Reverser server which reverses all text lines from

* clients.

* @author Trustin Lee (trustin@apache.org)

* @version $Rev: 165594 $, $Date: 20050502 16:21:22 +0900 $,

public class Main

{

private static final int PORT = 8080;

public static void main( String[] args ) throws Exception

{

ServiceRegistry registry = new SimpleServiceRegistry();

// Bind

Service service = new Service( "reverse", TransportType.SOCKET, PORT );

registry.bind( service, new ReverseProtocolProvider() );

System.out.println( "Listening on port " + PORT );

}

1.5.3.2 扩展逻辑

ProtocolFilter 同IO层的IoFilter类似：添加IoLoggingFilter来记录底层IO事件是为了debug。我们可以用ProtocolLoggingFilter代替它来记录高层事件：

private static void addLogger( ServiceRegistry registry )

{

ProtocolAcceptor acceptor = registry.getProtocolAcceptor( TransportType.SOCKET );

acceptor.getFilterChain().addLast( "logger", new ProtocolLoggingFilter() );

System.out.println( "Logging ON" );

}

1.6 其它相关知识

1.6.1 NIO ByteBuffer的功能。

MINA没有直接使用使用java NIO的ByteBuffer类。它使用一个自制的ByteBuffer来扩展java以下是它们的一些区别：

* MINA ByteBuffer是一个抽象类，用户可以自由的扩展它

* MINA 管理 MINA ByteBuffers 并对其提供对象池.

* MINA ByteBuffer提供很多便利的方法，如：无符号数值的getter和基于String的getter和putter

如果你使用MINA，你将不需要直接使用NIO buffers，因为仅使用MINA buffers就可以完成大多数buffer操作。

1.6.2 ByteBuffer 池

MINA有一个全局的ByteBuffer池，它被在同一个虚拟机下的所有MINA应用共享。任何分配的buffers将在IO操作或者事件处理方法被执行之后被释放。所以你可以调用ByteBuffer.allocate()来从池中得到一个ByteBuffer而不需要将它返回到池中。请查阅ByteBufferJavaDocs获得更多信息。

1.6.3 线程模式

MINA通过它灵活的filter机制来提供多种线程模型。没有线程池过滤器被使用时MINA运行在一个单线程模式。如果添加了一个IoThreadPoolFilter

到IoAcceptor，你将得到一个leaderfollower模式的线程池。如果再添加一个ProtocolThreadPoolFilter，你的server将有两个线程池；一个(IoThreadPoolFilter)被用于对message对象进行转换，另外一个(ProtocolThreadPoolFilter)被用于处理业务逻辑。

SimpleServiceRegistry加上IoThreadPoolFilter和ProtocolThreadPoolFilter的缺省实现即可适用于需要高伸缩性的应用。如果你想使用自己的线程模型，请查看SimpleServiceRegistry的源代码，并且自己初始化Acceptor。显然，这是个繁琐的工作。

IoThreadPoolFilter threadPool = new IoThreadPoolFilter();

threadPool.start();

IoAcceptor acceptor = new SocketAcceptor();

acceptor.getFilterChain().addLast( "threadPool", threadPool );

ProtocolThreadPoolFilter threadPool2 = new ProtocolThreadPoolFilter();

threadPool2.start();

ProtocolAcceptor acceptor2 = new IoProtocolAcceptor( acceptor );

acceptor2.getFilterChain().addLast( "threadPool", threadPool2 );

threadPool2.stop();

threadPool.stop();

1.6.4 更复杂的协议支持

‘Reverser’示例相对于其他复杂的协议来说仍然过于简单。要想让一个server工作，仍然有许多message类型和它们的转换的工作需要作。MINA提供了一下工具类来提供帮助：

* DemuxingProtocolHandler

* DemuxingProtocolCodecFactory

1.6.5 VM 内部管道通讯

你一定已经知道协议层是建立在IO层之上的，但是有时也不一定。虽然我们通常使用协议层来包装IO层，但仍有一种特殊的协议层实现，称作：’inVM pipe communication’让我们假设你需要使用MINA实现一个SMTP server和一个Spam Filter server。SMTPserver可能需要同Spam Filter server通讯以便发现spam message或者RBL中列出的客户端。如果这两个server是在同一个java虚拟机中，一个IO层是多余的，你可以绕过message对象的编解码的过程。InVMpipe communication可以使你使用同样的代码而不管spam filter server是否在同一个虚拟机中。

2 Mina快速入门(TCP协议)

2.1 介绍

Apache MINA 是一个网络应用框架，有助于用户非常方便地开发高性能、高伸缩性的网络应用。它通过Java NIO提供了一个抽象的、事件驱动的、异步的位于各种传输协议（如TCP/IP和UDP/IP）之上的API，

Apache MINA 通常可被称之为：

NIO 框架库；

客户端/服务器框架库；

或者一个网络socket库。

然而，它所提供的功能远不止这些。

（以上内容大致翻译自Apache MINA网站）

如期官方文档的介绍，Apache MINA 是一个网络应用程序框架，它对Java中的socket和NIO进行了有效和清晰的封装，方便开发人员开发TCP/UDP程序，从而抛开在使用原始的socket时需要考虑的各种繁杂而又烦人问题（线程、性能、会话等），把更多精力专著在应用中的业务逻辑的开发上。

Apache MINA 有两个主要版本：2.0 和 1.1，2.0与1.1有较大的区别，其采用java NIO进行开发，使得性能得到有效的提升，在接口方面也有不小的变化，具体信息可以参见其网站说明。

下面的介绍以 Apache MINA 2.0 为例。

2.2 软件准备

要编写和运行一个基于Apache MINA 2.0的程序，需要JDK 5.0以上版本，还需要以下软件：

（1）MINA 2.x Core

下载地址：http://mina.apache.org/downloads.html

（2）SLF4J 1.3.0 or greater

下载地址：http://www.slf4j.org/download.html

这里需要用到两个 SLF4J 的jar包：slf4j-api.jar 和 slf4j-jdk14.jar。

分别解压下载的MINA 2.x Core 和SLF4J文件，找出下列jar包文件：

mina-core-2.0.0-M1.jar

slf4j-api.jar

slf4j-jdk14.jar

2.3 编写一个Apache MINA 时间服务器

该程序的功能非常简单，就是当客户端连接到服务器的9123端口后，程序将服务器当前的时间信息以字符串的形式发送给客户端。

我们可以用Eclipse来创建编写这个程序。

（1）在Eclipse中创建一个Java项目，例如 TimeServerProject，然后将mina-core-2.0.0-M1.jar、slf4j-api.jar 和 slf4j-jdk14.jar这三个文件添加到项目的Libraries中。

2.3.1 服务器端通讯编写NioSocketAcceptor

创建一个 MinaTimeServer 类，其内容为：

import java.io.IOException;

import java.net.InetSocketAddress;

import java.nio.charset.Charset;

import org.apache.mina.common.IdleStatus;

import org.apache.mina.common.IoAcceptor;

import org.apache.mina.filter.codec.ProtocolCodecFilter;

import org.apache.mina.filter.codec.textline.TextLineCodecFactory;

import org.apache.mina.filter.logging.LoggingFilter;

import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

public class MinaTimeServer {

private static final int PORT = 9123;

public static void main(String[] args) throws IOException {

IoAcceptor acceptor = new NioSocketAcceptor();

acceptor.getFilterChain().addLast("logger", new LoggingFilter());

acceptor.getFilterChain().addLast(

"codec",

new ProtocolCodecFilter(new TextLineCodecFactory(Charset

.forName("UTF-8"))));

acceptor.setHandler(new TimeServerHandler());

acceptor.getSessionConfig().setReadBufferSize(2048);

acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);

acceptor.bind(new InetSocketAddress(PORT));

}

2.3.2 服务器端应用编写IoHandlerAdapter

（3）创建一个 TimeServerHandler 类，其内容为：

import java.util.Date;

import org.apache.mina.common.IdleStatus;

import org.apache.mina.common.IoHandlerAdapter;

import org.apache.mina.common.IoSession;

public class TimeServerHandler extends IoHandlerAdapter {

@Override

public void exceptionCaught(IoSession session, Throwable cause)

throws Exception {

cause.printStackTrace();

}

@Override

public void messageReceived(IoSession session, Object message)

throws Exception {

String str = message.toString();

System.out.println("Message read:");

System.out.println(str);

Date date = new Date();

session.write(date.toString());

System.out.println("Message written...");

session.close();

}

@Override

public void sessionIdle(IoSession session, IdleStatus status)

throws Exception {

System.out.println("IDLE " + session.getIdleCount(status));

}

（4）编译并运行MinaTimeServer类

2.3.3 客户端的应用

2.3.3.1 浏览器方式

打开您的浏览器，在地址栏中输入 http://127.0.0.1:9123/，然后回车，你就可以看到服务器的时间显示在您的浏览器内了。同时您也可以在运行MinaTimeServer的控制台窗口中看到类似下面的信息：

Message read:2008-4-11 12:22:44 org.apache.mina.filter.logging.LogLevel$4 log

信息: CREATED

2008-4-11 12:22:44 org.apache.mina.filter.logging.LogLevel$4 log

信息: OPENED

2008-4-11 12:22:44 org.apache.mina.filter.logging.LogLevel$4 log

信息: RECEIVED: HeapBuffer[pos=0 lim=261 cap=2048: 47 45 54 20 2F 20 48 54 54 50 2F 31 2E 31 0D 0A...]

GET / HTTP/1.1

Message written...

Message read:

Accept: */*

Message written...

Message read:

Accept-Language: zh-cn,en-US;q=0.5

Message written...

Message read:

UA-CPU: x86

Message written...

Message read:

Accept-Encoding: gzip, deflate

Message written...

Message read:

User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.2; .NET CLR 1.1.4322; .NET CLR 2.0.50727)

Message written...

Message read:

Host: 127.0.0.1:9123

Message written...

Message read:

Connection: Keep-Alive

Message written...

Message read:

Message written...

2008-4-11 12:22:44 org.apache.mina.filter.logging.LogLevel$4 log

信息: SENT: HeapBuffer[pos=0 lim=29 cap=30: 46 72 69 20 41 70 72 20 31 31 20 31 32 3A 32 32...]

2008-4-11 12:22:44 org.apache.mina.filter.logging.LogLevel$4 log

信息: SENT: HeapBuffer[pos=0 lim=0 cap=0: empty]

2008-4-11 12:22:44 org.apache.mina.filter.logging.LogLevel$4 log

信息: CLOSED

这是程序的日志信息以及，浏览器发送过来请求的HTTP头信息。

2.3.3.2 客户端模式

或者也可以通过telnet连接服务器的9123端口，连敲两次回车，就可以看到服务器发送过来的时间信息了。

3 Mian传递对象（TCP协议）

接触java的Mina框架已经有很多时间了，在网上也读过了很多的相关文章，发现Mina框架的确是一个值得拿来好好研究的东西，前些日子写了一个山寨QQ项目，其中的通信部分用到了java中自带的InputStream，OutputStream，Writer，Reader等等，感觉其中的很大的一个问题就是难以将事务处理的逻辑层与解析层分离开来，造成整个项目看起来比较臃肿，繁琐，不够模块化，接触Mina后发现mina在这方面做的很是恰到好处。

1、Mina框架传递对象是怎么回事

2、Mina传递对象可以用来做什么

3、Mina传递对象是怎么进行的

4、Mina传递对象过程中会遇到什么问题呢

在用原来的java的InputStream，OutputStream，Writer，Reader等进行通信的时候我们会将信息编码转化成字节流等进行信息传递，InputStream，OutputStream是基于字节流的，而Writer，Reader是基于字符的，我们都知道进行通信的服务器和客户端是事先必须定好通信协议，如果我们将<msg>你好吗？</msg>定义为是一条消息，<request>视频</request>定义为一条视频请求，如果客户端将这条消息和请求发送给了服务器，服务器要想得到消息和请求的真正内容（在这里分别是“你好吗？”和“视频”）并进行处理和应答就必须进行信息的解析，就要一条一条的进行判断：1、如果是信息是<msg>……</msg>格式的就将其看做是一条消息；2、如果是<request>……</request>格式的就将其看作是一条请求；3、如果是其他形式就将其视为无效信息，不予处理。当然这不失为一种办法可以进行信息的提取，但是我们会发现在这个过程中信息的发送、接受、解析、处理、应答等都是一条一条的，很是零散，比较难以统一，没有实现消息定义和解析处理过程的分离，这样写好了一个程序，如果日后想要进行改正其中的一条信息格式，就要在整个项目中Ctrl+F了，比较繁琐，还容易出错。

这是我们会自然的想到要用一种东西将各个格式的信息进行分类统一起来并方便进行一些必要的信息处理，为符合这些特点，我们会想到类这个东东恰恰满足了这些性质，我们可以将信息的格式中的内容定义为类的属性，而对这些属性的处理就可以用类中的方法来予以解决，这样就对信息进行了很好的包装。

这种思想有了，那就是在通信的时候直接进行形式上的对象传递（实际上在通信的时候都是最终以字节流的方式进行传递的），那么我们就要找一种工具进行这种形式的信息传递，对了，这种工具就是Mina框架，我们只看他其中的一个方法

public void messageReceived(IoSession session, Object message)，这是进行消息接收是能够被触发的一个方法，参数session代表当前的会话对象，参数message代表接收的到的信息，这时您会发现message的类型是Object型，而类 Object 是类层次结构的根类，当然可以用对象型的作为message啦！前面提到通信的时候都是最终以字节流的方式进行传递的，这样就要进行：对象（客户端）->字节流（客户端）->发送->接收->字节流（服务器）->对象（服务器）的过程，呵呵不用担心，这些繁琐的过程，Mina都提供了很好的底层默认实现所以你只需稍稍敲点代码就行了。光说不练还是不行，先上一个程序实例：

3.1 服务器端程序

3.1.1 主程序NioSocketAcceptor

package Mina.server;

import java.io.IOException;

import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;

import org.apache.mina.filter.codec.ProtocolCodecFilter;

import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;

import org.apache.mina.transport.socket.SocketAcceptor;

import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

public class MainServer

{

private static MainServer mainServer = null;

private SocketAcceptor acceptor = new NioSocketAcceptor();

private DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

private int bindPort = 8888;

public static MainServer getInstances()

{

if (null == mainServer) {

mainServer = new MainServer();

}

return mainServer;

}

private MainServer()

{

chain.addLast("myChin", new ProtocolCodecFilter(

new ObjectSerializationCodecFactory()));

acceptor.setHandler(ServerHandler.getInstances());

try {

acceptor.bind(new InetSocketAddress(bindPort));

} catch (IOException e) {

e.printStackTrace();

}

public static void main(String[] args) throws Exception {

MainServer.getInstances();

}

3.1.2 响应类IoHandlerAdapter

package Mina.server;

import org.apache.mina.core.filterchain.IoFilterAdapter;

import org.apache.mina.core.service.IoHandler;

import org.apache.mina.core.session.IdleStatus;

import org.apache.mina.core.session.IoSession;

import Mina.Object.UserInfo;

public class ServerHandler extends IoFilterAdapter implements IoHandler

{

private static ServerHandler samplMinaServerHandler = null;

public static ServerHandler getInstances()

{

if (null == samplMinaServerHandler) {

samplMinaServerHandler = new ServerHandler();

}

return samplMinaServerHandler;

}

private ServerHandler() {

}

// 当连接后打开时触发此方法，一般此方法与 sessionCreated 会被同时触发

public void sessionOpened(IoSession session) throws Exception {

}

public void sessionClosed(IoSession session) {

}

public void messageReceived(IoSession session, Object message)

throws Exception {

if (message instanceof UserInfo) {

UserInfo text = (UserInfo) message;

System.out.println("服务器接收到从客户端的姓名："+text.getName());

System.out.println("服务器接收到从客户端的QQ："+text.getQQNum());

}

public void exceptionCaught(IoSession arg0, Throwable arg1)

throws Exception {

}

// 当消息传送到客户端后触发

public void messageSent(IoSession arg0, Object arg1) throws Exception {

}

// 当一个新客户端连接后触发此方法.

public void sessionCreated(IoSession arg0) throws Exception {

}

// 当连接空闲时触发此方法.

public void sessionIdle(IoSession arg0, IdleStatus arg1) throws Exception {

}

3.2 客户端程序

3.2.1 主程序NioSocketConnector

package Mina.client;

import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;

import org.apache.mina.core.future.ConnectFuture;

import org.apache.mina.filter.codec.ProtocolCodecFilter;

import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;

import org.apache.mina.transport.socket.nio.NioSocketConnector;

public class MainClient {

private static MainClient mainClient = null;

NioSocketConnector connector = new NioSocketConnector();

DefaultIoFilterChainBuilder chain = connector.getFilterChain();

public static MainClient getInstances() {

if (null == mainClient) {

mainClient = new MainClient();

}

return mainClient;

}

private MainClient() {

chain.addLast("myChin", new ProtocolCodecFilter(

new ObjectSerializationCodecFactory()));

connector.setHandler(ClientHandler.getInstances());

connector.setConnectTimeout(30);

ConnectFuture cf = connector.connect(new InetSocketAddress("localhost",

8888));

}

public static void main(String args[]) {

MainClient.getInstances();

}

3.2.2 功能端IoHandlerAdapter

package Mina.client;

import org.apache.mina.core.service.IoHandlerAdapter;

import org.apache.mina.core.session.IoSession;

import Mina.Object.UserInfo;

public class ClientHandler extends IoHandlerAdapter

{

private static ClientHandler samplMinaClientHandler = null;

public static ClientHandler getInstances()

{

if (null == samplMinaClientHandler)

{

samplMinaClientHandler = new ClientHandler();

}

return samplMinaClientHandler;

}

private ClientHandler() {

}

public void sessionOpened(IoSession session) throws Exception {

session.write("客户端与服务器的会话打开了……");

UserInfo text=new UserInfo();

text.setName("梅竹寒香");

text.setQQNum("972341215");

session.write(text);

}

public void sessionClosed(IoSession session)

{

}

public void messageReceived(IoSession session, Object message)

throws Exception

{

}

public void messageSent(IoSession arg0, Object arg1) throws Exception

{

System.out.println("客户端已经向服务器发送了："+(String)arg1);

}

3.3 公共类：

package Mina.Object;

public class UserInfo implements java.io.Serializable{

private String name;

private String QQNum;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getQQNum() {

return QQNum;

}

public void setQQNum(String qQNum) {

QQNum = qQNum;

}

如下建包即可：以上就是对象的收发的简单示例，如果报错，或许会是一下原因：1、包的引进是否妥当 2、是否引入了mina的第三方包（网上有了很多的相关文章，在此就不在赘述了）

3.4 几点注意

通过程序您会看到对象已经成功传递并进行了相关属性的输出，对于这个简单的程序我稍做些相关说明：

(1) 进行传递的对象所实例化的类要实现java.io.Serializable序列化接口

(2) 2、您会发现实例中的类尤其是相关的IoHandlerAdapter继承类都采用了单实例模式，为什么这样做呢，原因很简单，那就是要在整个通信过程中做到对象session的等实例的单一防止发生“所托非人”的现象

(3) 3、服务器接收到message在进行类判断时用了instanceof关键字如果你看到上面的实例就觉得对象传递的学习已经成功了，那就错了，细心的博友看到这个包结构：是不是有点问题呢。

例如客户端传了一个userinfo对象到服务器，在服务器端判断如果是userinfo对象后就打印出相关信息，我看源码文档其中有这样的建包方式其中服务器和客户端共用了中间的Mina.Object包，这样在收到对象后就能通过instanceof关键字判断是不是useinfo对象，我看了一下，这个方法是可行的，现在的问题是，我们如果编写通讯软件的时候，肯定是服务器和客户端是要分开的，所以那个Mina.Object包是不能共享的，所以问题来了

（1）、如果将userinfo放到客户端中，那么该怎么用instanceof进行判断是不是userinfo呢（这时你已经不能再引入服务器中的userinfo了）

（2）、如果在客户端和服务器中都编写一个类定义一样的userinfo，可是他们这两个类是分属不同的包，所以是两个不同的类了，这样在用instanceof进行判断的时候也是行不通的；那么我们该用什么方法来进行判断接收到的类是不是userinfo对象呢？

这个问题把我纠结了很久，在网上面搜了好久也没有解决，最后想了想那个（2）或许可以改动改动就可以解决，问题的关键在于两个UserInfo分属于两个不同的包，如果可以将包名一致就好了，但是在一个工程里面不能同时建立两个命名一样的包，这样你就会发现何不建立两个工程呢一个是服务器，一个是客户端，这样都可以分别建立名字都是Object的包，这样可不可行呢，经过试验果然可以，这样就就解决了上面的问题工程图如下

好啦，有了这个工具，您会有什么想法呢？对象传递还可以做什么？那就是可以用它来进行图片，文件的传递啦，这个只是个小小的提示具体怎么实现，就要看各位博友怎么发挥啦！呵呵

4 Mina快速入门（UDP协议）

4.1 服务器端

4.1.1 应用逻辑IoHandlerAdapter

package com.taobao.mina.myudp;

import java.nio.charset.Charset;

import java.nio.charset.CharsetEncoder;

import java.util.Date;

import org.apache.mina.core.buffer.IoBuffer;

import org.apache.mina.core.service.IoHandlerAdapter;

import org.apache.mina.core.session.IdleStatus;

import org.apache.mina.core.session.IoSession;

/**

* Class the extends IoHandlerAdapter in order to properly handle

* connections and the data the connections send

* @author <a href="http://mina.apache.org" mce_href="http://mina.apache.org">Apache MINA Project</a>

public class MemoryMonitorHandler extends IoHandlerAdapter {

private MemoryMonitor server;

public MemoryMonitorHandler(MemoryMonitor server)

{

this.server = server;

}

/**

* 异常来关闭session

@Override

public void exceptionCaught(IoSession session, Throwable cause)

throws Exception {

cause.printStackTrace();

session.close(true);

}

/**

* 服务器端收到一个消息

@Override

public void messageReceived(IoSession session, Object message)

throws Exception {

if (message instanceof IoBuffer) {

IoBuffer buffer = (IoBuffer) message;

buffer.setAutoExpand(true);

System.out.println("服务器端获得udp信息:" + buffer.getLong());

Charset c = Charset.forName("UTF-8");

CharsetEncoder ce = c.newEncoder();

// 给client返回信息 IoBuffer.wrap

IoBuffer clientBuffer = IoBuffer.wrap((new Date().toLocaleString() + "服务器已收到。").getBytes(c));

clientBuffer.setAutoExpand(true);

session.setAttribute("clientbuffer", clientBuffer);

session.write(clientBuffer);

}

@Override

public void sessionClosed(IoSession session) throws Exception {

System.out.println("服务器端关闭session...");

}

@Override

public void sessionCreated(IoSession session) throws Exception {

System.out.println("服务器端成功创建一个session...");

}

@Override

public void sessionIdle(IoSession session, IdleStatus status)

throws Exception {

// System.out.println("Session idle...");

}

@Override

public void sessionOpened(IoSession session) throws Exception {

System.out.println("服务器端成功开启一个session...");

}

4.1.2 控制逻辑NioDatagramAcceptor

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;

import org.apache.mina.filter.logging.LoggingFilter;

import org.apache.mina.transport.socket.DatagramSessionConfig;

import org.apache.mina.transport.socket.nio.NioDatagramAcceptor;

/**

* The class that will accept and process clients in order to properly

* track the memory usage.

* @author <a href="http://mina.apache.org" mce_href="http://mina.apache.org">Apache MINA Project</a>

public class MemoryMonitor {

private static final long serialVersionUID = 1L;

public static final int PORT = 18567;

public MemoryMonitor() throws IOException {

// 创建UDP数据包NIO

NioDatagramAcceptor acceptor = new NioDatagramAcceptor();

// NIO设置底层IOHandler 把服务器的本身传入

acceptor.setHandler(new MemoryMonitorHandler(this));

// 设置filter

DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();

chain.addLast("logger", new LoggingFilter());

// 设置是否重用地址？也就是每个发过来的udp信息都是一个地址？

DatagramSessionConfig dcfg = acceptor.getSessionConfig();

dcfg.setReuseAddress(true);

// 绑定端口地址

acceptor.bind(new InetSocketAddress(PORT));

System.out.println("UDPServer listening on port " + PORT);

}

public static void main(String[] args) {

try {

new MemoryMonitor();

} catch (IOException e) {

e.printStackTrace();

}

4.2 客户端

4.2.1 应用逻辑IoHandlerAdapter

import java.net.InetSocketAddress;

import java.nio.charset.Charset;

import java.nio.charset.CharsetDecoder;

import org.apache.mina.core.buffer.IoBuffer;

import org.apache.mina.core.future.ConnectFuture;

import org.apache.mina.core.future.IoFutureListener;

import org.apache.mina.core.service.IoConnector;

import org.apache.mina.core.service.IoHandlerAdapter;

import org.apache.mina.core.session.IdleStatus;

import org.apache.mina.core.session.IoSession;

import org.apache.mina.example.udp.MemoryMonitor;

import org.apache.mina.transport.socket.nio.NioDatagramConnector;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

* Sends its memory usage to the MemoryMonitor server.

* 这样的写法将本来可以单独的client写到IoHandlerAdapter 更紧凑

* @author <a href="http://mina.apache.org" mce_href="http://mina.apache.org">Apache MINA Project</a>

public class MemMonClient extends IoHandlerAdapter

{

/**

* Default constructor.

public MemMonClient()

{

}

private void sendData() throws InterruptedException

{

for (int i = 0; i < 10; i++) {

long free = Runtime.getRuntime().freeMemory(); // 得到当前空闲内存大小

IoBuffer buffer = IoBuffer.allocate(8);

buffer.putLong(free); // 只把剩余内存大小放入buffer，扔给server

buffer.flip();

session.write(buffer); // 写入

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

throw new InterruptedException(e.getMessage());

}

@Override

public void exceptionCaught(IoSession session, Throwable cause)

throws Exception {

cause.printStackTrace();

}

@Override

public void messageReceived(IoSession session, Object message)

throws Exception {

Charset c = Charset.forName("UTF-8");

CharsetDecoder cd = c.newDecoder();

IoBuffer buffer = (IoBuffer)message;

System.out.println("客户端收到来自服务器的消息String:" + (buffer.getString(cd)));

}

@Override

public void messageSent(IoSession session, Object message) throws Exception

{

System.out.println("客户端向服务器发送信息：" + ((IoBuffer)message).getLong());

}

@Override

public void sessionClosed(IoSession session) throws Exception

{

System.out.println("客户端关闭了当前会话");

}

@Override

public void sessionCreated(IoSession session) throws Exception

{

System.out.println("客户端成功创建session");

}

@Override

public void sessionIdle(IoSession session, IdleStatus status)

throws Exception {

}

@Override

public void sessionOpened(IoSession session) throws Exception {

System.out.println("客户端成功开启一个session id:"+session.getId());

}

4.2.2 控制逻辑NioDatagramConnector

import java.net.InetSocketAddress;

import java.nio.charset.Charset;

import java.nio.charset.CharsetDecoder;

import org.apache.mina.core.buffer.IoBuffer;

import org.apache.mina.core.future.ConnectFuture;

import org.apache.mina.core.future.IoFutureListener;

import org.apache.mina.core.service.IoConnector;

import org.apache.mina.core.service.IoHandlerAdapter;

import org.apache.mina.core.session.IdleStatus;

import org.apache.mina.core.session.IoSession;

import org.apache.mina.example.udp.MemoryMonitor;

import org.apache.mina.transport.socket.nio.NioDatagramConnector;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class MemoryClientconector

{

private final static Logger LOGGER = LoggerFactory.getLogger(MemMonClient.class);

private IoSession session;

private IoConnector connector;

public memoryclientconector()

{

connector = new NioDatagramConnector();

connector.setHandler(this);

ConnectFuture connFuture = connector.connect(new InetSocketAddress(

"localhost", MemoryMonitor.PORT)); // 这样不太好吧

connFuture.awaitUninterruptibly();

// 给conn添加一个监听器

connFuture.addListener(new IoFutureListener<ConnectFuture>() {

public void operationComplete(ConnectFuture future) {

if (future.isConnected()) {

session = future.getSession();

try {

sendData();

} catch (InterruptedException e) {

e.printStackTrace();

}

} else {

try {

throw new Exception(" 连接错误。 ");

} catch (Exception e) {

e.printStackTrace();

}

});

}

public static void main(String[] args)

{

new MemoryClientconector ();

}

5 Mina几个关键类

5.1 IoSession

双方专用的会话通道！

[img]http://mina.apache.org/class-diagrams.data/IoSession.png" alt="[/img]

5.2 IoConnector

双方建立连接的接口，即open、close

[img]http://mina.apache.org/class-diagrams.data/IoService-connector.png" alt="[/img]

5.3 IoAcceptor

接收客户端的一个受理，然后生成一个会话类!

[img]http://mina.apache.org/class-diagrams.data/IoService-acceptor.png" alt="[/img]

5.4 IoProcessor

当有一个请求到达后，调用相应处理模块处理用户请求！

[img]http://mina.apache.org/class-diagrams.data/IoProcessor.png" alt="[/img]

5.5 IoBuffer

[img]http://mina.apache.org/class-diagrams.data/IoBuffer.png" alt="[/img]

5.6 IoFuture

[img]http://mina.apache.org/class-diagrams.data/IoFuture.png" alt="[/img]

5.7 ProtocolDecoder

协议解密

[img]http://mina.apache.org/class-diagrams.data/ProtocolDecoder.png" alt="[/img]

5.8 ProtocolEncoder

协议加密

[img]http://mina.apache.org/class-diagrams.data/ProtocolEncoder.png" alt="[/img]

6 Mian的状态机制

如果你使用Mina开发一个复杂的网络应用时，你可能在某些地方会遇到那个古老而又好用的状态模式，来使用这个模式解决你的复杂应用。然而，在你做这个决定之前，你或许想检出Mina的状态机的代码，它会根据当前对象的状态来返回对接收到的简短的数据的处理信息。注意：现在正式发布Mina的状态机。因此你要自己在Mina的SVN服务器上检出该代码，并自己编译，请参考开发指南，来获取更多的关于检出和编译Mina源码的信息。Mina的状态机可以和所有已经发布的版本Mina配合使用(1.0.x, 1.1.x 和当前发布的版本)。

6.1 一个简单的例子

让我们使用一个简单的例子来展示一下Mina的状态机是如何工作的。下面的图片展示了一个录音机的状态机。其中的椭圆是状态，箭头表示事务。每个事务都有一个事件的名字来标记该事务。

初始化时，录音机的状态是空的。当磁带放如录音机的时候，加载的事件被触发，录音机进入到加载状态。在加载的状态下，退出的事件会使录音机进入到空的状态，播放的事件会使加载的状态进入到播放状态。等等......我想你可以推断后后面的结果:)

现在让我们写一些代码。外部(录音机中使用该代码的地方)只能看到

6.1.1 录音机的接口TapeDeck

行为方法，是时。

public interface TapeDeck

{

void load(String nameOfTape);

void eject();

void start();

void pause();

void stop();

}

下面我们开始编写真正执行的代码，这些代码在一个事务被触发时，会在状态机中执行。首先我们定义一个状态。这些状态都使用字符串常量来定义，并且使用@state标记来声明。

状态类，是间，即方法运行完后的状态。

public class TapeDeckHandler

{

@State public static final String EMPTY = "Empty";

@State public static final String LOADED = "Loaded";

@State public static final String PLAYING = "Playing";

@State public static final String PAUSED = "Paused";

}

现在我们已经定义了录音机中的所有状态，我们可以根据每个事务来创建相应的代码。每个事务都和一个TapeDeckHandler的方法对应。每个事务的方法都使用@Transtration标签来声明，这个标签定义了事件的ID，该ID会触发事务的执行。事务开始时的状态使用start，事务结束使用next，事务正在运行使用on。

6.1.2 状态类实现TapeDeckHandler

public class TapeDeckHandler

{

@State public static final String EMPTY = "Empty";

@State public static final String LOADED = "Loaded";

@State public static final String PLAYING = "Playing";

@State public static final String PAUSED = "Paused";

@Transition(on = "load", in = EMPTY, next = LOADED)

public void loadTape(String nameOfTape)

{

System.out.println("Tape '" + nameOfTape + "' loaded");

}

@Transitions({

@Transition(on = "play", in = LOADED, next = PLAYING),

@Transition(on = "play", in = PAUSED, next = PLAYING)

})

public void playTape()

{

System.out.println("Playing tape");

}

@Transition(on = "pause", in = PLAYING, next = PAUSED)

public void pauseTape()

{

System.out.println("Tape paused");

}

@Transition(on = "stop", in = PLAYING, next = LOADED)

public void stopTape()

{

System.out.println("Tape stopped");

}

@Transition(on = "eject", in = LOADED, next = EMPTY)

public void ejectTape()

{

System.out.println("Tape ejected");

}

请注意，TapeDeckHandler 类没有实现TapeDeck ，呵呵，这是故意的。现在让我们亲密接触一下这个代码。在loadTape方法上的@Transition标签：

@Transition(on = "load", in = EMPTY, next = LOADED)

public void loadTape(String nameOfTape) {}

指定了这个状态后，当录音机处于空状态时，磁带装载事件启动后会触发loadTape方法，并且录音机状态将会变换到Loaded状态。@Transition标签中关于pauseTape,stopTape,ejectTape的方法就不需要在多介绍了。关于playTape的标签和其他的标签看起来不太一样。从上面的图中我们可以知道，当录音机的状态在Loaded或者Paused时，play事件都会播放磁带。当多个事务同时条用同一个方法时，@Transition标签需要按下面的方法使用：

@Transitions({

@Transition(on = "play", in = LOADED, next = PLAYING),

@Transition(on = "play", in = PAUSED, next = PLAYING)

})

public void playTape(){}

@Transition标签清晰的列出了声明的方法被多个事务调用的情况。

###############################################################

要点：更多关于@Transition 标签的参数

（1）如果你省略了on参数，系统会将该值默认为“*”，这样任何事件都可以触发该方法。

（2）如果你省略了next参数，系统会将默认值改为“_self_”，这个是和当前的状态相关的，如果你要实现一个循环的事务，你所需要做的就是省略状态机中的next参数。

（3）weight参数用于定义事务的查询顺序，一般的状态的事务是根据weight的值按升序排列的，weight默认的是0.

现在最后一步就是使用声明类创建一个状态机的对象，并且使用这个状态机的实例创建一个代理对象，该代理对象实现了TapeDeck接口:

6.1.3 程序的调用程序

public static void main(String[] args)

{

// 创建录音机事件的句柄

TapeDeckHandler handler = new TapeDeckHandler();

// 创建录音机的状态机

StateMachine sm = StateMachineFactory.getInstance(Transition.class).create(TapeDeckHandler.EMPTY, handler);

// 使用上面的状态机，通过一个代理创建一个TapeDeck的实例

TapeDeck deck = new StateMachineProxyBuilder().create(TapeDeck.class, sm);

// 加载磁带

deck.load("The Knife - Silent Shout");

// 播放

deck.play();

// 暂停

deck.pause();

// 播放

deck.play();

// 停止

deck.stop();

// 退出

deck.eject();

}

TapeDeckHandler handler = new TapeDeckHandler();

StateMachine sm = StateMachineFactory.getInstance(Transition.class).create(TapeDeckHandler.EMPTY, handler);

使用TapeDeckHandler创建一个状态机的实例。StateMachineFactory.getInstance(...) 调用的方法中使用的Transition.class 是通知工厂我们使用@Transition 标签创建一个状态机。我们指定了状态机开始时状态是空的。一个状态机是一个基本的指示图。状态对象和图中的节点对应，事务对象和箭头指向的方向对应。我们在TapeDeckHandler中使用的每一个@Transition 标签都和一个事务的实例对应。

要点：那么， @Transition 和 Transition 有什么不同吗？

@Transition 是你用来标记当事务在状态之间变化时应该使用那个方法。在后台处理中，

Mina的状态机会为MethodTransition 中每一个事务标签创建一个事务的实例。MethodTransition 实现了Transition 接口。作为一个Mina状态机的使用者，你不用直接使用Transition 或者MethodTransition 类型的对象。

录音机TapeDeck 的实例是通过调用StateMachineProxyBuilder来创建的:

TapeDeck deck = new StateMachineProxyBuilder().create(TapeDeck.class, sm);

StateMachineProxyBuilder.create()使用的接口需要由代理的对象来实现，状态机的实例将接收由代理产生的事件所触发的方法。当代码执行时，输出的结果如下：

Tape 'The Knife - Silent Shout' loaded

Playing tape

Tape paused

Playing tape

Tape stopped

Tape ejected

要点：这和Mina有什么关系？或许你已经注意到，在这个例子中没有对Mina进行任何配置。但是不要着急。稍后我们将会看到如何为Mina的IoHandler接口创建一个状态机。

6.2 Mnia的工作机制

6.2.1 它是怎样工作的？

让我们走马观花的看看当代理调用一个方法的时候发生了什么。查看一个StateContext(状态的上下文)对象状态上下文之所以重要是因为它保存了当前的状态。代理调用一个方法时，状态上下文会通知StateContextLookup 实例去方法的参数中获取一个状态的上下文。一般情况下，StateContextLookup 的实现将会循环方法中的参数，并查找一个指定类型的对象，并且使用这个对象反转出一个上下文对象。如果没有声明一个状态上下文，StateContextLookup 将会创一个，并将其存放到对象中。

当代理Mina的IoHandler接口时，我们将使用IoSessoinStateContextLookup 实例，该实例用来查询一个IoSession中的方法参数。它将会使用 IoSession的属性值为每一个Mina的session来存放一个独立的状态上下文的实例。这中方式下，同样的状态机可以让所有的Mina的会话使用，而不会使每个会话彼此产生影响。

要点：在上面的例子中，当我们使用StateMachineProxyBuilder创建一个代理时，我们一直没有我们一直没有配置StateContextLookup 使用哪种实现。如果没有配置，系统会使用SingletonStateContextLookup 。

SingletonStateContextLookup 总是不理会方法中传递给它的参数，它一直返回一个相同的状态上下文。很明显，这中方式在多个客户端并发的情况下使用同一个同一个状态机是没有意义的。这种情况下的配置会在后面的关于IoHandler 的代理配置时进行说明。

将方法请求反转成一个事件对象所有在代理对象上的方法请求都会有代理对象转换成事件对象。一个事件有一个ID或者0个或多个参数。事件的ID和方法的名字相当，事件的参数和方法的参数相当。调用方法deck.load("The Knife - Silent Shout") 相当于事件{id = "load", arguments = ["The Knife - Silent Shout"]}.事件对象中包含一个状态上下文的引用，该状态上下文是当前查找到的。

6.2.2 触发状态机

一旦事件对象被创建，代理会调用StateMachine.handle(Event).方法。StateMachine.handle(Event)遍历事务对象中当前的状态，来查找能够接收当前事件的事务的实例。这个过程会在事务的实例找到后停止。这个查询的顺序是由事务的重量值来决定的（重量值一般在@Transition 标签中指定）。

6.2.3 执行事务

最后一部就是在Transition 中调用匹配事件对象的Transition.execute(Event)方法。当事件已经执行，这个状态机将更新当前的状态，更新后的值是你在事务中定义的后面的状态。

要点：事务是一个接口。每次你使用@Transition 标签时，MethodTransition对象将会被创建。

MethodTransition(方法事务)

MethodTransition非常重要，它还需要一些补充说明。如果事件ID和@Transition标签中的on参数匹配，事件的参数和@Transition中的参数匹配，那么MethodTransition和这个事件匹配。所以如果事件看起来像{id = "foo", arguments = [a, b, c]}，那么下面的方法：

@Transition(on = "foo")

public void someMethod(One one, Two two, Three three) { ... }

只和这个事件匹配((a instanceof One && b instanceof Two && c instanceof Three) == true).。当匹配时，这个方法将会被与其匹配的事件使用绑定的参数调用。

要点： Integer, Double, Float, 等也和他们的基本类型int, double, float, 等匹配。

因此，上面的状态是一个子集，需要和下面的方法匹配：

@Transition(on = "foo")

public void someMethod(Two two) { ... }

上面的方法和((a instanceof Two || b instanceof Two || c instanceof Two) == true)是等价的。在这种情况下，第一个被匹配的事件的参数将会和该方法绑定，在它被调用的时候。一个方法如果没有参数，在其事件的ID匹配时，仍然会被调用：

@Transition(on = "foo")

public void someMethod() { ... }

这样做让事件的处理变得有点复杂，开始的两个方法的参数和事件的类及状态的上下文接口相匹配。这意味着：

@Transition(on = "foo")

public void someMethod(Event event, StateContext context, One one, Two two, Three three) { ... }

@Transition(on = "foo")

public void someMethod(Event event, One one, Two two, Three three) { ... }

@Transition(on = "foo")

public void someMethod(StateContext context, One one, Two two, Three three) { ... } 上面的方法和事件{id = "foo", arguments = [a, b, c]} if ((a instanceof One && b instanceof Two&& c instanceof Three) == true) 是匹配的。当前的事件对象和事件的方法绑定，当前的状态上下文和该方法被调用时的上下文绑定。在此之前一个事件的参数的集合将会被使用。当然，一个指定的状态上下文的实现将会被指定，以用来替代通用的上下文接口。

@Transition(on = "foo")

public void someMethod(MyStateContext context, Two two) { ... }

要点：方法中参数的顺序很重要。若方法需要访问当前的事件，它必须被配置为第一个方法参数。当事件为第一个参数的时候，状态上下问不能配置为第二个参数，它也不能配置为第一个方法的参数。事件的参数也要按正确的顺序进行匹配。方法的事务不会在查找匹配事件方法的时候重新排序。

到现在如果你已经掌握了上面的内容，恭喜你！我知道上面的内容会有点难以消化。希望下面的例子能让你对上面的内容有更清晰的了解。注意这个事件Event {id = "messageReceived", arguments = [ArrayList a = [...], Integer b = 1024]}。下面的方法将和这个事件是等价的：

// All method arguments matches all event arguments directly