通过实例学习SpringStateMachine之Tasks

最新推荐文章于 2024-08-25 17:10:43 发布
最新推荐文章于 2024-08-25 17:10:43 发布
阅读量830 收藏
点赞数
分类专栏： spring相关 通过实例学习SpringStateMachine
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Revivedsun/article/details/104456272
版权

背景介绍

本系列通过学习SpringStateMachine中附带的10余个Sample来学习SpringStateMachine中的各个概念和用法。项目是使用的分支为2.2.0.RELEASE[1]。项目参考文档也是2.2.0.RELEASE[1]。

Tasks简介

Tasks演示了在region内如何处理并行任务,并且添加了错误处理方法，在任务恢复执行前，通过自动或手动的方式修正问题。我们在使用状态机时常会遇到当一个事件发生后，会转移到多个状态上，执行对应的操作，当这些操作执行完毕后，在统一转换到一个状态上。Tasks这个demo就是通过fork、join这两个伪状态实现了一到多再到一这样的能力。此外在发生转换时我们希望根据条件转换到不同的状态上，这时候通过choice实现选选择性转换的能力。Tasks这个demo对应的状态机如下图所示：
在这里插入图片描述

  • 状态机总是会进入到READY状态，通过产生RUN事件来执行任务。
  • tasks状态有三个独立的region组成，这个状态处理fork和join状态之间。当fork状态进入到tasks状态后会转换到tasks的三个内部状态。当三个内部状态转换到其结束状态后，会继续转移到JOIN状态。
  • JOIN状态转移到CHOICE状态后会根据跳转检测是转换到READY状态还是ERROR状态
  • 在ERROR状态内转移到AUTOMATIC执行修复操作，如果失败通过触发FALLBACK事件转换到MANUAL状态。随后通过CONTINUE状态再回到READY状态。

Tasks 依赖

项目在实现上述功能时，需要依赖springshell，官方给出的demo[1]使用了spring-shell1.2，本文将其改为spring-shell 2.0.0.RELEASE。

 <dependency>
       <groupId>
            org.springframework.statemachine</groupId>
            <artifactId>spring-statemachine-core</artifactId>
            <version>2.2.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.shell</groupId>
            <artifactId>spring-shell-starter</artifactId>
            <version>2.0.0.RELEASE</version>
        </dependency>

Tasks 实现

Tasks状态机的状态与事件定义如下：

public enum States {
    READY,
    FORK, JOIN, CHOICE,
    TASKS, T1, T1E, T2, T2E, T3, T3E,
    ERROR, AUTOMATIC, MANUAL
}

public enum Events {
    RUN, FALLBACK, CONTINUE, FIX;
}

接着配置状态。由于需要使用一到多再到一的能力，因此配置中使用了fork和join方法配置fork与join状态。通过choice方法实现选择性状态转移。

@Override
public void configure(StateMachineStateConfigurer<States, Events> states)
		throws Exception {
	states
		.withStates()
			.initial(States.READY)
			.fork(States.FORK)
			.state(States.TASKS)
			.join(States.JOIN)
			.choice(States.CHOICE)
			.state(States.ERROR)
			.and()
			.withStates()
				.parent(States.TASKS)
				.initial(States.T1)
				.end(States.T1E)
				.and()
			.withStates()
				.parent(States.TASKS)
				.initial(States.T2)
				.end(States.T2E)
				.and()
			.withStates()
				.parent(States.TASKS)
				.initial(States.T3)
				.end(States.T3E)
				.and()
			.withStates()
				.parent(States.ERROR)
				.initial(States.AUTOMATIC)
				.state(States.AUTOMATIC, automaticAction(), null)
				.state(States.MANUAL);
}

接着配置转换。为了描述fork状态转换使用withFork方法。join使用withJoin方法描述。选择性状态通过withChoice方法描述。

使用withChoice通过配置的条件方法tasksChoiceGuard实现条件判断。当满足条件转换到ERROR状态，当不满足条件时候转换到READY状态。这里first作用相当与if…else中的if，而last相当与else。

