Fork me on GitHub

spring-machine-02 cd player

阅读数:0次
字数统计: 3.6k字   |   阅读时长≈ 16分

为了进一步学习spring statemachine 本文将继续讲解spring状态机案列CD Player .它类似于现实世界中使用过的CD播放器。CD播放器本身是一个非常简单的实体，它允许用户打开甲板，插入或更换CD，然后按各个按钮调整播放器的功能（出仓和关仓）eject，（播放）play， （停止）stop，（暂停和开始）pause，(上一曲)back，和（下一曲）forward）。

cd player

​ 为了进一步学习spring statemachine 本文将继续讲解spring状态机案列CD Player .它类似于现实世界中使用过的CD播放器。CD播放器本身是一个非常简单的实体，它允许用户打开甲板，插入或更换CD，然后按各个按钮调整播放器的功能（出仓和关仓）eject，（播放）play， （停止）stop，（暂停和开始）pause，(上一曲)back，和（下一曲）forward）。

​ 我们使用过程中很少有人去考虑，怎样去编写与硬件交互以驱动 CD 播放器的代码。是的，我们使用很简单，但是如果我们去看看幕后代码，事情实际上会变得有点复杂。

​ 首先让我们描述下场景：首先我们得有CD播放机和CD库。有了这两样我们就可以播放了，首先弹出舱门eject然后放入CDcd load,之后我们可能会直接按play按钮播放（此时应该关仓+播放）或者按关仓后播放，播放之后，播放CD中的当前曲目时间会逐渐+1s，期间我们可以按暂停播放停止播放等行为。

通过简单的描述我们可能已经注意到，如果甲板已经打开并按下播放键，甲板会关闭并开始播放歌曲（如果插入了 CD）。从某种意义上说，当甲板打开时，您首先需要关闭它，然后尝试开始播放（同样，如果确实插入了 CD）。CD 播放器就是如此简单。当然，我们可以用一个简单的类来包装所有这些，这个类有一些bool变量，可能还有一些嵌套的 if-else 子句,这些可以帮助我们完成这项工作，但是如果我们遇到的行为变得更加复杂怎么办？你真的想继续添加更多的标志位和 if-else 子句吗？当然不否则程序维护将更加困难。

流程

状态描述

首先我们描述下cd应该有哪些状态？

1
2
3
4
5
可以分为两大类：工作状态(busy)和空闲状态(idle)
工作状态：包括播放中、暂停中状态 播放中按暂停按钮变暂停，再按暂停变播放中
空闲状态：包括关仓状态和出仓状态 关仓状态按出仓变出仓再按出仓变关仓
工作状态安下停止键变空闲状态
空闲状态按下播放键变工作状态

状态行为图

状态图3

完整过程

状态机启动，之后我们查找有哪些cd可以用，出仓，放入cd并并关仓，开始播放，然后可以暂停、停止、出仓、换cd等操作。

实现

0、状态和事件定义

1
2
3
4
5
6
7
8
9
10
11
// 状态
public enum States {
    // super state of PLAYING and PAUSED
    BUSY, // 工作中
    PLAYING,
    PAUSED,
    // super state of CLOSED and OPEN
    IDLE, // 空闲
    CLOSED,
    OPEN
}
1
2
3
4
// 事件代表用户可以按下的按钮以及用户是否将光盘加载到播放器中
public enum Events {
    PLAY, STOP, PAUSE, EJECT, LOAD, FORWARD, BACK
}
1
2
3
4
// 扩展状态记录当前播放的哪张cd哪首歌以及歌播放的时间
public enum Variables {
    CD, TRACK, ELAPSEDTIME
}
1
2
3
4
// 上一曲下一曲headers设置TRACKSHIFT
public enum Headers {
    TRACKSHIFT
}

状态定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Override
      public void configure(StateMachineStateConfigurer<States, Events> states)
              throws Exception {
          states
                  .withStates()
                      .initial(States.IDLE)
                      .state(States.IDLE)
                      .and()
                      .withStates()
                          .parent(States.IDLE)
                          .initial(States.CLOSED)
                          .state(States.CLOSED, closedEntryAction(), null)
                          .state(States.OPEN)
                          .and()
                  .withStates()
                      .state(States.BUSY)
                      .and()
                      .withStates()
                          .parent(States.BUSY)
                          .initial(States.PLAYING)
                          .state(States.PLAYING)
                          .state(States.PAUSED);
      }

