初次写流程控制的小伙伴肯都有体会，事务处理的流程中状态一旦多了，就会出现非常多的if-elseif 语句，对于出现Bug解决问题来说，不得不对整段代码的逻辑理一遍，然后才能分析出到底是哪里出了问题。那么，有什么别的好的解决方案吗？
在设计模式中，其实早就已经为我们考虑到了这一个场景，我们可以利用状态模式基本还原这样的任务。
整个实现上的核心基础类就是 基础状态抽象类 和基础有限自动机。业务状态标识了业务流程中的一个个节点，而有限状态机是业务流程的运输体。想象一下，把汽车生产流程当做一个办事流程，那么有限自动机就是传送带，状态就是一道道工序。
// State.java
/**
* @auther chaojilaji
* @version 1.0
* <pre>状态基础</pre>
* <p>主要定义了基础的状态的进入，状态的释放等功能</p>
*/
public abstract class State {
public State() {
}
/**
* 将当前状态加入到某个状态机中
* @param var1 有限状态机
*/
public abstract void enter(FiniteStateMachine var1);
/**
* 从某个状态机中退出
* @param var1 有限状态机
*/
public abstract void exit(FiniteStateMachine var1);
public abstract void pause(FiniteStateMachine var1);
public abstract void resume(FiniteStateMachine var1);
}
基础状态类只需要定义出所有状态的基础功能即可。即 进入传送带、从传送带上面取出来等。
下面来定义基础传动带
// FiniteStateMachine.java
/**
* @author chaojilaji
* @version 1.0
* <pre>有限状态机可以看做是处理事务流程的载体</pre>
*/
public class FiniteStateMachine{
protected EmptyState nullState = new EmptyState();
private Stack<State> states = new Stack();
/**
*
* @return 获取当前状态机中的状态
*/
public State getCurrentState() {
return (State)(this.states.size() == 0 ? this.nullState : (State)this.states.peek());
}
public FiniteStateMachine() {
}
/**
* 状态切换
* @param newSate 进入到新状态
*/
public void ChangeTo(State newSate) {
this.getCurrentState().exit(this);
if (this.states.size() > 0) {
this.states.pop();
}
this.states.push(newSate);
System.out.println("状态----------"+newSate.getClass());
this.getCurrentState().enter(this);
}
}
// EmptyState.java
public class EmptyState extends State{
public EmptyState() {
}
@Override
public void enter(FiniteStateMachine var1) {
}
@Override
public void exit(FiniteStateMachine var1) {
}
@Override
public void pause(FiniteStateMachine var1) {
}
@Override
public void resume(FiniteStateMachine var1) {
}
}
好了，现在第一层基础模块已经写好了，现在我们来实现一个流程demo，如何完成一个处理任务的流程。
// 业务流程中的传送带
/**
* @author chaojilaji
* @version 1.0
* <pre>扫描任务领域有限状态机</pre>
*/
public class TaskFiledMachine extends FiniteStateMachine implements TaskThingListener{
private Long taskId;
public TaskFiledMachine(Long taskId){
this.taskId = taskId;
nullState = new EmptyState();
ChangeTo(new NotBeginState());
}
@Override
public void onCommand(OperateCode operateCode) {
try {
((TaskState)getCurrentState()).onCommand(operateCode);
}catch (Exception e){
e.printStackTrace();
}
}
}
// TaskThingListener 接口定义了传送带在这个业务领域中要干的事儿
public interface TaskThingListener {
void onCommand(OperateCode operateCode);
}
// OperateCode 是操作码
public class OperateCode{
private Integer code;
private Map<String,Object> body;
public OperateCode(Integer code){
this.code = code;
}
public void setBody(Map<String, Object> body) {
this.body = body;
}
public Integer getCode() {
return code;
}
public Map<String, Object> getBody() {
return body;
}
}
传送带建好了，现在我们需要定义该业务流程下的状态基类
public abstract class TaskState extends State {
/**
* 指定当前业务状态所属的业务状态机
*/
protected TaskFiledMachine taskFiledMachine;
public abstract void onCommand(OperateCode operateCode);
@Override
public void enter(FiniteStateMachine var1) {
taskFiledMachine = (TaskFiledMachine) var1;
}
@Override
public void exit(FiniteStateMachine var1) {
taskFiledMachine = null;
}
@Override
public void pause(FiniteStateMachine var1) {
}
@Override
public void resume(FiniteStateMachine var1) {
}
}然后我们只需要基于这个业务场景，通过继承这个TaskState ，定义出一道道工序（状态）
// 未开始的状态
/**
* @author chaojilaji
* @version 1.0
* <pre>未开始的状态</pre>
*/
@Slf4j
public class NotBeginState extends TaskState {
@Override
public void onCommand(OperateCode operateCode) {
if (operateCode.getCode().equals(OperateCodeEnum.NEW_TASK.getCode())){
log.info("新建任务了");
taskFiledMachine.ChangeTo(new QueueState());
}
}
}
// 队列中状态
/**
* @author chaojilaji
* @version 1.0
* <pre>队列状态</pre>
*/
@Slf4j
public class QueueState extends TaskState {
@Override
public void onCommand(OperateCode operateCode){
if (operateCode.getCode().equals(OperateCodeEnum.INIT_STATE.getCode())){
log.info("开始做---出队列---后要做的事儿，先检测参数完整性，再做一些处理");
if (operateCode.getBody().containsKey("task_id")){
log.info("taskId {},进入到队列中处理",operateCode.getBody().get("task_id"));
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("taskId {},队列中处理完毕，转入到扫描中状态",operateCode.getBody().get("taskId"));
taskFiledMachine.ChangeTo(new ScanningState());
taskFiledMachine.onCommand(operateCode);
}
}
}
// 任务执行中状态
/**
* @author chaojilaji
* @version 1.0
* <pre>扫描中</pre>
*/
@Slf4j
public class ScanningState extends TaskState {
@Override
public void onCommand(OperateCode operateCode) {
if (operateCode.getCode().equals(OperateCodeEnum.INIT_STATE.getCode())){
log.info("开始做---扫描中---要做的事儿，先检测参数完整性，再做一些处理");
if (operateCode.getBody().containsKey("task_id")){
log.info("taskId {},进入到扫描中处理",operateCode.getBody().get("task_id"));
}
try {
Thread.sleep(1000*1);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("taskId {},扫描中处理完毕，转入到扫描完毕状态",operateCode.getBody().get("taskId"));
taskFiledMachine.ChangeTo(new ScanEndState());
taskFiledMachine.onCommand(operateCode);
}
}
}
// 任务执行完毕状态
/**
* @author chaojilaji
* @version 1.0
* <pre>扫描完成状态</pre>
*/
@Slf4j
public class ScanEndState extends TaskState {
@Override
public void onCommand(OperateCode operateCode) {
if (operateCode.getCode().equals(OperateCodeEnum.INIT_STATE.getCode())){
log.info("开始做---扫描完毕---要做的事儿，先检测参数完整性，再做一些处理");
if (operateCode.getBody().containsKey("task_id")){
log.info("taskId {},进入到扫描完毕处理",operateCode.getBody().get("task_id"));
}
try {
Thread.sleep(1000*1);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("taskId {},扫描完毕处理完毕，转入到扫描完毕状态",operateCode.getBody().get("taskId"));
}
}
}
最后来看看如何触发这个流程
// 定义一个创建任务的接口，初始化流程
@Autowired
private ScanTask scanTask;
@PostMapping("/change/state")
@ResponseBody
public Object changeStatus(@RequestParam("task_id")final Long taskId,
@RequestParam("operate_code")final Integer operateCode){
Map<String,Object> ans = new HashMap<>();
ans.put("code",400);
if (Objects.isNull(taskId)){
return ans;
}
TaskFiledMachine taskFiledMachine = null;
if (scanTask.taskFiledMachineConcurrentHashMap.containsKey(taskId)){
taskFiledMachine = scanTask.taskFiledMachineConcurrentHashMap.get(taskId);
if (Objects.isNull(taskFiledMachine)){
return ans;
}
}else {
taskFiledMachine = new TaskFiledMachine(taskId);
}
try {
taskFiledMachine.onCommand(new OperateCode(operateCode));
scanTask.taskFiledMachineConcurrentHashMap.put(taskId,taskFiledMachine);
ans.put("code",200);
}catch (Exception e){
e.printStackTrace();
}
return ans;
}
// 流程化任务服务
@Service
public class ScanTask implements InitializingBean {
private PriorityBlockingQueue<Long> tasks = new PriorityBlockingQueue<>(16);
public Map<Long, TaskFiledMachine> taskFiledMachineConcurrentHashMap = new ConcurrentHashMap<>();
private void dispatch() throws InterruptedException {
while (true){
Long taskId = tasks.take();
TaskFiledMachine taskFiledMachine = taskFiledMachineConcurrentHashMap.get(taskId);
taskFiledMachine.onCommand(new OperateCode(OperateCodeEnum.INIT_STATE.getCode()));
}
}
@Override
public void afterPropertiesSet() throws Exception {
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true){
}
}catch (Exception e){
e.printStackTrace();
}
}
}).start();
}
}
简单来说，通过onCommand的调用进入到状态处理，状态间通过changeTo不断的转状态。
