Spring statemachine-实际项目应用

最新推荐文章于 2025-07-02 12:26:21 发布
原创 最新推荐文章于 2025-07-02 12:26:21 发布 · 8.2k 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring statemachine #状态机 #状态机应用

本文介绍如何使用Spring StateMachine实现一个复杂的权限审批流程，包括创建、审批、管理员审核等多个步骤，通过代码示例详细解释了状态机配置、事件处理及数据库持久化策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1. 公司里一个项目真实的应用，需求如下：

image

创建的一个user或group，需要不同人员去approve，user 或group状态就会发生变化。这个很适合使用spring-statemachine来做。以建立group来说明如下

  1. 建立一个group，状态是pending Approved

  2. approve这个group，状态变成partial Approved

  3. approve这个group，如果建立的group级别是高级，状态变成Pending Admin Approve，需要公司人员(Admin级别)去approve. 如果group级别不是高级，状态直接变成Approved

  4. 公司人员(Admin级别) approve这个group,状态变成Pending Admin Approve Confirm

  5. 公司人员(Admin级别) approve这个group,状态变成Approved

  6. 第4步，如果公司人员(Admin级别) reject这个group,状态变成Pending Admin Reject Confirm

  7. 公司人员(Admin级别) approve这个group,状态变成Rejected

  8. 第7步，如果公司人员(Admin级别) reject这个group,状态变成Pending Admin Approve,重新走流程

以下为代码参考了官方sample-persist并做了更改

2.sql
CREATE TABLE `pagroup` (
  `groupId` int(11) DEFAULT NULL,
  `groupName` varchar(256) DEFAULT NULL,
  `status` int(11) DEFAULT NULL,
  `isAdvance` tinyint(1) NOT NULL DEFAULT 0
) ENGINE=InnoDB DEFAULT CHARSET=utf8

对应的Pojo

public class Group {
    private int groupId;
    private String groupName;
    private int state;
    private boolean isAdvance;
   //getter and setter...
}
3.statemahine config

spring statemachine的Configuration，java代码如下，实际上就是用java代码描述1的那个图。刚开始写有点懵，实际写下就很简单了，就是source到target的状态变化需要用什么event(事件)去trigger。需要说明的是withChoice()，这个就是说当状态从pending approved改到choice时，statemahine引擎需要知道如何去选下个状态是Approved还是pending Admin approve，这里逻辑如果group 是isadvance就是pending Admin approve否则就是approved

 
@Configuration
@EnableStateMachine
public class StateMachineConfig extends StateMachineConfigurerAdapter<Status,ActionType>{