转换定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
@Override
    public void configure(StateMachineTransitionConfigurer<States, Events> transitions)
            throws Exception {
        transitions
                .withExternal()
                    .source(States.CLOSED).target(States.OPEN).event(Events.EJECT)
                    .and()
                .withExternal()
                    .source(States.OPEN).target(States.CLOSED).event(Events.EJECT)
                    .and()
                .withExternal()
                    .source(States.OPEN).target(States.CLOSED).event(Events.PLAY)
                    .and()
                .withExternal()
                    .source(States.PLAYING).target(States.PAUSED).event(Events.PAUSE)
                    .and()
                .withInternal()
                    .source(States.PLAYING)
                    .action(playingAction())
                    .timer(1000)
                    .and()
                .withInternal()
                    .source(States.PLAYING).event(Events.BACK)
                    .action(trackAction())
                    .and()
                .withInternal()
                    .source(States.PLAYING).event(Events.FORWARD)
                    .action(trackAction())
                    .and()
                .withExternal()
                    .source(States.PAUSED).target(States.PLAYING).event(Events.PAUSE)
                    .and()
                .withExternal()
                    .source(States.BUSY).target(States.IDLE).event(Events.STOP)
                    .and()
                .withExternal()
                    .source(States.IDLE).target(States.BUSY).event(Events.PLAY)
                    .action(playAction())
                    .guard(playGuard())
                    .and()
                .withInternal()
                    .source(States.OPEN).event(Events.LOAD).action(loadAction());
    }

在前面的配置中：

  • EnumStateMachineConfigurerAdapter配置状态和转换。
  • 设置IDLE的子状态CLOSED和OPEN状态，BUSY的子状态PLAYING和PAUSED。
  • 对于CLOSED状态，我们添加了进入状态的动作 closedEntryAction。
  • 状态转换，其中EJECT关闭和打开甲板、PLAY，STOP和PAUSE做简单的转换。对于其他转换，我们执行了以下操作：
    • 对于源状态PLAYING，我们添加了一个定时器触发器，自动跟踪播放曲目中的经过时间，并有一个判断会决定何时切换到下一曲目。
    • 对于PLAY事件，如果源状态是IDLE，目标状态是 BUSY，我们定义了一个名为 的动作playAction和一个名为 的守卫playGuard。
    • 对于LOAD事件和OPEN状态，我们使用名为 的动作定义了一个内部转换loadAction，它跟踪插入带有扩展状态变量的光盘。
    • 对于PLAYING状态定义了三个内部转换。一个由运行称为 的操作的计时器触发，该操作playingAction更新扩展状态变量。其他两个转换使用trackAction 不同的事件（分别为BACK和FORWARD）来处理用户想要在轨道中后退或前进的情况。

1、曲库查询

首先我们得有个查库操作看看有哪些cd唱片。

cd信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Cd {
    private final String name;
    // q
    private final Track[] tracks;
    public Cd(String name, Track[] tracks) {
        this.name = name;
        this.tracks = tracks;
    }
    public String getName() {
        return name;
    }
    public Track[] getTracks() {
        return tracks;
    }
    @Override
    public String toString() {
        return name;
    }
}

曲目信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Track {
	private final String name;
	private final long length;
	public Track(String name, long length) {
		this.name = name;
		this.length = length;
	}
	public String getName() {
		return name;
	}
	public long getLength() {
		return length;
	}
	@Override
	public String toString() {
		return name;
	}
}

