自定义状态机

小鱼儿 2022-06-14 11:53 175阅读 0赞

附源码：https://gitee.com/Gjson/SpringCloud.git

Spring StateMachine框架可能对于大部分使用Spring的开发者来说还比较生僻，该框架的主要功能是帮助开发者简化状态机的开发过程，让状态机结构更加层次化

介绍Spring StateMachine状态机实现、自定义初始状态及监听器。

@Configuration
    @EnableStateMachine
    public  class MyStateMachineBuilder   extends EnumStateMachineConfigurerAdapter<States, Events> implements Builder , InitializingBean{
        Logger logger = LoggerFactory.getLogger(this.getClass());
        @Autowired
        BeanFactory beanFactory;
        private States states;
        @Override
        public States getName() {
            logger.info("Builder getName");
            return states;
        }
        @Override
        public void  setName(States states){
            this.states=states;
        }
    
        @Override
        public void configure(StateMachineStateConfigurer<States, Events> states)
                throws Exception {
            states
                    .withStates()
                    .initial(States.UNPAID)
                    .states(EnumSet.allOf(States.class));
        }
        @Override
        public void configure(StateMachineTransitionConfigurer<States, Events> transitions)
                throws Exception {
            transitions
                    .withExternal()
                    .source(States.UNPAID).target(States.WAITING_FOR_RECEIVE)
                    .event(Events.PAY)
                    .and()
                    .withExternal()
                    .source(States.UNPAID).target(States.WAITING_FOR_PENDING)
                    .event(Events.DELAY_PAY)
                    .and()
                    .withExternal()
                    .source(States.WAITING_FOR_RECEIVE).target(States.DONE)
                    .event(Events.RECEIVE)
                    .and()
                    .withExternal()
                    .source(States.UNPAID).target(States.CANCEL_BUYER)
                    .event(Events.CANCEL)
                    .and()
                    .withExternal()
                    .source(States.WAITING_FOR_PENDING).target(States.CANCEL_SELLER)
                    .event(Events.CANCEL);
        }
        @Override
        public void configure(StateMachineConfigurationConfigurer<States, Events> config)
                throws Exception {
            config
                    .withConfiguration()
                    .listener(listener());
        }
    
        @Override
        public  StateMachine<States, Events> build(States states) throws Exception{
            logger.info("Builder build.");
            StateMachineBuilder.Builder<States, Events> builder = StateMachineBuilder.builder();
    
            builder.configureConfiguration()
                    .withConfiguration().machineId("myState").autoStartup(true).beanFactory(beanFactory);
    
            builder.configureStates().withStates().initial(states).states(EnumSet.allOf(States.class));
    
            builder.configureTransitions()
                    .withExternal()
                    .source(States.UNPAID).target(States.WAITING_FOR_RECEIVE)
                    .event(Events.PAY)
                    .and()
                    .withExternal()
                    .source(States.UNPAID).target(States.WAITING_FOR_PENDING)
                    .event(Events.DELAY_PAY)
                    .and()
                    .withExternal()
                    .source(States.WAITING_FOR_RECEIVE).target(States.DONE)
                    .event(Events.RECEIVE)
                    .and()
                    .withExternal()
                    .source(States.UNPAID).target(States.CANCEL_BUYER)
                    .event(Events.CANCEL)
                    .and()
                    .withExternal()
                    .source(States.WAITING_FOR_PENDING).target(States.CANCEL_SELLER)
                    .event(Events.CANCEL)
                    .and()
                    .withExternal()
                    .source(States.WAITING_FOR_PENDING).target(States.WAITING_FOR_RECEIVE)
                    .event(Events.PENDING)
                    .and()
                    .withExternal()
                    .source(States.WAITING_FOR_RECEIVE).target(States.DONE)
                    .event(Events.MONEY);
            StateMachine stateMachine = builder.build();
            stateMachine.addStateListener(listener());
            return stateMachine;
        }
        
        public StateMachineListener<States, Events> listener() {
            return new StateMachineListenerAdapter<States, Events>() {
                @Override
                public void transition(Transition<States, Events> transition) {
                    if (transition.getTarget().getId() == States.UNPAID) {
                        logger.info("订单创建，待支付");
                        return;
                    }
                    if (transition.getSource().getId() == States.UNPAID && transition.getTarget().getId() == States.WAITING_FOR_RECEIVE) {
                        logger.info("用户完成支付，待收货");
                        return;
                    }
                    if (transition.getSource().getId() == States.WAITING_FOR_RECEIVE && transition.getTarget().getId() == States.DONE) {
                        logger.info("用户已收货，订单完成");
                        return;
                    }
                    if(transition.getSource().getId() == States.UNPAID && transition.getTarget().getId() == States.CANCEL_BUYER){
                        logger.info("买家取消");
                        return;
                    }
                    if(transition.getSource().getId() == States.WAITING_FOR_PENDING && transition.getTarget().getId() == States.CANCEL_SELLER){
                        logger.info("卖家取消");
                        return;
                    }
    
                    if(transition.getSource().getId() == States.UNPAID && transition.getTarget().getId() == States.WAITING_FOR_PENDING){
                        logger.info("货到付款");
                        return;
                    }
                }
            };
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
    
        }
    }

public void run(String... args) throws Exception {
    
    
            stateMachine=myStateMachineBuilder.build(States.UNPAID);
            stateMachine.sendEvent(Events.CANCEL);
    
            stateMachine=myStateMachineBuilder.build(States.WAITING_FOR_RECEIVE);
            stateMachine.sendEvent(Events.RECEIVE);
    
    
        }

2017-06-19 16:00:46.635  INFO 10200 --- \[           main\] Builder$$EnhancerBySpringCGLIB$$908ecf40 : Builder build.  
2017-06-19 16:00:46.652  INFO 10200 --- \[           main\] o.s.s.support.LifecycleObjectSupport     : started org.springframework.statemachine.support.DefaultStateMachineExecutor@750ed637  
2017-06-19 16:00:46.652  INFO 10200 --- \[           main\] o.s.s.support.LifecycleObjectSupport     : started DONE INITED UNPAID CANCEL\_SELLER WAITING\_FOR\_PENDING CANCEL\_BUYER WAITING\_FOR\_RECEIVE  / UNPAID / uuid=4c2212ee-be6f-43e7-8622-227ba622cf44 / id=myState  
2017-06-19 16:00:47.890  INFO 10200 --- \[           main\] Builder$$EnhancerBySpringCGLIB$$908ecf40 : 买家取消  
2017-06-19 16:00:47.892  INFO 10200 --- \[           main\] Builder$$EnhancerBySpringCGLIB$$908ecf40 : Builder build.  
2017-06-19 16:00:47.893  INFO 10200 --- \[           main\] o.s.s.support.LifecycleObjectSupport     : started org.springframework.statemachine.support.DefaultStateMachineExecutor@469a7575  
2017-06-19 16:00:47.893  INFO 10200 --- \[           main\] o.s.s.support.LifecycleObjectSupport     : started DONE INITED UNPAID CANCEL\_SELLER WAITING\_FOR\_PENDING CANCEL\_BUYER WAITING\_FOR\_RECEIVE  / WAITING\_FOR\_RECEIVE / uuid=4f473ede-a0fa-4ca7-b1a9-6e4abd61253f / id=myState  
2017-06-19 16:00:48.423  INFO 10200 --- \[           main\] Builder$$EnhancerBySpringCGLIB$$908ecf40 : 用户已收货，订单完成  
2017-06-19 16:00:48.425  INFO 10200 --- \[           main\] com.gson.Application                     : Started Application in 8.847 seconds (JVM running for 9.29)