    @Override
    public void configure(StateMachineStateConfigurer<Status,ActionType> states) throws Exception {
        states.withStates()
                .initial(Status.PENDING_APPROVAL)
                .choice(Status.CHOICE)
                .states(EnumSet.allOf(Status.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<Status,ActionType> transitions) throws Exception {
        transitions
                .withExternal()
                .source(Status.PENDING_APPROVAL).target(Status.PARTIALLY_APPROVED).event(ActionType.APPROVE)
                .and()
                .withExternal()
                .source(Status.PARTIALLY_APPROVED).target(Status.CHOICE).event(ActionType.APPROVE)
                .and()
                .withChoice()
                .source(Status.CHOICE)
                .first(Status.PENGDING_DOCUMENT_CHECK,(context)->{
                    Group group = context.getMessage().getHeaders().get("group",Group.class);
                    return group.isAdvance();
                })
                .last(Status.APPROVED)
                .and()
                .withExternal()
                .source(Status.PENGDING_DOCUMENT_CHECK).target(Status.PENDING_APPROVAL_CONFIRMATION).event(ActionType.APPROVE)
                .and()
                .withExternal()
                .source(Status.PENDING_APPROVAL_CONFIRMATION).target(Status.APPROVED).event(ActionType.APPROVE)
                .and()
                .withExternal()
                .source(Status.PENDING_APPROVAL_CONFIRMATION).target(Status.PENGDING_DOCUMENT_CHECK).event(ActionType.REJECT)
                .and()
                .withExternal()
                .source(Status.PENGDING_DOCUMENT_CHECK).target(Status.PENDING_REJECT_CONFIRMATION).event(ActionType.REJECT)
                .and()
                .withExternal()
                .source(Status.PENDING_REJECT_CONFIRMATION).target(Status.PENGDING_DOCUMENT_CHECK).event(ActionType.REJECT)
                .and()
                .withExternal()
                .source(Status.PENDING_REJECT_CONFIRMATION).target(Status.REJECTED).event(ActionType.APPROVE)
                .and()
                .withExternal()
                .source(Status.PENDING_APPROVAL).target(Status.REJECTED).event(ActionType.REJECT)
                .and()
                .withExternal()
                .source(Status.PARTIALLY_APPROVED).target(Status.REJECTED).event(ActionType.REJECT);
    }

}
4.事件(ActionType)和状态(Status)定义
public enum ActionType {
 APPROVE(1), REJECT(2);
}

public enum Status {
    PENDING_APPROVAL("status.pending_approval", 1),
    PARTIALLY_APPROVED("status.partially_approval", 2),
    APPROVED("status.approved", 3),
    REJECTED("status.rejected", 4),
    PENGDING_DOCUMENT_CHECK("status.pending_document_check", 5),
    PENDING_APPROVAL_CONFIRMATION("status.pending_approval_confirmation", 10),
    PENDING_REJECT_CONFIRMATION("status.pending_reject_confirmation", 11),
    CHOICE("spring.state.machine.choice",501);
    private String msgKey;
    private int statusCode;
    Status(String desc, int statusCode) {
        this.msgKey = desc;
        this.statusCode = statusCode;
    }
    public static Status valueOf(int statusCode) {
       Iterator<Status> iterator = EnumSet.allOf(Status.class).iterator();
       while (iterator.hasNext()){
           Status st =iterator.next();
           if(st.statusCode==statusCode)
               return st;
       }
        throw new IllegalArgumentException("invalid status code");
    }
    public String getMsgKey() {
        return msgKey;
    }
    public int getStatusCode() {
        return statusCode;
    }
}

PersistStateMachineHandler

该代码就是往statemachine里添加一个拦截器PersistingStateChangeInterceptor，
拦截到所有的preStateChange事件，就通知CompositePersistStateChangeListener里面注册的listener去处理


@Component
public class PersistStateMachineHandler extends LifecycleObjectSupport {

    private final StateMachine<Status,ActionType> stateMachine;
    private final PersistingStateChangeInterceptor interceptor = new PersistingStateChangeInterceptor();
    private final CompositePersistStateChangeListener listeners = new CompositePersistStateChangeListener();
    /**
     * Instantiates a new persist state machine handler.
     *
     * @param stateMachine the state machine
     */
    @Autowired
    public PersistStateMachineHandler(StateMachine<Status,ActionType> stateMachine) {
        Assert.notNull(stateMachine, "State machine must be set");
        this.stateMachine = stateMachine;
    }

    //会被LifecycleObjectSupport父类的InitializingBean.afterPropertiesSet()里调用
    protected void onInit() throws Exception {
    
       //往stateMachine加入拦截器PersistingStateChangeInterceptor
        stateMachine.getStateMachineAccessor().doWithAllRegions(new StateMachineFunction<StateMachineAccess<Status,ActionType>>() {
            public void apply(StateMachineAccess<Status,ActionType> function) {
                function.addStateMachineInterceptor(interceptor);
            }
        });

        //获取所有 PersistStateChangeListener的bean注册到CompositePersistStateChangeListener
        Map<String, PersistStateChangeListener> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors((ListableBeanFactory) this.getBeanFactory(), PersistStateChangeListener.class, true, false);
        if (!matchingBeans.isEmpty()) {
            listeners.setListeners(new ArrayList(matchingBeans.values()));
        }
    }

    /**
     * Handle event with entity.
     *
     * @param event the event
     * @param state the state
     * @return true if event was accepted
     */
    public boolean handleEventWithState(Message<ActionType> event, Status state) {
        stateMachine.stop();
        List<StateMachineAccess<Status,ActionType>> withAllRegions = stateMachine.getStateMachineAccessor().withAllRegions();
        for (StateMachineAccess<Status,ActionType> a : withAllRegions) {
            a.resetStateMachine(new DefaultStateMachineContext<Status,ActionType>(state, null, null, null));
        }
        stateMachine.start();
        return stateMachine.sendEvent(event);
    }

    /**
     * Adds the persist state change listener.
     *
     * @param listener the listener
     */
    public void addPersistStateChangeListener(PersistStateChangeListener listener) {
        listeners.register(listener);
    }

    /**
     * The listener interface for receiving persistStateChange events.
     * The class that is interested in processing a persistStateChange
     * event implements this interface, and the object created
     * with that class is registered with a component using the
     * component's <code>addPersistStateChangeListener</code> method. When
     * the persistStateChange event occurs, that object's appropriate
     * method is invoked.
     */
    public interface PersistStateChangeListener {
        /**
         * Called when state needs to be persisted.
         *
         * @param state        the state
         * @param message      the message
         * @param transition   the transition
         * @param stateMachine the state machine
         */
        void onPersist(State<Status,ActionType> state, Message<ActionType> message, Transition<Status,ActionType> transition,
                       StateMachine<Status,ActionType> stateMachine);
    }

    private class PersistingStateChangeInterceptor extends StateMachineInterceptorAdapter<Status,ActionType> {
        @Override
        public void preStateChange(State<Status, ActionType> state, Message<ActionType> message, Transition<Status, ActionType> transition, StateMachine<Status, ActionType> stateMachine) {
            listeners.onPersist(state,message,transition,stateMachine);
        }
    }

    private class CompositePersistStateChangeListener extends AbstractCompositeListener<PersistStateChangeListener> implements
            PersistStateChangeListener {
        public void onPersist(State<Status,ActionType> state, Message<ActionType> message,
                              Transition<Status,ActionType> transition, StateMachine<Status,ActionType> stateMachine) {
            for (Iterator<PersistStateChangeListener> iterator = getListeners().reverse(); iterator.hasNext(); ) {
                PersistStateChangeListener listener = iterator.next();
                listener.onPersist(state, message, transition, stateMachine);
            }
        }
    }
}

GroupController


@RestController
public class GroupController {

    @Autowired
    GroupService groupService;

    @RequestMapping("/group/list")
    public List<Group> list(){
        return groupService.listAll();
    }

    @PostMapping("/group/create")
    public boolean  create(@RequestBody Group group){
        groupService.create(group);
        return true;
    }

   //web入口，处理某个group{id}的某个事件，例如group/2/APPROVE就是对group id 为2  做approve
    @RequestMapping("/group/{id}/{event}")
    public boolean handle(@PathVariable("id")Integer id,@PathVariable("event") String event){
        return groupService.handleAction(id,event);
    }

}

GroupService

@org.springframework.stereotype.Service
public class GroupService {

    @Autowired
    private PersistStateMachineHandler handler;
    @Autowired
    private GroupRepository repository;

    public boolean handleAction(int groupId, String event) {
        Group group = repository.findGroupById(groupId);
        //发送事件去触发状态机
        return handler.handleEventWithState(MessageBuilder.withPayload(ActionType.valueOf(event))
                .setHeader("group", group).build(), Status.valueOf(group.getState()));
    }

    public void create(Group group) {
        repository.create(group);
    }
    public List listAll() {
        return repository.listAll();
    }
}

GroupRepoository 相当于Dao

@Repository
public class GroupRepository {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void create(Group group){
        jdbcTemplate.update("insert into pagroup(groupId,groupName,status) values (?,?,?)",
                group.getGroupId(),
                group.getGroupName(),
                Status.PENDING_APPROVAL.getStatusCode());
    }

    public List listAll() {
        List list  = jdbcTemplate.query("select groupId,groupName,status,isAdvance from pagroup",rowMapper());
        return list;
    }

    public Group findGroupById(int groupId) {
        Group group = jdbcTemplate.queryForObject("select groupId, groupName,status,isAdvance from pagroup where groupId = ?", new Object[]{groupId},rowMapper());
        return group;
    }
    private RowMapper<Group> rowMapper(){
        return  new RowMapper<Group>() {
            public Group mapRow(ResultSet rs, int rowNum) throws SQLException {
                Group group = new Group(rs.getInt("groupId"), rs.getString("groupName"));
                group.setState(rs.getInt("status"));
                group.setAdvance(rs.getBoolean("isAdvance"));
                return group;
            }
        };
    }
}

GroupPersistStateChangeListener 监听到状态机状态更改，就更新数据库里的对应字段

@Component
public class GroupPersistStateChangeListener  implements PersistStateMachineHandler.PersistStateChangeListener {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public GroupPersistStateChangeListener(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void onPersist(State<Status, ActionType> state, Message<ActionType> message, Transition<Status, ActionType> transition, StateMachine<Status, ActionType> stateMachine) {
        if (message != null && message.getHeaders().containsKey("group")) {
            Group group = message.getHeaders().get("group", Group.class);
            jdbcTemplate.update("update pagroup set status = ? where groupId = ?", state.getId().getStatusCode(), group.getGroupId());
        }
    }
}

启动Spring工程

@SpringBootApplication
public class BootStrap {

    public static void main(String[] args) {
        SpringApplicationBuilder builder = new SpringApplicationBuilder(BootStrap.class);
        builder.run(args);
    }
}

代码在github

企业级订单系统开发指南：Spring Statemachine核心应用与最佳实践(入门篇)
肖哥弹架构博客
07-09 871
详细解析订单从创建、支付到发货的完整状态流转机制，通过清晰的时序图和状态转换图展示核心业务流程。 全流程架构设计：从订单创建、支付到发货的完整状态流转机制，配有多张流程图解 深度技术整合：Spring Statemachine与Spring Boot、JPA的无缝集成方案 企业级数据库设计：包含5张核心业务表和2张状态机持久化表的详细定义，附SQL脚本
Spring Statemachine 高级功能详解：任务调度+性能监控+分布式集成+安全控制(应用场景实战)
最新发布
肖哥弹架构博客
07-18 820
Spring Statemachine 作为复杂业务流程管理的核心组件，其高级功能能够显著提升系统的健壮性和可维护性。本文系统性地解析了四大高级应用： 任务调度：通过定时任务实现超时处理、延迟事件触发、周期性状态检查等业务逻辑，提供通用代码示例与典型应用场景。 性能监控：针对高并发、复杂流程和分布式系统，介绍指标采集、链路追踪及动态采样等监控技巧，确保状态机高效运行。 分布式集成：解析跨服务状态协同、高可用与水平扩展的配置方案，结合 Redis 和分布式锁实现状态一致性。 安全控制：基于 Spring S
spring statemachine状态机在项目中的实践
zengqingfa123的博客
10-15 2432
我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。给定一个状态机，同时给定它的当前状态以及输入，那么输出状态时可以明确的运算出来的。这个想法是你的应用程序可能存在于有限数量的状态中，某些预定义的触发器可以将你的应用程序从一个状态转移到另一个状态。有限状态机（Finite-state machine,FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。获取的结果无法感知到。
Spring Statemachine 详解
csdn_tom_168的博客
07-02 970
Spring Statemachine 是一个用于管理复杂业务流程的状态机框架，核心概念包括状态、事件、转换、守卫和动作。它支持多种状态类型（初始/结束/并行/历史状态等）和高级特性（条件转换、业务逻辑执行、层次状态、并行处理）。通过简单配置即可实现状态机功能，并提供监听器机制和持久化支持，特别适合订单系统、工作流等场景。开发时只需定义状态/事件枚举，配置状态转换规则，即可构建完整的状态管理系统。
Spring Statement 状态机应用实例
若明天不见
11-20 1064
本文主要介绍Spring Statement状态机应用实例。在业务系统中，通过应用的方式，将所有的状态、事件、动作都抽离出来，对复杂的状态迁移逻辑进行统一管理，来取代冗长的 if else 判断，能使系统中的复杂问题得以解耦，变得直观、方便操作，使系统更加易于维护和管理。有限状态机的定义及重要概念见https://blog.youkuaiyun.com/why_still_confused/article/details/127703487。
线上系统引入Spring状态机实践
猫舍
10-13 1291
什么是状态机 在某个起始状态下，当满足某个条件时，将状态转换到另一个状态的机制。状态机就是实现这一机制的控制元件。状态机的概念也经常出现在电气元件中。 而在软件开发中，状态机指的是一种在某个状态下，由某个事件触发，并将状态转移到目标状态的一个模块。 为什么要使用状态机 状态机解决的痛点在于，当某个业务流程很长，且很复杂时，对于状态的流转的维护成本将膨胀到不可接受的程度。而将状态的流转从业务代码中剥离出来，让开发过程中更加专注于业务处理，就成为了项目急需解决的问题。 状态机的引入，让程序开发不再需要关注复杂繁
聊一聊 Spring StateMachine 的基本概念和实践
2301_78976656的博客
08-25 1323
状态机中基本的元素是状态和事件，整个业务逻辑的组织变更流转基本是围绕状态和事件展开。States 状态枚举类java代码解读复制代码。
spring-statemachine：Spring Statemachine是一个框架，供应用程序开发人员在Spring中使用状态机概念
02-03
让我们深入探讨一下Spring Statemachine的核心概念、功能以及如何在实际项目中应用。 1. **状态机概念**： 状态机是一种数学模型，用于描述对象或系统在不同时间点的行为变化。它由一系列状态（如启动、运行、停止...
spring-statemachine-2.02.release源码
08-30
Spring StateMachine 是 Spring 生态系统中的一个重要组件，它为开发者提供了一种强大的状态管理框架，用于构建复杂的有状态应用。通过深入研究其源码，我们可以更好地理解和掌握状态机的设计理念和实现方式，从而...
Spring StateMachine学习(一) ——快速开始
hxyascx的博客
04-14 1888
有限状态机（Finite-state machine） 有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。应用FSM模型可以帮助对象生命周期的状态的顺序以及导致状态变化的事件进行管理。将状态和事件控制从不同的业务Service方法的if else中抽离出来。FSM的应用范围很广，对于有复杂状态流，...
Spring State Machine 的介绍与使用详解
fudaihb的博客
09-16 330
状态机是一种行为模型，广泛应用于许多领域，如工作流、任务管理、订单处理等。其核心思想是系统可以处于不同的状态，并通过特定的事件或条件进行状态的转换。在Java开发中，Spring State Machine 提供了一个灵活、功能强大的状态机框架，帮助开发者轻松实现复杂的状态流转逻辑。本文将介绍Spring状态机的基本概念、使用场景、以及详细的使用方式。
Spring系列学习之Spring Statemachine状态机
纸上得来终觉浅，绝知此事要躬行
12-22 7284
英文原文：https://projects.spring.io/spring-statemachine/ 目录 快速开始 Builder JavaConfig 版本 资源 Spring Statemachine是应用程序开发人员在Spring应用程序中使用状态机概念的框架。 Spring Statemachine旨在提供以下功能： 易于使用的扁平单级状态机，用于简单的使用...
spring statemachine的企业可用级开发指南8-复杂状态机的实现，choice，guard和action...
weixin_34289744的博客
05-13 943
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring Statemachine
qq_38589743的博客
07-06 649
Spring StateMachine个人小结 一、有关概念梳理 官方流程图： 二、简单demo实验 参考自：https://github.com/sunbufu/spring-state-machine-demo 依赖： <dependency> <groupId>org.springframework.statemachine</groupId> <artifactId>spring-s
终于用上了 Spring 状态机，太优雅了！
lingqu＋wx bjmsb06
12-19 1083
状态模式在生活场景中也是比较常见的。比如我们平时网购的订单状态变化，还有平时坐电梯，电梯状态的变化。在软件开发过程中，对于某一项的操作，可能存在不同的情况。通常处理多情况问题最直接的办法就是使用if...else或者switch...case条件语句进行判断。这种做法对于复杂状态的判断天然存在弊端：判断条件语句过于臃肿，可读性较差，不具备扩展性，维度难度也很大。
spring state machine
www.yiye.tech
07-10 440
java code geeks推荐的文章 Spring State Machine: what is it and do you need it? spring官方文档 Spring Statemachine - Reference Documentation 这是一篇博主的文章：举了一个订单的例子 这是一篇博主的文章：基于Spring-statemachine的有限状态机(FSM)的介...
Spring状态机
cxl0_0的博客
01-19 2526
spring statemachine框架的作用在于提供一个项目业务切入的视角，关注点不在于具体的业务数据，而是状态流程。
Spring-Statemachine 状态机
bingpo0的博客
08-11 1021
此博客有详细的搭建过程，我这里写一下在搭建过程中的理解和使用 https://www.cnblogs.com/cnblog-long/p/7245522.html 再复述一下搭建过程: 搭建一个spring-boot 的框架 Spring-Statemachine 依赖 版本号要特别注意 2.0.1.RELEASE <!-- 状态机--> <dependency> <groupId>org.springframework
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值