曲库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Library {

    private final List<Cd> collection;

    public Library(Cd[] collection) {
        this.collection = Arrays.asList(collection);
    }

    public List<Cd> getCollection() {
        return collection;
    }

    public static Library buildSampleLibrary() {
        Track cd1track1 = new Track("Bohemian Rhapsody", 5 * 60 + 56);
        Track cd1track2 = new Track("Another One Bites the Dust", 3 * 60 + 36);
        Cd cd1 = new Cd("Greatest Hits", new Track[] { cd1track1, cd1track2 });
        Track cd2track1 = new Track("A Kind of Magic", 4 * 60 + 22);
        Track cd2track2 = new Track("Under Pressure", 4 * 60 + 8);
        Cd cd2 = new Cd("Greatest Hits II", new Track[] { cd2track1, cd2track2 });
        return new Library(new Cd[] { cd1, cd2 });
    }

}

加载曲库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@CliCommand(value = "cd library", help = "List user CD library")
public String library() {
    SimpleDateFormat format = new SimpleDateFormat("mm:ss");
    StringBuilder buf = new StringBuilder();
    int i1 = 0;
    for (Cd cd : library.getCollection()) {
        buf.append(i1++ + ": " + cd.getName() + "\n");
        int i2 = 0;
        for (Track track : cd.getTracks()) {
            buf.append("  " + i2++ + ": " + track.getName() + "  " + format.format(new Date(track.getLength()*1000)) + "\n");
        }
    }
    return buf.toString();
}

2、出仓

3、放入cd

放入cd的时候我们需要记录当前放的是哪一张cd，所以这里有个扩展变量1CD信息

1
2
3
4
5
6
public void load(Cd cd) {
    stateMachine
        .sendEvent(Mono.just(MessageBuilder
                             .withPayload(Events.LOAD).setHeader(Variables.CD.toString(), cd).build()))
        .subscribe();
}

事件发送之后的处理

1
2
.withInternal()
                        .source(States.OPEN).event(Events.LOAD).action(loadAction());

LoadAction如果事件标头包含有关要加载的光盘的信息，则更新扩展状态变量。以下清单定义了LoadAction：

1
2
3
4
5
6
7
8
9
public static class LoadAction implements Action<States, Events> {
    @Override
    public void execute(StateContext<States, Events> context) {
        // 从head中获取加载哪张cd，并设置到扩展变量中。（扩展变量是其它状态均可访问的变量）
        Object cd = context.getMessageHeader(Variables.CD);
        // 设置扩展变量，也意味着cd播放机已经加载过cd
        context.getExtendedState().getVariables().put(Variables.CD, cd);
    }
}

4、开仓状态下的关仓或播放

这里有两种情况会导致关仓，开仓状态下按下关仓或者play。注意其中play事件触发的关仓，如果播放机里面有cd则进入播放状态

因为关仓后可能会主动进入播放状态，所以我们给关仓close这个状态设置了进入状态的一个动作，主要是判断是不是play事件导致的关仓并且里面有cd唱片

1
2
3
4
5
6
.withStates()
    .parent(States.IDLE)
    .initial(States.CLOSED)
    .state(States.CLOSED, closedEntryAction(), null)
    .state(States.OPEN)
    .and()

ClosedEntryAction是Close状态的入口动作，如果存在光盘，则向状态机CLOSED发送PLAY事件。以下定义了ClosedEntryAction：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
public void execute(StateContext<States, Events> context) {
    // 这里主要是open --[play]--> close 如果有cd则自动触发idle --[play]--> busy
    // 注意大状态只能到大状态 不能子状态到其它大状态或者大状态到其它子状态
    if (context.getTransition() != null
        && context.getEvent() == Events.PLAY
        && context.getTransition().getTarget().getId() == States.CLOSED
        && context.getExtendedState().getVariables().get(Variables.CD) != null) {
        context.getStateMachine()
            .sendEvent(Mono.just(MessageBuilder
                                 .withPayload(Events.PLAY).build()))
            .subscribe();
    }
}

5、关仓下的播放

主要判断里面是否有cd，有的话进行播放动作

1
2
3
4
5
.withExternal()
    .source(States.IDLE).target(States.BUSY).event(Events.PLAY)
    .action(playAction())
    .guard(playGuard())
    .and()

守卫playGuard()

1
2
3
4
5
6
@Override
public boolean evaluate(StateContext<States, Events> context) {
    // 获取加载cd是哪张cd，仅仅用来判断是否加载过cd
    ExtendedState extendedState = context.getExtendedState();
    return extendedState.getVariables().get(Variables.CD) != null;
}

