Mina状态机StateMachine()

最新推荐文章于 2021-09-01 09:31:43 发布
最新推荐文章于 2021-09-01 09:31:43 发布
阅读量2.2k 收藏
点赞数
分类专栏： 11.Mina 文章标签： telnet Mina NIO linkedlist stateMachine

接下来我们要把这样的方式用在通信中。用通信的方式来模拟录放机的按钮。

我们先看状态的定义：

001 package com.a2.desktop.example10.mina.statemachine;
002  
003 import static org.apache.mina.statemachine.event.IoHandlerEvents.EXCEPTION_CAUGHT;
004 import static org.apache.mina.statemachine.event.IoHandlerEvents.MESSAGE_RECEIVED;
005 import static org.apache.mina.statemachine.event.IoHandlerEvents.SESSION_OPENED;
006  
007 import org.apache.mina.core.future.IoFutureListener;
008 import org.apache.mina.core.session.IoSession;
009  
010 import org.apache.mina.statemachine.StateControl;
011 import org.apache.mina.statemachine.annotation.IoHandlerTransition;
012 import org.apache.mina.statemachine.annotation.IoHandlerTransitions;
013 import org.apache.mina.statemachine.annotation.State;
014 import org.apache.mina.statemachine.context.AbstractStateContext;
015 import org.apache.mina.statemachine.context.StateContext;
016 import org.apache.mina.statemachine.event.Event;
017  
018 public class TapeDeckServer {
019  
020     @State
021     public static final String ROOT = "Root";
022     @State(ROOT)
023     // 表示继承关系
024     public static final String EMPTY = "Empty";
025     @State(ROOT)
026     public static final String LOADED = "Loaded";
027     @State(ROOT)
028     public static final String PLAYING = "Playing";
029     @State(ROOT)
030     public static final String PAUSED = "Paused";
031  
032     private final String[] tapes = { "盖世英雄-王力宏", "唯一-王力宏" };
033  
034     static class TapeDeckContext extends AbstractStateContext {
035         public String tapeName;
036     }
037      
038      @IoHandlerTransition(on = SESSION_OPENED, in = EMPTY)
039         public void connect(IoSession session) {
040             session.write("+ Greetings from your tape deck!");
041         }
042          
043         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = EMPTY, next = LOADED)
044         public void loadTape(TapeDeckContext context, IoSession session, LoadCommand cmd) {
045       
046             if (cmd.getTapeNumber() < 1 || cmd.getTapeNumber() > tapes.length) {
047                 session.write("- Unknown tape number: " + cmd.getTapeNumber());
048                 StateControl.breakAndGotoNext(EMPTY);
049             } else {
050                 context.tapeName = tapes[cmd.getTapeNumber() - 1];
051                 session.write("+ \"" + context.tapeName + "\" loaded");
052             }
053         }
054  
055         @IoHandlerTransitions({
056             @IoHandlerTransition(on = MESSAGE_RECEIVED, in = LOADED, next = PLAYING),
057             @IoHandlerTransition(on = MESSAGE_RECEIVED, in = PAUSED, next = PLAYING)
058         })
059         public void playTape(TapeDeckContext context, IoSession session, PlayCommand cmd) {
060             session.write("+ Playing \"" + context.tapeName + "\"");
061         }
062          
063         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = PLAYING, next = PAUSED)
064         public void pauseTape(TapeDeckContext context, IoSession session, PauseCommand cmd) {
065             session.write("+ \"" + context.tapeName + "\" paused");
066         }
067          
068         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = PLAYING, next = LOADED)
069         public void stopTape(TapeDeckContext context, IoSession session, StopCommand cmd) {
070             session.write("+ \"" + context.tapeName + "\" stopped");
071         }
072          
073         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = LOADED, next = EMPTY)
074         public void ejectTape(TapeDeckContext context, IoSession session, EjectCommand cmd) {
075             session.write("+ \"" + context.tapeName + "\" ejected");
076             context.tapeName = null;
077         }
078          
079         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = ROOT)
080         public void listTapes(IoSession session, ListCommand cmd) {
081             StringBuilder response = new StringBuilder("+ (");
082             for (int i = 0; i < tapes.length; i++) {
083                 response.append(i + 1).append(": ");
084                 response.append('"').append(tapes[i]).append('"');
085                 if (i < tapes.length - 1) {
086                     response.append(", ");
087                 }
088             }
089             response.append(')');
090             session.write(response);
091         }
092          
093         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = ROOT)
094         public void info(TapeDeckContext context, IoSession session, InfoCommand cmd) {
095             String state = context.getCurrentState().getId().toLowerCase();
096             if (context.tapeName == null) {
097                 session.write("+ Tape deck is " + state + "");
098             } else {
099                 session.write("+ Tape deck is " + state
100                         + ". Current tape: \"" + context.tapeName + "\"");
101             }
102         }
103          
104         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = ROOT)
105         public void quit(TapeDeckContext context, IoSession session, QuitCommand cmd) {
106             session.write("+ Bye! Please come back!").addListener(IoFutureListener.CLOSE);
107         }
108          
109         @IoHandlerTransition(on = MESSAGE_RECEIVED, in = ROOT, weight = 10)
110         public void error(Event event, StateContext context, IoSession session, Command cmd) {
111             session.write("- Cannot " + cmd.getName()
112                     + " while " + context.getCurrentState().getId().toLowerCase());
113         }
114          
115         @IoHandlerTransition(on = EXCEPTION_CAUGHT, in = ROOT)
116         public void commandSyntaxError(IoSession session, CommandSyntaxException e) {
117             session.write("- " + e.getMessage());
118         }
119          
120         @IoHandlerTransition(on = EXCEPTION_CAUGHT, in = ROOT, weight = 10)
121         public void exceptionCaught(IoSession session, Exception e) {
122             e.printStackTrace();
123             session.close(true);
124         }
125          
126         @IoHandlerTransition(in = ROOT, weight = 100)
127         public void unhandledEvent() {
128         }
129          
130 }

