状态机实现

说明：
1、参考了spring state machine，但是个人感觉spring state machine，使用注入的方式太重了，而且附加的各种特性如监听，条件选择等等都不实用，不适合自己的业务场景，个人期望的是，每一个实体类都可以有一个自己的状态机，状态机用来清晰的展示状态的迁移逻辑，核心作用是可读性、内聚性，同时可以限制未定义的状态迁移。
2、状态机跟状态的关系，根据个人的理解做了区隔。状态机是状态迁移的逻辑定义，本身并不代表一个状态，状态机的作用就是对于给定的输入（状态，事件），告诉你下一个状态是什么，是一个辅助工具。
3、对于迁移条件，条件绝大部分时候具有外部性，将外部性的逻辑纳入到状态机内部，只能增加状态机跟外部的耦合性，导致状态机使用复杂，不符合高内聚低耦合、单一职责的开发原则，条件可以通过增加事件类型来处理。
4、对于状态发生变化时，自动触发某个操作，这个操作也是外部性的，如果采用ddd建模，这个触发的操作，应该是聚合的职责，而不是状态机的职责。

总而言之，个人对状态机的理解和需求，是一个简单易用，主要目的是用来明确展示状态迁移规则，增强状态变化业务逻辑内聚性的工具，如下这个实现，很好的满足了这个需求，如果你也在找这样一个状态机，不妨参考下，能给一些建议就更好了。

public class StateMachine<S,E> {
	private Map<S,List<Rule>> ruleMap = new HashMap<>();
	private Set<S> startNodes = new HashSet<>();
	private Set<S> targetNodes = new HashSet<>();
	private final StateMachine<S,E> innerStateMachine = this;
	
	@SuppressWarnings("unchecked")
	public void init(S ...status) {
		if(status !=null && status.length > 0) {
			for(S s : status) {
				startNodes.add(s);
			}
		}
	}
	public When when(S status) {
		if(!startNodes.contains(status) && !targetNodes.contains(status)) {
			throw new RuntimeException("开始状态尚未定义");
		}
		return new When(status);
	}
	
	public class When {
		private S status;
		public When(S status) {
			this.status = status;
		}
		@SuppressWarnings("unchecked")
		public Occur occur(E... event) {
			return  new Occur(status, event);
		}
	}
	public class Occur {
		private E[] eventArr;
		private S statusFrom;
		Occur(S statusFrom, E[] eventArr){
			this.statusFrom = statusFrom;
			this.eventArr = eventArr;
		}
		public StateMachine<S,E> then(S statusTo) {
			Rule rule = new Rule(statusFrom, eventArr, statusTo);
			List<Rule> ruleList;
			if(ruleMap.containsKey(statusFrom)) {
				ruleList = ruleMap.get(statusFrom);
			} else {
				ruleList = new ArrayList<Rule>();
				ruleMap.put(rule.statusFrom, ruleList);
			}
			ruleList.add(rule);
			targetNodes.add(statusTo);
			return innerStateMachine;
		}
	}
	private class Rule {
		private Set<E> eventSet = new HashSet<>();
		private S statusFrom;
		private S statusTo;
		public Rule(S statusFrom, E[] eventArr, S statusTo) {
			for(E e : eventArr) {
				this.eventSet.add(e);
			}
			this.statusFrom=statusFrom;
			this.statusTo = statusTo;
		}
		public boolean isMatch(E event) {
			if(eventSet.contains(event)) {
				return true;
			}
			return false;
		}
	}
	
	public S on(S status,E event) {
		List<Rule> ruleList = this.ruleMap.get(status);
		if(ruleList != null && ruleList.size()>0) {
			for(Rule rule : ruleList) {
				if(rule.isMatch(event)) {
					return rule.statusTo;
				} else {
					continue ;
				}
			}
		}
		throw new RuntimeException("状态"+status+"与事件"+event+"不匹配");
	}
	
	public boolean isValidStartNode(S status) {
		if(startNodes.contains(status)) {
			return true;
		}
		return false;
	}
}

使用实例：

public class Order {
	private String orderId;
	private BigDecimal buyAmount;
	private Integer status;
	public static enum MyStatus {
		WAIT_PAY,
		PAYED,
		SEND_OUT,
		BUY_SUCCESS,
		CLOSE;//订单关闭
		
		public static MyStatus valueOf(Integer v) {
			for(MyStatus status : MyStatus.values()) {
				if(status.ordinal() == v) {
					return status;
				}
			}
			return null;
		}
	}
	public static enum MyEvent {
		PAY_OUTOF_TIME,
		PAY_SUCCESS,
		SEND_OUT_SUCCESS,
		BUY_SUCCESS,
		REFUND, //退货
		REJECTED//拒收
	}
	
	private static StateMachine<MyStatus, MyEvent> stateMachine = new StateMachine<>();
	static {
		stateMachine.when(MyStatus.WAIT_PAY).occur(MyEvent.PAY_SUCCESS).then(MyStatus.PAYED)
		.when(MyStatus.WAIT_PAY).occur(MyEvent.PAY_OUTOF_TIME).then(MyStatus.CLOSE)
		.when(MyStatus.PAYED).occur(MyEvent.PAY_SUCCESS).then(MyStatus.PAYED)
		.when(MyStatus.PAYED).occur(MyEvent.SEND_OUT_SUCCESS).then(MyStatus.SEND_OUT)
		.when(MyStatus.SEND_OUT).occur(MyEvent.REFUND,MyEvent.REJECTED).then(MyStatus.CLOSE);
	}
	
	public Order() {
		this.status = MyStatus.WAIT_PAY.ordinal();
	}
	
	public void paySuccess() {
		this.status = stateMachine.on(MyStatus.valueOf(status), MyEvent.PAY_SUCCESS).ordinal();
	}
	public void sendOut() {
		this.status = stateMachine.on(MyStatus.valueOf(status), MyEvent.SEND_OUT_SUCCESS).ordinal();
	}
	public void refund() {
		this.status = stateMachine.on(MyStatus.valueOf(status), MyEvent.REFUND).ordinal();
	}
	
	public static void main(String[] args) {
		Order order = new Order();
		order.paySuccess();
		order.sendOut();
		order.refund();
		System.out.println(MyStatus.valueOf(order.status));
	}
}