动作playAction()

cd中会有很多歌曲每个歌曲有名称和时长，所以播放我们应该记录播放的是当前cd的哪一首歌以及播放的时长。所以这里又多了两个扩展状态TRACK，ELAPSEDTIME播放那首歌以及时长。

所以扩展变量如下：

1
2
3
public enum Variables {
    CD, TRACK, ELAPSEDTIME
}

进入播放动作后主要初始化一些信息，播放的当前曲目和时间

1
2
3
4
5
6
@Override
public void execute(StateContext<States, Events> context) {
    // 加载cd后播放动作初始化,cd中第一首歌，以及第一首歌播放时间默认第一张开始播放0。之后player内部定时触发内部转换，更新扩展变量信息
    context.getExtendedState().getVariables().put(Variables.ELAPSEDTIME, 0L);
    context.getExtendedState().getVariables().put(Variables.TRACK, 0);
}

6、播放中

播放中主要是顺序播放cd中的曲目。这里定时1s触发内部动作

1
2
3
4
5
.withInternal()
    .source(States.PLAYING)
    .action(playingAction())
    .timer(1000)
    .and()

playingAction()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@Override
public void execute(StateContext<States, Events> context) {
    Map<Object, Object> variables = context.getExtendedState().getVariables();
    // 当前播放时长
    Object elapsed = variables.get(Variables.ELAPSEDTIME);
    // 哪张cd
    Object cd = variables.get(Variables.CD);
    // 哪首曲目
    Object track = variables.get(Variables.TRACK);
    // 简单判断数据类型是否正确
    if (elapsed instanceof Long) {
        // 当前时间+1s
        long e = ((Long) elapsed) + 1000L;
        // e不允许大于曲目最大时间，如果大于设置 forward下一曲并换挡
        if (e > ((Cd) cd).getTracks()[((Integer) track)].getLength() * 1000) {
            context.getStateMachine()
                .sendEvent(Mono.just(MessageBuilder
                                     // 下一曲
                                     .withPayload(Events.FORWARD)
                                     // 换挡
                                     .setHeader(Headers.TRACKSHIFT.toString(), 1).build()))
                .subscribe();
        } else {
            // 否则的话更新曲目已播放时长
            variables.put(Variables.ELAPSEDTIME, e);
        }
    }
}

7、上一曲目和下一曲目

transational

1
2
3
4
5
6
7
8
.withInternal()
    .source(States.PLAYING).event(Events.BACK)
    .action(trackAction())
    .and()
.withInternal()
    .source(States.PLAYING).event(Events.FORWARD)
    .action(trackAction())
    .and()

触发事件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void forward() {
		stateMachine
			.sendEvent(Mono.just(MessageBuilder
				.withPayload(Events.FORWARD)
				.setHeader(Headers.TRACKSHIFT.toString(), 1).build()))
			.subscribe();
	}

	public void back() {
		stateMachine
			.sendEvent(Mono.just(MessageBuilder
				.withPayload(Events.BACK)
				.setHeader(Headers.TRACKSHIFT.toString(), -1).build()))
			.subscribe();
	}

trackAction()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Override
public void execute(StateContext<States, Events> context) {
    Map<Object, Object> variables = context.getExtendedState().getVariables();
    // 获取换挡信息（下一曲信息）Header
    Object trackshift = context.getMessageHeader(Headers.TRACKSHIFT.toString());
    // 获取当前曲目
    Object track = variables.get(Variables.TRACK);
    // 获取当前cd
    Object cd = variables.get(Variables.CD);
    // 简单的类型判断，防止程序被人乱改导致异常
    if (trackshift instanceof Integer && track instanceof Integer && cd instanceof Cd) {
        // 下一首 = 当前曲目+换挡数值1（也就是跳转曲目间隔数量）
        int next = ((Integer) track) + ((Integer) trackshift);
        // 曲目应该在当前cd范围内，在的话设置当前曲目+1 重置播放时长
        if (next >= 0 && ((Cd) cd).getTracks().length > next) {
            variables.put(Variables.ELAPSEDTIME, 0L);
            variables.put(Variables.TRACK, next);
            //否则 cd已经被播放完成了，play应该停止，触发停止事件
        } else if (((Cd) cd).getTracks().length <= next) {
            context.getStateMachine()
                .sendEvent(Mono.just(MessageBuilder
                                     .withPayload(Events.STOP).build()))
                .subscribe();
        }
    }
}