命令的抽象类：

1 package com.a2.desktop.example10.mina.statemachine;
2  
3 public abstract class Command {
4      public abstract String getName();
5 }

以下是各类命令，实现形式相似：

01 package com.a2.desktop.example10.mina.statemachine;
02  
03 public class LoadCommand extends Command {
04      
05     public static final String NAME = "load";
06  
07     private final int tapeNumber;
08  
09     public LoadCommand(int tapeNumber) {
10         this.tapeNumber = tapeNumber;
11     }
12  
13     public int getTapeNumber() {
14         return tapeNumber;
15     }
16  
17     @Override
18     public String getName() {
19         return NAME;
20     }
21  
22 }
23  
24 package com.a2.desktop.example10.mina.statemachine;
25  
26 public class PlayCommand extends Command {
27  
28     public static final String NAME = "play";
29  
30     @Override
31     public String getName() {
32         return NAME;
33     }
34 }
35 //以下省略各种命令…

下面是解码器,继承了文本的解码方式：

01 package com.a2.desktop.example10.mina.statemachine;
02  
03 import java.nio.charset.Charset;
04 import java.util.LinkedList;
05  
06 import org.apache.mina.core.buffer.IoBuffer;
07 import org.apache.mina.core.filterchain.IoFilter.NextFilter;
08 import org.apache.mina.core.session.IoSession;
09 import org.apache.mina.filter.codec.ProtocolDecoderOutput;
10 import org.apache.mina.filter.codec.textline.LineDelimiter;
11 import org.apache.mina.filter.codec.textline.TextLineDecoder;
12  
13 public class CommandDecoder extends TextLineDecoder {
14  
15      public CommandDecoder() {
16             super(Charset.forName("UTF8"), LineDelimiter.WINDOWS);
17         }
18          
19         private Object parseCommand(String line) throws CommandSyntaxException {
20             String[] temp = line.split(" +", 2);
21             String cmd = temp[0].toLowerCase();
22             String arg = temp.length > 1 ? temp[1] : null;
23              
24             if (LoadCommand.NAME.equals(cmd)) {
25                 if (arg == null) {
26                     throw new CommandSyntaxException("No tape number specified");
27                 }
28                 try {
29                     return new LoadCommand(Integer.parseInt(arg));
30                 } catch (NumberFormatException nfe) {
31                     throw new CommandSyntaxException("Illegal tape number: " + arg);
32                 }
33             } else if (PlayCommand.NAME.equals(cmd)) {
34                 return new PlayCommand();
35             } else if (PauseCommand.NAME.equals(cmd)) {
36                 return new PauseCommand();
37             } else if (StopCommand.NAME.equals(cmd)) {
38                 return new StopCommand();
39             } else if (ListCommand.NAME.equals(cmd)) {
40                 return new ListCommand();
41             } else if (EjectCommand.NAME.equals(cmd)) {
42                 return new EjectCommand();
43             } else if (QuitCommand.NAME.equals(cmd)) {
44                 return new QuitCommand();
45             } else if (InfoCommand.NAME.equals(cmd)) {
46                 return new InfoCommand();
47             }
48              
49             throw new CommandSyntaxException("Unknown command: " + cmd);
50         }
51  
52         @Override
53         public void decode(IoSession session, IoBuffer in, final ProtocolDecoderOutput out)
54                 throws Exception {
55              
56             final LinkedList<String> lines = new LinkedList<String>();
57             super.decode(session, in, new ProtocolDecoderOutput() {
58                 public void write(Object message) {
59                     lines.add((String) message);
60                 }
61                 public void flush(NextFilter nextFilter, IoSession session) {}
62             });
63              
64             for (String s: lines) {
65                 out.write(parseCommand(s));
66             }
67         }
68 }