@Override
public void configure(StateMachineTransitionConfigurer<States, Events> transitions)
		throws Exception {
	transitions
		.withExternal()
			.source(States.READY).target(States.FORK)
			.event(Events.RUN)
			.and()
		.withFork()
			.source(States.FORK).target(States.TASKS)
			.and()
		.withExternal()
			.source(States.T1).target(States.T1E)
			.and()
		.withExternal()
			.source(States.T2).target(States.T2E)
			.and()
		.withExternal()
			.source(States.T3).target(States.T3E)
			.and()
		.withJoin()
			.source(States.TASKS).target(States.JOIN)
			.and()
		.withExternal()
			.source(States.JOIN).target(States.CHOICE)
			.and()
		.withChoice()
			.source(States.CHOICE)
			.first(States.ERROR, tasksChoiceGuard())
			.last(States.READY)
			.and()
		.withExternal()
			.source(States.ERROR).target(States.READY)
			.event(Events.CONTINUE)
			.and()
		.withExternal()
			.source(States.AUTOMATIC).target(States.MANUAL)
			.event(Events.FALLBACK)
			.and()
		.withInternal()
			.source(States.MANUAL)
			.action(fixAction())
			.event(Events.FIX);
}

@Bean
public Guard<States, Events> tasksChoiceGuard() {
	return new Guard<States, Events>() {

		@Override
		public boolean evaluate(StateContext<States, Events> context) {
			Map<Object, Object> variables = context.getExtendedState().getVariables();
			return !(ObjectUtils.nullSafeEquals(variables.get("T1"), true)
					&& ObjectUtils.nullSafeEquals(variables.get("T2"), true)
					&& ObjectUtils.nullSafeEquals(variables.get("T3"), true));
		}
	};
}

@Bean
public Action<States, Events> automaticAction() {
	return new Action<States, Events>() {

		@Override
		public void execute(StateContext<States, Events> context) {
			Map<Object, Object> variables = context.getExtendedState().getVariables();
			if (ObjectUtils.nullSafeEquals(variables.get("T1"), true)
					&& ObjectUtils.nullSafeEquals(variables.get("T2"), true)
					&& ObjectUtils.nullSafeEquals(variables.get("T3"), true)) {
				context.getStateMachine().sendEvent(Events.CONTINUE);
			} else {
				context.getStateMachine().sendEvent(Events.FALLBACK);
			}
		}
	};
}

@Bean
public Action<States, Events> fixAction() {
	return new Action<States, Events>() {

		@Override
		public void execute(StateContext<States, Events> context) {
			Map<Object, Object> variables = context.getExtendedState().getVariables();
			variables.put("T1", true);
			variables.put("T2", true);
			variables.put("T3", true);
			context.getStateMachine().sendEvent(Events.CONTINUE);
		}
	};
}

接着定义我们的Tasks。定义当转换到fork后，随后再由fork到tasks，在tasks内部的三个子转换所对应的执行方法。

package springboot.statemachine.example.task.demo;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.statemachine.ExtendedState;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.annotation.WithStateMachine;

import java.util.HashMap;
import java.util.Map;

/**
 * Created on 2020/2/23.
 */
@WithStateMachine
public class Tasks {
    private final static Log log = LogFactory.getLog(Tasks.class);

    @Autowired
    private StateMachine<States, Events> stateMachine;

    private final Map<String, Boolean> tasks = new HashMap<String, Boolean>();

    public Tasks() {
        tasks.put("T1", true);
        tasks.put("T2", true);
        tasks.put("T3", true);
    }

    public void run() {
        stateMachine.sendEvent(Events.RUN);
    }

    public void fix() {
        tasks.put("T1", true);
        tasks.put("T2", true);
        tasks.put("T3", true);
        stateMachine.sendEvent(Events.FIX);
    }

    public void fail(String task) {
        if (tasks.containsKey(task)) {
            tasks.put(task, false);
        }
    }

    @StatesOnTransition(target = States.T1)
    public void taskT1(ExtendedState extendedState) {
        runTask("T1", extendedState);
    }

    @StatesOnTransition(target = States.T2)
    public void taskT2(ExtendedState extendedState) {
        runTask("T2", extendedState);
    }

    @StatesOnTransition(target = States.T3)
    public void taskT3(ExtendedState extendedState) {
        runTask("T3", extendedState);
    }

    //tag::snippetA[]
    @StatesOnTransition(target = States.AUTOMATIC)
    public void automaticFix(ExtendedState extendedState) {
        Map<Object, Object> variables = extendedState.getVariables();
        variables.put("T1", true);
        tasks.put("T1", true);
    }
//end::snippetA[]

