Spring statemachine-实际项目应用

最新推荐文章于 2024-10-05 13:18:43 发布
最新推荐文章于 2024-10-05 13:18:43 发布
阅读量8.1k 收藏 16
点赞数 5
分类专栏： spring-intergration spring 文章标签： spring statemachine 状态机 状态机应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guo_xl/article/details/83716342
版权
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

xiao_long_guo
关注
专栏目录
Spring-Statemachine 状态机
bingpo0的博客
08-11 822
此博客有详细的搭建过程，我这里写一下在搭建过程中的理解和使用 https://www.cnblogs.com/cnblog-long/p/7245522.html 再复述一下搭建过程: 搭建一个spring-boot 的框架 Spring-Statemachine 依赖 版本号要特别注意 2.0.1.RELEASE <!-- 状态机--> <dependency> <groupId>org.springframework
Spring StateMachine学习(一) ——快速开始
hxyascx的博客
04-14 1806
有限状态机（Finite-state machine） 有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。应用FSM模型可以帮助对象生命周期的状态的顺序以及导致状态变化的事件进行管理。将状态和事件控制从不同的业务Service方法的if else中抽离出来。FSM的应用范围很广，对于有复杂状态流，...
深入理解Spring Statemachine：在Spring中实现状态机
最新发布
weixin_36047538的博客
10-05 1675
本文还有配套的精品资源，点击获取 简介：Spring Statemachine框架通过提供状态机抽象，简化了在Spring环境中实现和管理复杂工作流程及业务逻辑的过程。本文深入探讨了Spring Statemachine的核心概念、功能及应用，包括状态和转换的结构化定义、事件驱动的状态变迁、持久化支持以及集成Spring生态系统。通过实例分析，展示了其在多个领域的实际应用，...
spring statemachine状态机在项目中的实践
zengqingfa123的博客
10-15 2174
我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。给定一个状态机，同时给定它的当前状态以及输入，那么输出状态时可以明确的运算出来的。这个想法是你的应用程序可能存在于有限数量的状态中，某些预定义的触发器可以将你的应用程序从一个状态转移到另一个状态。有限状态机（Finite-state machine,FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。获取的结果无法感知到。
Spring Statement 状态机应用实例
若明天不见
11-20 939
本文主要介绍Spring Statement状态机应用实例。在业务系统中，通过应用的方式，将所有的状态、事件、动作都抽离出来，对复杂的状态迁移逻辑进行统一管理，来取代冗长的 if else 判断，能使系统中的复杂问题得以解耦，变得直观、方便操作，使系统更加易于维护和管理。有限状态机的定义及重要概念见https://blog.csdn.net/why_still_confused/article/details/127703487。
线上系统引入Spring状态机实践
猫舍
10-13 1197
什么是状态机 在某个起始状态下，当满足某个条件时，将状态转换到另一个状态的机制。状态机就是实现这一机制的控制元件。状态机的概念也经常出现在电气元件中。 而在软件开发中，状态机指的是一种在某个状态下，由某个事件触发，并将状态转移到目标状态的一个模块。 为什么要使用状态机 状态机解决的痛点在于，当某个业务流程很长，且很复杂时，对于状态的流转的维护成本将膨胀到不可接受的程度。而将状态的流转从业务代码中剥离出来，让开发过程中更加专注于业务处理，就成为了项目急需解决的问题。 状态机的引入，让程序开发不再需要关注复杂繁
Spring系列学习之Spring Statemachine状态机
纸上得来终觉浅，绝知此事要躬行
12-22 7014
英文原文：https://projects.spring.io/spring-statemachine/ 目录 快速开始 Builder JavaConfig 版本 资源 Spring Statemachine是应用程序开发人员在Spring应用程序中使用状态机概念的框架。 Spring Statemachine旨在提供以下功能： 易于使用的扁平单级状态机，用于简单的使用...
spring-statemachine：Spring Statemachine是一个框架，供应用程序开发人员在Spring中使用状态机概念
02-03
spring-statemachine：Spring Statemachine是一个框架，供应用程序开发人员在Spring中使用状态机概念
spring-statemachine-2.02.release源码
08-30
Spring StateMachine 是 Spring 生态系统中的一个重要组件，它为开发者提供了一种强大的状态管理框架，用于构建复杂的有状态应用。通过深入研究其源码，我们可以更好地理解和掌握状态机的设计理念和实现方式，从而...
Spring Statemachine使用入门
通往神秘的道路的专栏
11-21 1621
1、编程式 下面以官网的示例稍加改造举例来体会一下Spring Statemachine使用。 添加下面maven坐标到pom中。 <dependencies> <dependency> <groupId>org.springframework.statemachine</groupId> <ar...
Spring StateMachine
05-07 2973
一、状态机 有限状态机是一种用来进行对象行为建模的工具，其作用主要是描述对象在它的生命周期内所经历的状态序列，以及如何响应来自外界的各种事件。在电商场景（订单、物流、售后）、社交（IM消息投递）、分布式集群管理（分布式计算平台任务编排）等场景都有大规模的使用。 状态机的要素： 状态机可归纳为4个要素，现态、条件、动作、次态。“现态”和“条件”是因，“动作”和“次态”是果。 1 现态：指...
Spring Statemachine
qq_38589743的博客
07-06 587
Spring StateMachine个人小结 一、有关概念梳理 官方流程图： 二、简单demo实验 参考自：https://github.com/sunbufu/spring-state-machine-demo 依赖： <dependency> <groupId>org.springframework.statemachine</groupId> <artifactId>spring-s
spring state machine
www.yiye.tech
07-10 406
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 2256
spring statemachine框架的作用在于提供一个项目业务切入的视角，关注点不在于具体的业务数据，而是状态流程。
spring statemachine的企业可用级开发指南8-复杂状态机的实现，choice，guard和action...
weixin_34289744的博客
05-13 896
2019独角兽企业重金招聘Python工程师标准>>> ...
基于Spring-statemachine的有限状态机(FSM)的介绍及示例
热门推荐
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
11-26 5万+
前言本文主要介绍一下状态机以及相关的一些概念。结合一个简单的订单状态流程，示例怎样在Springboot中集成Spring-statemachine。有限状态机（Finite-state machine）有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。示例中以一个常见的“订单”的状态转移为例。
Spring Statemachine 项目，旨在提供一个通用的基础设施，在 Spring 应用程序中使用状态机概念
03-06
Spring Statemachine 项目旨在提供一个通用的基础设施，以便在 Spring 应用程序中使用状态机概念。示例可以在 spring-statemachine-samples 下找到。查看参考文档，详细了解它们的作用。
Spring Statemachine 2.2.0
BLOG域名:programb.blog.csdn.net
03-26 164
Spring Statemachine is a framework for application developers to use state machine concepts with Spring applications. Spring Statemachine aims to provide following features: Easy to use flat one level...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值