处理异常类：

01 package com.a2.desktop.example10.mina.statemachine;
02  
03 import org.apache.mina.filter.codec.ProtocolDecoderException;
04  
05 /**
06  * Exception thrown by CommandDecoder when a line cannot be decoded as a Command
07  * object.
08  *
09  */
10 public class CommandSyntaxException extends ProtocolDecoderException {
11     private final String message;
12  
13     public CommandSyntaxException(String message) {
14         super(message);
15         this.message = message;
16     }
17  
18     @Override
19     public String getMessage() {
20         return message;
21     }
22 }
测试类：
01 package com.a2.desktop.example10.mina.statemachine;
02  
03 import java.net.InetSocketAddress;
04  
05 import org.apache.mina.core.service.IoHandler;
06 import org.apache.mina.filter.codec.ProtocolCodecFilter;
07 import org.apache.mina.filter.codec.textline.TextLineEncoder;
08 import org.apache.mina.filter.logging.LoggingFilter;
09 import org.apache.mina.statemachine.StateMachine;
10 import org.apache.mina.statemachine.StateMachineFactory;
11 import org.apache.mina.statemachine.StateMachineProxyBuilder;
12 import org.apache.mina.statemachine.annotation.IoHandlerTransition;
13 import org.apache.mina.statemachine.context.IoSessionStateContextLookup;
14 import org.apache.mina.statemachine.context.StateContext;
15 import org.apache.mina.statemachine.context.StateContextFactory;
16 import org.apache.mina.transport.socket.SocketAcceptor;
17 import org.apache.mina.transport.socket.nio.NioSocketAcceptor;
18  
19 public class TestMain {
20      private static final int PORT = 8082;
21          
22         private static IoHandler createIoHandler() {
23             StateMachine sm = StateMachineFactory.getInstance(
24                     IoHandlerTransition.class).create(TapeDeckServer.EMPTY,
25                     new TapeDeckServer());
26  
27             return new StateMachineProxyBuilder().setStateContextLookup(
28                     new IoSessionStateContextLookup(new StateContextFactory() {
29                         public StateContext create() {
30                             return new TapeDeckServer.TapeDeckContext();
31                         }
32                     })).create(IoHandler.class, sm);
33         }
34          
35         public static void main(String[] args) throws Exception {
36             SocketAcceptor acceptor = new NioSocketAcceptor();
37             acceptor.setReuseAddress(true);
38             ProtocolCodecFilter pcf = new ProtocolCodecFilter(
39                     new TextLineEncoder(), new CommandDecoder());
40             acceptor.getFilterChain().addLast("log1", new LoggingFilter("log1"));
41             acceptor.getFilterChain().addLast("codec", pcf);
42             acceptor.getFilterChain().addLast("log2", new LoggingFilter("log2"));
43             acceptor.setHandler(createIoHandler());
44             acceptor.bind(new InetSocketAddress(PORT));
45         }
46 }