8、出仓、暂停、停止

发送对应的事件即可

1
2
3
4
5
6
public void stop() {
		stateMachine
			.sendEvent(Mono.just(MessageBuilder
				.withPayload(Events.STOP).build()))
			.subscribe();
	}
1
2
3
4
5
6
public void pause() {
	stateMachine
		.sendEvent(Mono.just(MessageBuilder
			.withPayload(Events.PAUSE).build()))
		.subscribe();
}
1
2
3
4
5
6
public void eject() {
	stateMachine
		.sendEvent(Mono.just(MessageBuilder
			.withPayload(Events.EJECT).build()))
		.subscribe();
}

9、查看当前播放的歌曲信息

这个因为内部在不断的定时播放，所以我们应该监听两个转换

1、to busy

说明有cd要播放

1
2
3
4
5
6
7
@OnTransition(target = "BUSY")
public void busy(ExtendedState extendedState) {
    Object cd = extendedState.getVariables().get(Variables.CD);
    if (cd != null) {
        cdStatus = ((Cd)cd).getName();
    }
}

2、to playing

说明有歌曲在播放

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@StatesOnTransition(target = States.PLAYING)
public void playing(ExtendedState extendedState) {
    // 播放时长
    Object elapsed = extendedState.getVariables().get(Variables.ELAPSEDTIME);
    // 当前cd
    Object cd = extendedState.getVariables().get(Variables.CD);
    // 当前曲目
    Object track = extendedState.getVariables().get(Variables.TRACK);
    // 简单的类型判断
    if (elapsed instanceof Long && track instanceof Integer && cd instanceof Cd) {
        SimpleDateFormat format = new SimpleDateFormat("mm:ss");
        trackStatus = ((Cd) cd).getTracks()[((Integer) track)]
            + " " + format.format(new Date((Long) elapsed));
    }
}

因为想让这个样本类型安全，所以定义了自己的注释 ( @StatesOnTransition)，它有一个强制性的元注释 ( @OnTransition)。

1
2
3
4
5
6
7
8
9
10
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@OnTransition
public @interface StatesOnTransition {

    States[] source() default {};

    States[] target() default {};

}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
sm>sm start
Entry state IDLE
Entry state CLOSED
State machine started

sm>cd lcd
No CD

sm>cd library
0: Greatest Hits
  0: Bohemian Rhapsody  05:56
  1: Another One Bites the Dust  03:36
1: Greatest Hits II
  0: A Kind of Magic  04:22
  1: Under Pressure  04:08

sm>cd eject
Exit state CLOSED
Entry state OPEN

sm>cd load 0
Loading cd Greatest Hits

sm>cd play
Exit state OPEN
Entry state CLOSED
Exit state CLOSED
Exit state IDLE
Entry state BUSY
Entry state PLAYING

sm>cd lcd
Greatest Hits Bohemian Rhapsody 00:03

sm>cd forward

sm>cd lcd
Greatest Hits Another One Bites the Dust 00:04

sm>cd stop
Exit state PLAYING
Exit state BUSY
Entry state IDLE
Entry state CLOSED

sm>cd lcd
Greatest Hits

运行说明：

  • 状态机启动，这导致机器被初始化。
  • 打印 CD 播放机的lcd屏幕状态。
  • 打印 CD 库。
  • CD 播放机的甲板被打开。
  • 将索引为 0 的 CD 装入甲板。
  • 播放导致甲板关闭并立即播放，因为插入了光盘。
  • 我们打印lcd状态并请求下一曲目。
  • 我们不玩了。
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、聚合支付、
公众号开发、开源爱好者、Linux

联系QQ:2013881276

很惭愧

只做了一点微小的工作
谢谢大家