易拓展、易修改的状态流程设计和实现

1，前言

     Workflow(https://en.wikipedia.org/wiki/Workflow)是一个极其常见的业务场景，基本所有行业都能涉及到流程管理上的问题。工作流，个人认为可以等价的理解为状态流(state flow)，因为工作流的主要工作就是流程管理或者就是状态转移。如果用状态转移来抽象描述问题的话，基本大多数业务系统都可以状态转移来描述，且不说OA、ERP等软件，在常见交易系统软件里产品管理的流程、在线交易系统里订单的各个状态流程等。

     使用状态转移来描述问题的优势是语义简洁、易于图像化描述(计算机专业所熟知的计算理论中的状态机)。日前已有像Spring webflow、jBPM等开源workflow实现，但本文对这些不相关，本文主要是围绕使用Spring Statemachine(http://projects.spring.io/spring-statemachine/)，以一个具体应用实例来设计和实现一个简单基本但易拓展、易修改的状态流程。

 

2，问题描述

     在一些网络上的金融产品平台上，我们可以看到各种类型的定期理财产品。这些理财产品实际都是金融公司依据国家的一些监管要求，打包成的一系列金融资产。所以这些资产在平台上正式对外公开募集资金前，实际是需要是需要经过一系列评审流程的。例如假设有一笔资产A，对这笔资产首先需要发起一场沟通会议，然后风控经理做好第一道最重要的风控问题、再是产品经理审批，最后进行评审、表决是否通过、拒绝或待议。

     既然是状态转移问题，忽略异常状态和中间状态终止或转移流程，我们通过语义来描述上述问题的正常流程：

1) 状态定义: Meeting("项目沟通会"), RiskManager("风控经理"), ProdManager("产品经理"), Review(“评审"), Pass("通过"), Reject("否决"), Discussing("待议")；

2) 状态转移事件:

　　　　{from=Initial, to=Meeting, on=LAUNCH_MEETING("发起项目沟通会")},

　　　　{from=Meeting, to=RiskManager, on=PASS_MEETING("通过项目沟通会")},

              {from=RiskManager, to=ProdManager, on=PASS_RISK_MANAGER("风控经理审核通过")},

              {from=ProdManager, to=Review, on=PASS_PROD_MANAGER("产品经理审核通过")},

              {from=Review, to=Termination, on=REVIEW_PASS("通过")},

              {from=Review, to=Termination, on=REVIEW_REJECT("否决")},

              {from=Review, to=Terminaton, on=REVIEW_DISCUSSING("待议")};

图1

     问题如果使用状态机描述的话，则如图1所示。

 

3，领域建模

图2 领域抽象

     从图2中可以看出，资产评审的领域核心Entity即是Review。State和Feature是刻画Review状态转移的基本组件，如第2部分语义所描述的。状态转移的发生都是通过FeatureEvent来触发，从FeatureEvent我们可以看到每一个Feature都是对应一个单例的触发Event，每一个FeatureEvent都标明了它将使Review从具体一个状态跳转到另一个状态。Review的构成除了基本user和asset数据外，featureCode和state记录了该Review的状态转移语义。state表明该Review当前所处的状态，featureCode标识了对应的触发状态转移的FeatureEvent。特别的，所有的流程都应当有一个初始的状态，这就是Review#initial()需要完成的工作。

 

4，编码实现

4.1， 领域核心实现

Review.java

import org.springframework.beans.factory.support.StaticListableBeanFactory;
import org.springframework.core.task.SyncTaskExecutor;
import org.springframework.messaging.Message;
import org.springframework.statemachine.StateMachine;
import org.springframework.statemachine.config.StateMachineBuilder;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
import org.springframework.statemachine.listener.StateMachineListenerAdapter;
import org.springframework.statemachine.transition.Transition;
import org.springframework.util.Assert;
 
import java.util.*;
 
/**
* @author shenjixiaodao
*/
public class Review {
    private Long reviewId;
    private Users user;
    private String featureCode;
    private Assets asset;
    private State state;
 
    public enum State{
         Meeting("项目沟通会"), RiskManager("风控经理审批"),
         ProdManager("产品经理审批"), Review("评审"),
         Pass("评审通过"), Reject("否决"), Discussing("待议");
         private String desc;
        State(String desc) {
            this.desc = desc;
        }
        public String getDesc(){return this.desc;}
    }
 
    private StateMachine<State, FeatureEvent> machine = null;
/**
* 触发状态转移动作
* @return true:允许状态转移
*/
    public boolean fire(){
        return this.fireEvent(FeatureEvent.codeOf(featureCode));
    }
    private boolean fireEvent(FeatureEvent event){
        try {
            if(machine == null) {
                machine = buildSyncMachine();
                machine.addStateListener(new StateMachineListenerAdapter<State, FeatureEvent>() {
                    @Override
                    public void eventNotAccepted(Message<FeatureEvent> msg) {
                        FeatureEvent event = msg.getPayload();
                        StringBuilder appender = new StringBuilder();
                        appender.append("【").append(event.featureName()).append("】只能将资产从")
                                .append(event.reviewState()).append("修改为").append(event.nextState());
                        throw new IllegalArgumentException(appender.toString());
                    }
 
                    @Override
                    public void transitionEnded(Transition<State, FeatureEvent> transition) {
                        FeatureEvent event = transition.getTrigger().getEvent();
                        state = event.nextState();
                    }
                });
            }
            return machine.sendEvent(event);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
 
    public Review(Integer userId, Integer assetId, String featureCode) {
        this.user = new Users();
        this.user.setId(userId);
        this.asset = new Assets();
        this.asset.setId(assetId);
        this.featureCode = featureCode;
    }
 
    public static Review initial(Integer assetId){
        Review review = new Review();
        review.asset = new Assets();
        review.asset.setId(assetId);
        review.state = State.Publish;
        return review;
    }
    
    public boolean isInitial(){
        return  this.reviewId == null && this.state == State.Publish;
    }
 
    public void setReviewId(Long reviewId) {
        this.reviewId = reviewId;
        for(Attachment attachment:attachments)
            attachment.setReviewId(reviewId);
    }
 
    public FeatureEvent featureEvent(){
        if(StringUtils.isEmpty(featureCode))
            return null;
        return FeatureEvent.codeOf(featureCode);
    }
    public void featureCode(String featureCode){
        this.featureCode = featureCode;
    }

    public State state() {
        return state;
    }
 
    public Review state(State state) {
        this.state = state;
        return this;
    }
 
    Review() {
        //for ORM
    }
/**
* 构建线程同步状态机
*/   
    private StateMachine<State, FeatureEvent> buildSyncMachine() throws Exception {
        Assert.notNull(state,"状态不能为空");
        StateMachineBuilder.Builder<State, FeatureEvent> builder = StateMachineBuilder.builder();
        builder.configureConfiguration().withConfiguration()
                .taskExecutor(new SyncTaskExecutor())
                .beanFactory(new StaticListableBeanFactory())
                .autoStartup(true);
        //配置状态
        builder.configureStates()
                .withStates()
                .initial(state)
                .states(EnumSet.allOf(State.class));
        //配置状态转移
        StateMachineTransitionConfigurer<State, FeatureEvent> transition = builder.configureTransitions();
        for(FeatureEvent event:FeatureEvent.values()) {
            transition = transition.withExternal()
                    .source(event.reviewState())
                    .target(event.nextState())
                    .event(event)
                    .and();
        }
        return builder.build();
    }
 
}

从Review的状态转移实现主要依赖 buildSyncMachine()方法，在 buildSyncMachine()方法里使用Spring Statemachine（的使用在本文不作描述）实现了第2部分描述的状态转移语义，定义状态和状态转移事件。fireEvent(FeatureEvent event)是触发review发生状态转移的动作，其中主要是实现对拒绝动作和状态正确转移地操作。

 

4.2，调用接口设计

ReviewServiceImpl.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
 
/**
* @author shenjixiaodao
*/
@Service
public class ReviewServiceImpl implements ReviewService {
 
    @Autowired
    private ReviewRepository repository;
 
    @Transactional
    public void review(Review review) {
        // FIXME: 2017/7/10 检查资产是否存在
        Review lastReview = repository.findLastUpdated(review.asset().getId());
        boolean accept = review.state(lastReview.state()).fire();
        FeatureEvent event = review.featureEvent();
        if(!accept) {
            StringBuilder appender = new StringBuilder();
            appender.append("【").append(event.code()).append("】只能将资产从【")
                    .append(event.reviewState().getDesc()).append("】修改为【")
                    .append(event.nextState().getDesc()).append("】");
            throw new IllegalArgumentException(appender.toString());
        }
        if(!lastReview.isInitial()) {
            Assert.notNull(lastReview.reviewId(),"当前状态的评审ID为空");
            //记录状态迁移信息
            lastReview.featureCode(event.code());
            repository.update(lastReview);
        }
        //进入新的状态
        repository.save(review);
    }
 
}

     如上ReviewServiceImpl.java源码所示，定义了一个ReviewService#review(Review)接口来执行所有评审动作。从review(Review)的实现源码看，在触发状态转移之前，我需要从数据库中恢复Review当前所处的状态。最后如果状态迁移成功，则更新状态迁移记录，并进入新的评审状态。