启动测试类，用telnet去连，然后输入各种命令，效果如下：

更详细的代码可以参阅: org.apache.mina.example.tapedeck

代码其实都不难，只是我们需要灵活的将状态机这样的模式运用到自己的项目中去，通过状态之间的有规则的切换来控制更复杂的业务逻辑。
hxwhou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一种基于Mina状态机的高性能服务器的设计方法
11-14
基于 Mina 状态机的服务器设计方法通过实现状态机，编写自定义编解码器，并在 Mina 框架中创建状态机对象，设置 I/O 代理的过程，编制了基于 Mina 状态机的五子棋游戏服务器程序。在模拟环境下，测试结果表明，该...
mina-statemachine-2.0.2.jar
04-26
mina-statemachine-2.0.2.jar
apache mina 学习（十二）-----状态机（stateMachine）
Cages的专栏
03-21 138
mina状态机的工作原理： mina中引入了StateContext对象，顾名思义是一个状态上下文对象，用来保存当前的状态，当代理state对象的方法被调用的时候，这个上下文对象会通知stateContextLookup的实例去从方法参数中获取stateContext，通常情况下StateContextLookup 的实现类会循环方法的参数进行查找，并创建指定的对...
Mina状态机介绍(Introduction to mina-statemachine)
中國壹石頭
07-13 132
如果你使用Mina开发一个复杂的网络应用时，你可能在某些地方会遇到那个古老而又好用的状态模式，来使用这个模式解决你的复杂应用。然而，在你做这个决定之前，你或许想检出Mina的状态机的代码，它会根据当前对象的状态来返回对接收到的简短的数据的处理信息。   注意：现在正式发布Mina的状态机。因此你要自己在Mina的SVN服务器上检出该代码，并自己编译，请参考开发指南，来获取更多的关于检出和编译M...
Mina状态机StateMachine
cruise技术博客
11-06 1717
首先，关于状态机的一个极度确切的描述是它是一个有向图形，由一组节点和一组相应的转移函数组成。状态机通过响应一系列事件而“运行”。每个事件都在属于“当前” 节点的转移函数的控制范围内，其中函数的范围是节点的一个子集。函数返回“下一个”（也许是同一个）节点。这些节点中至少有一个必须是终态。当到达终态， 状态机停止。 接下来的问题是，我们为什么要用状态机，什么时候用： 传统应用程序的控制流程基本
Mina State machine状态机讲解
纸上得来终觉浅，绝知此事要躬行
06-16 4571
原文地址：Mina State machine(Apache Mina User guide Chapter14 State machine) 如果您使用的是Mina与复杂网络开发应用程序交互，你可能在某些时候发现自己达到的美好状态模式尝试解决一些复杂性。然而，在你这样做之前你可能想检查mina-statemachine试图解决一些状态模式的不足之处。 1.1.1. 一个简单的例子 让我们演
Mina状态机介绍和实例
02-26
MINA(Multipurpose Infrastructure for Network Applications)是用于开发高性能和高可用性的网络应用程序的基础框架。通过使用MINA框架可以可以省下处理底层I/O和线程并发等复杂工作，开发人员能够把更多的精力投入...
mina-master_mina_
09-29
Apache MINA（Multipurpose Infrastructure for Network Applications）是一个高度可扩展且功能丰富的网络应用程序框架，主要用于简化开发高性能、高效率的服务端应用。MINA提供了一种与传输协议无关的API，支持多种...
Mina 2.1.3压缩包
08-31
Apache Mina是一个高度可扩展的网络通信框架，用于构建高性能、高效率的服务端应用程序。它提供了基于事件驱动、非阻塞I/O模型的基础架构，使得开发者可以更容易地处理并发连接和大规模网络通信。Mina 2.1.3是这个...
使用Spring StateMachine框架实现状态机
weixin_30883311的博客
07-09 884
spring statemachine刚出来不久，但是对于一些企业的大型应用的使用还是十分有借鉴意义的。 最近使用了下这个，感觉还是挺好的。 下面举个例子来说下吧： 　　　创建一个Spring Boot的基础工程，并在pom.xml中加入spring-statemachine-core的依赖，具体如下： <parent> &...
spring statemachine 简单示例
zh_haining的博客
05-29 2317
最近在网上看到了一些关于spring statemachine 的示例，因为自己在学习过程中，看了例子后总是感觉缺少点什么，大家关注的业务参数如何传递说了但是没有给具体示例，下面是我自己在学习中的示例：示例简单实现一个订单状态机，模拟使用三个线程开启三个订单状态的的流转，其中流转过程中传递参数并获取参数；同时自己也遇到几个问题，文末提出；话不多说，上代码： 状态及事件定义： ...
mina教程
孔令宽的专栏
11-20 1333
  简介： Apache MINA 2 是一个开发高性能和高可伸缩性网络应用程序的网络应用框架。它提供了一个抽象的事件驱动的异步 API，可以使用 TCP/IP、UDP/IP、串口和虚拟机内部的管道等传输方式。Apache MINA 2 可以作为开发网络应用程序的一个良好基础。本文将介绍 Apache MINA 2 的基本概念和 API，包括 I/O 服务、I/O 会话、I/O 过滤器和 I/O...
