Mina状态机StateMachine()

状态机在通信中的应用
最新推荐文章于 2025-06-27 14:48:11 发布
转载 最新推荐文章于 2025-06-27 14:48:11 发布 · 2.3k 阅读 · 0
文章标签：

#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

代码其实都不难，只是我们需要灵活的将状态机这样的模式运用到自己的项目中去，通过状态之间的有规则的切换来控制更复杂的业务逻辑。
Spring StateMachine 状态机入门(项目实战)
Coding for freedom
09-01 5698
背景介绍 最近在公司做一个Spring Boot表单项目，表单涉及的状态如图所示： 在设计表单状态转换模块时，想到状态机这个概念。在网上检索相关的实现框架，发现Spring StateMachine框架。网上大多数的教程都是非常简单的Demo，只有一个状态机连续切换的示例，很难作为一个实战入门的Demo。幸运的是在网上找到了一个Spring系列的视频，其中涉及到了状态机的实战项目。这篇文章也是基于该视频教程，结合自己的项目实践做一个完整的状态机实战笔记。 StateMachine实战 Spring Sta
apache mina 学习（十二）-----状态机（stateMachine）
Cages的专栏
03-21 215
mina状态机的工作原理： mina中引入了StateContext对象，顾名思义是一个状态上下文对象，用来保存当前的状态，当代理state对象的方法被调用的时候，这个上下文对象会通知stateContextLookup的实例去从方法参数中获取stateContext，通常情况下StateContextLookup 的实现类会循环方法的参数进行查找，并创建指定的对...
Mina状态机介绍(Introduction to mina-statemachine)
中國壹石頭
07-13 190
如果你使用Mina开发一个复杂的网络应用时，你可能在某些地方会遇到那个古老而又好用的状态模式，来使用这个模式解决你的复杂应用。然而，在你做这个决定之前，你或许想检出Mina的状态机的代码，它会根据当前对象的状态来返回对接收到的简短的数据的处理信息。   注意：现在正式发布Mina的状态机。因此你要自己在Mina的SVN服务器上检出该代码，并自己编译，请参考开发指南，来获取更多的关于检出和编译M...
Mina状态机StateMachine
cruise技术博客
11-06 1811
首先，关于状态机的一个极度确切的描述是它是一个有向图形，由一组节点和一组相应的转移函数组成。状态机通过响应一系列事件而“运行”。每个事件都在属于“当前” 节点的转移函数的控制范围内，其中函数的范围是节点的一个子集。函数返回“下一个”（也许是同一个）节点。这些节点中至少有一个必须是终态。当到达终态， 状态机停止。 接下来的问题是，我们为什么要用状态机，什么时候用： 传统应用程序的控制流程基本
Mina State machine状态机讲解
纸上得来终觉浅，绝知此事要躬行
06-16 4688
原文地址：Mina State machine(Apache Mina User guide Chapter14 State machine) 如果您使用的是Mina与复杂网络开发应用程序交互，你可能在某些时候发现自己达到的美好状态模式尝试解决一些复杂性。然而，在你这样做之前你可能想检查mina-statemachine试图解决一些状态模式的不足之处。 1.1.1. 一个简单的例子 让我们演
Mina2中文文档
07-06
#### Chapter 14 - StateMachine(状态机) - **状态机设计**：介绍了如何利用状态机模式优化Mina应用程序的状态管理。 #### Chapter 15 - 代理 - **代理支持**：探讨了Mina对代理服务器的支持情况，包括配置和使用...
状态机设计模式 java开源代码
08-19
Spring Statemachine 是 Spring 官方提供的状态机框架，支持高级功能如状态嵌套、并行状态、子状态机等。它与 Spring 框架高度集成，适合在 Spring Boot 项目中使用。该框架的文档完善，社区活跃，适合需要复杂状态...
MINA2项目所用JAR包
05-09
3. **mina-statemachine-2.0.7.jar**：状态机模块，提供了对状态转换和事件处理的支持，适用于实现复杂的网络协议解析或业务逻辑流程控制。 4. **slf4j-api-1.6.6-sources.jar** 和 **slf4j-api-1.6.6.jar**：SLF4J...
用java实现状态机
最新发布
08-28
我们被要求用Java实现一个状态机。...2. Spring StateMachine 与自定义状态机的性能对比如何？ 3. 状态机在分布式事务（如Saga模式）中如何应用？ 4. 如何实现状态机的版本兼容性（支持状态规则变更）？
mina2.0全部jar包
02-27
mina-statemachine-2.0.7.jar提供了状态机的支持，使得开发者能够以声明式的方式定义和管理对象的状态转换，这在处理网络协议或者业务逻辑流程时非常有用。 mina-integration-beans-2.0.7.jar和mina-integration-...
Spring状态机 Statemachine使用
weixin_42190492的博客
06-27 1888
状态机（State Machine）是一种描述系统行为的数学模型，核心思想是将系统抽象为有限个状态，并通过状态转移规则定义系统如何响应外部事件。它由一系列状态（States）、转换（Transitions）、事件（Events）、卫兵（Guards）和动作（Actions）组成。在软件开发中，状态机常用于控制程序的流程和状态变化。其核心优势在于: 通过清晰明确的状态定义、自动状态更新，将复杂的状态流转逻辑结构化。从而使得业务逻辑与状态解耦。
Spring state machine 状态机
qinheJ的博客
08-16 2151
一、活动状态机配置 package com.zhibi.xiuba.configurer; import com.zhibi.xiuba.statemachine.EventsOnTransition; import com.zhibi.xiuba.statemachine.TaskEvent; import com.zhibi.xiuba.task.spi.domain.Task...
spring statemachine 简单示例
zh_haining的博客
05-29 2460
最近在网上看到了一些关于spring statemachine 的示例，因为自己在学习过程中，看了例子后总是感觉缺少点什么，大家关注的业务参数如何传递说了但是没有给具体示例，下面是我自己在学习中的示例：示例简单实现一个订单状态机，模拟使用三个线程开启三个订单状态的的流转，其中流转过程中传递参数并获取参数；同时自己也遇到几个问题，文末提出；话不多说，上代码： 状态及事件定义： ...
statemachine简介及简单应用
green hand的博客
06-14 9007
1.背景 1.1 spring statemachine是干啥用的 有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。将状态和事件控制从不同的业务Service方法的if else中抽离出来。FSM的应用范围很广，对于有复杂状态流，扩展性要求比较高的场景都可以使用该模型。下面是状态机模型中的4个要素，即现态、条件、动作、次态。 现态：是指当前所处的状态。 条件：又称为“事件”。当一个条件被满足，..
StateMachine状态机初识
sjz4860402的专栏
11-14 3744
StateMachine状态机的介绍中，以下的这篇博客讲得已经很全面了。 http://www.cnblogs.com/bastard/archive/2012/06/05/2536258.html为了更加方便的理解，个人简单的画了一张时序图：具体的使用：要实现自己的StateMachine并让它跑起来，需要做以下几个工作： 一 . 实现自己的State子类。 StateMachine已经帮我
stateMachine 概念
拒绝背八股文
05-06 1436
LogRec : 保存已处理消息的信息 private IState mState; //当前的state private IState mOrgState; //消息未被处理之前的state private IState mDstState; //需要转变到的state LogRecords : 保存stateMachine最近处理...
Android学习 StateMachine与State模式
weixin_34183910的博客
06-05 579
　　　　　　Android学习 StateMachine与State模式 一 State模式 意图： 　　允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。（Objects for States） 　　对象内部状态决定行为方式，对象状态改变行为方式改变；但这里为何要强调内部状态， 外部状态改变也同样会影响行为方式的改变，通常外部状态的改变都会反映到内部状态上来。 ...
Spring StateMachine使用笔记
hsqyz519的博客
09-16 7424
Spring StateMachine使用笔记 配置状态机 状态 分层状态 withStates() 配置状态 states状态列表 可以使用多个withStates进行parent分层 配置区域:当相同的分层状态机具有多组状态时，每个都具有初始状态，就产生正交状态，多个独立区域 .withStates() .i...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值