    private void runTask(String task, ExtendedState extendedState) {
        log.info("run task on " + task);
        sleep(2000);
        extendedState.getVariables().put(task, tasks.get(task));
        log.info("run task on " + task + " done");
    }

    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
        }
    }

    @Override
    public String toString() {
        return "Tasks " + tasks;
    }
}

最后定义操tasks状态机用到的命令。

@ShellComponent
public class TasksCommands {


    @Autowired
    private Tasks tasks;

    @ShellMethod(key = "tasks run", value = "Run tasks")
    public void run() {
        tasks.run();
    }

    @ShellMethod(key = "tasks list", value = "List tasks")
    public String list() {
        return tasks.toString();
    }

    @ShellMethod(key = "tasks fix", value = "Fix tasks")
    public void fix() {
        tasks.fix();
    }

    @ShellMethod(key = "tasks fail", value = "Fail task")
    public void fail(@ShellOption(value = {"", "task"}, help = "Task id") String task) {
        tasks.fail(task);
    }
}

总结

通过tasks这个demo我们学到了如果通过fork,join实现产生多个状态的功能。此外通过choice实现选择性的状态转换。

参考

[1] tasks原始demo,https://github.com/spring-projects/spring-statemachine/tree/2.2.0.RELEASE/spring-statemachine-samples/tasks/src/main/java/demo/tasks
[2]tasks doc,https://docs.spring.io/spring-statemachine/docs/2.2.0.RELEASE/reference/#statemachine-examples-tasks