状态机StateMachine使用小记
热门推荐
小熙的博客
06-04 2万+
概要：Spring Statemachine 状态机之所以强大，是因为始终保证行为是一致的，这使得调试相对容易。这是因为在机器启动时，操作规则是不可更改的。其思想是，应用程序可能存在有限数量的状态，某些预定义的触发器可以将应用程序从一种状态转移到另一种状态。这样的触发器可以基于事件或计时器。 在应用程序之外定义高级逻辑，然后依靠状态机来管理状态要容易得多。您可以通过发送事件、侦听更改或请求当前状态来与状态机交互。 官网地址：https://projects.spring.io/spring-statemac
Spring StateMachine使用笔记
hsqyz519的博客
09-16 7048
Spring StateMachine使用笔记 配置状态机 状态 分层状态 withStates() 配置状态 states状态列表 可以使用多个withStates进行parent分层 配置区域:当相同的分层状态机具有多组状态时，每个都具有初始状态，就产生正交状态，多个独立区域 .withStates() .i...
stateMachine 概念
我只是好奇
05-06 1362
LogRec : 保存已处理消息的信息 private IState mState; //当前的state private IState mOrgState; //消息未被处理之前的state private IState mDstState; //需要转变到的state LogRecords : 保存stateMachine最近处理...
Android学习 StateMachine与State模式
weixin_34183910的博客
06-05 416
　　　　　　Android学习 StateMachine与State模式 一 State模式 意图： 　　允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。（Objects for States） 　　对象内部状态决定行为方式，对象状态改变行为方式改变；但这里为何要强调内部状态， 外部状态改变也同样会影响行为方式的改变，通常外部状态的改变都会反映到内部状态上来。 ...
Spring StateMachine 状态机入门(项目实战)
Coding for freedom
09-01 4570
背景介绍 最近在公司做一个Spring Boot表单项目，表单涉及的状态如图所示： 在设计表单状态转换模块时，想到状态机这个概念。在网上检索相关的实现框架，发现Spring StateMachine框架。网上大多数的教程都是非常简单的Demo，只有一个状态机连续切换的示例，很难作为一个实战入门的Demo。幸运的是在网上找到了一个Spring系列的视频，其中涉及到了状态机的实战项目。这篇文章也是基于该视频教程，结合自己的项目实践做一个完整的状态机实战笔记。 StateMachine实战 Spring Sta
StateMachine状态机初识
sjz4860402的专栏
11-14 3484
StateMachine状态机的介绍中，以下的这篇博客讲得已经很全面了。 http://www.cnblogs.com/bastard/archive/2012/06/05/2536258.html为了更加方便的理解，个人简单的画了一张时序图：具体的使用：要实现自己的StateMachine并让它跑起来，需要做以下几个工作： 一 . 实现自己的State子类。 StateMachine已经帮我
Mina2.0快速入门与源码剖析
最新发布
09-14
Mina2.0快速入门与源码剖析

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值