Before_Morning

浏览: 35351 次

最近访客更多访客>>

dolphin_111

dongcaoheneric

181822498

lijun0349

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (77)

社区版块

存档分类

2015-04 ( 21)
2015-03 ( 21)
2014-12 ( 12)
更多存档...

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

个简单的例子

让我们使用一个简单的例子来展示一下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