FserSuN
关注
专栏目录
深度学习论文: Learning to Resize Images for Computer Vision Tasks及其PyTorch实现
mingo_敏
01-10 2401
深度学习论文: Learning to Resize Images for Computer Vision Tasks及其PyTorch实现 Learning to Resize Images for Computer Vision Tasks PDF: https://arxiv.org/pdf/2103.09950.pdf PyTorch代码: https://github.com/shanglianlm0525/CvPytorch PyTorch代码: https://github.com/shang
实例学习Ansilbe：常用模块之替换replace/lineinfile
知行合一 止于至善
08-12 4441
Ansible常用的用于替换的模块为replace和lineinfile，进行替换的场景在自动化运维中是一个非常常见的场景，比如设定OS的selinux，再比如设定docker服务的service文件（当然这种情况更多是template模块的应用场景），在Ansible中甚至可以直接使用shell模块结合sed -i来事先替换的效果，但是考虑到可读性性和可维护性等多方面因素，使用Ansible的替换模块是一个不错的选择。
Spring Statemachine 概念及应用
weixin_42128568的博客
06-18 934
转自https://www.jianshu.com/p/9ee887e045dd，感谢 1 Finite-state machine 1.1 状态机定义 有限状态机，（英语：Finite-state machine, FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 有限状态机体现了两点：首先是离散的，然后是有限的。 State：状态这个词有些难以定义，状态存储关于过去的信息，就是说它反映从系统开始到现在时刻的输入变化。 Actions
SpringStateMachine状态机教程
weixin_45647349的博客
03-23 970
【代码】SpringStateMachine状态机教程。
SpringTask定时任务笔记
最新发布
qq_45607971的博客
08-25 885
介绍了SpringBoot项目结合SpringTask定时任务的基本使用
通过实例学习SpringStateMachine之Persist
Revivedsun的专栏
02-29 1578
背景介绍 本系列通过学习SpringStateMachine中附带的10余个Sample来学习SpringStateMachine中的各个概念和用法。项目是使用的分支为2.2.0.RELEASE。项目参考文档也是2.2.0.RELEASE。 Persist简介 Persist这个例子演示了通过状态机来更新数据库中记录的状态。例如一条订单记录，有两个状态，支付与未支付。建立对应的订单状态机，当状态机...
Spring定时任务（Spring Task）（推荐@Scheduled）
热门推荐
qq_42437597的博客
02-25 2万+
1. 定时器 项目开发中需要执行一些定时任务，比如在凌晨时候，更新一些新的信息，定时发送邮件等等 1.1. 实现方式 1.1.1. java.util.Timer Java自带的java.util.Timer类，可以调度一个java.util.TimerTask任务。这种方式可以让程序按照某一个频度执行，但不能在指定的时间运行，一般用的比较少。 1.1.2. Quartz 使用Quartz，这是一个功能比较强大的调度器，可以让程序在指定的时间执行，也可以按照某一个频度执行，配置起来稍显复杂。 1.1.3.
Spring Statemachine使用入门
通往神秘的道路的专栏
11-21 1586
1、编程式 下面以官网的示例稍加改造举例来体会一下Spring Statemachine使用。 添加下面maven坐标到pom中。 <dependencies> <dependency> <groupId>org.springframework.statemachine</groupId> <ar...
tasks-manager-backend:通过Spring练习Web开发的Tasks Manager宠物项目
04-04
《Spring实战：构建Tasks Manager后端应用》 在IT领域，Spring框架是Java Web开发中的一个强大工具，尤其在构建企业级应用时更是不可或缺。本篇文章将深入探讨如何利用Spring框架来开发一个名为"Tasks Manager"的...
Spring官网学习(一)概述
qq_36526036的博客
04-26 6016
文章目录1、Spring官网简介2、Spring总览2.1、什么是Spring2.2、Spring的发展历程3、Spring的设计理念4、Getting Started 1、Spring官网简介 进入Spring的官网介绍，可以看到，Spring官网将整个Spring框架分成如下8个部分： Overview：该模块主要介绍Spring的历史、设计理念、并且可以快速构建一个Spring的Demo等...
jpa-spring-crud-tasks:基于 https 的示例 jpa-sping 演示项目
06-22
jpa-spring-crud-tasks 使用 spring-data、spring-jpa、spring-boot、spring-rest 的示例项目 jpa-model 包含持久层： 基于来自UML 模型生成 spring-cli REST seb 服务，用于说明循环 JPA 图上的 JSON 序列化问题
Spring任务调度——SpringTask
武汉小喽啰
01-22 335
在spring中使用定时很简单，首先需要在配置文件中加上task的命名空间 xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/sc...
分布式调度器
z1231234321的博客
04-15 335
在服务类中定义一个方法，并使用。
Spring Statemachine的使用
一念流转
01-14 267
仅作为作者本人学习记录，读者需要一定的基础知识才能入手。
Spring Task：实现定时任务的高效解决方案
无远弗届
05-30 1045
1. Spring Task概述 1.1 定义Spring Task Spring Task是Spring Framework的一个扩展模块，它提供了一种声明式的方式来配置和执行定时任务。这一模块允许开发者通过简单的注解和配置来定义任务，而无需深入了解底层的调度机制。Spring Task的实现基于Java的java.util.concurrent包，提供了任务执行器（TaskExecutor）和调度器（Scheduler）的抽象，使得任务的调度和管理更加灵活和强大。 1.2 与Java原生定时任务的比较
SpringTask--介绍及其使用
maoheguxiang的博客
03-16 1014
是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑。Spring3.0以后自主开发的定时任务工具，可以看做是一个轻量级的Quartz框架。使用起来很简单，除spring相关的包外不需要额外的包**定位：**定时任务框架**作用：**定时自动执行某段Java代码。
初试SpringStateMachine框架实现状态机
woshiyexinjie的专栏
10-05 2020
官网：https://projects.spring.io/spring-statemachine/ 官网这里列出了很多特性，说的就是易于使用的状态机，帮助开发者简化状态机的开发过程，让状态机结构更加层次化。 状态机 有限状态机(FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。  状态存储关于过去的信息，就是说：它反映从系统开始到现在时刻的输入变化...
Spring Task 超详解版
qq_53317005的博客
11-06 5214
OK，果然如此，注意这个是任务结束后每隔五秒，如果方法中间加了一个sleep方法，那么执行时间还要加上sleep里面的值，比如说中间加了一个sleep(1000)，那么就会每隔6秒执行一次。比如说我们设置了两个定时任务，那么因为Spring Task是单线程，如果在第一个定时任务加了一个sleep方法，那么会等第一个方法响应后在执行第二个任务，就很浪费cpu运行时间。该域可以省略，表示每年都触发。执行效果如上，确实不会影响到任务2的运行，但是如果定时任务过多，超过了配置的线程池的线程数量还是会运行错乱。
spring-boot-starter-tasks的依赖
05-31
spring-boot-starter-tasks是一个Spring Boot的Starter，它提供了异步执行任务的能力。它的依赖包括core、context和task。具体来说，它依赖的库包括： - spring-boot-starter：Spring Boot核心库。 - spring-boot-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值