mina statemachine解读（二）
这里主要讲下对外接口暴露的处理。
// 创建对外接口对象 TaskWork taskWork = new StateMachineProxyBuilder().setStateContextLookup(new StateContextLookup() { @Override public StateContext lookup(Object[] objects) { Integer taskId = (Integer)objects[0]; // 这里应该是根据Id去数据库查询 Task task = new Task(); task.setId(taskId); StateContext context = new DefaultStateContext(); if (taskId == 123) { task.setState(TaskHandler.CREATED); } else if (taskId == 124) { task.setState(TaskHandler.TOOK); } else if (taskId == 125) { task.setState(TaskHandler.SUBMITTED); } context.setCurrentState(sm.getState(task.getState())); context.setAttribute("task", task); return context; } }).create(TaskWork.class, sm);
这里主要看create方法，其实就是通过代理模式创建了一个代理类。
public Object create(Class<?>[] ifaces, StateMachine sm) { ClassLoader cl = defaultCl; if (cl == null) { cl = Thread.currentThread().getContextClassLoader(); } InvocationHandler handler = new MethodInvocationHandler(sm, contextLookup, interceptor, eventFactory, ignoreUnhandledEvents, ignoreStateContextLookupFailure, name); return Proxy.newProxyInstance(cl, ifaces, handler); }
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if ("hashCode".equals(method.getName()) && args == null) { return Integer.valueOf(System.identityHashCode(proxy)); } if ("equals".equals(method.getName()) && args.length == 1) { return Boolean.valueOf(proxy == args[0]); } if ("toString".equals(method.getName()) && args == null) { return (name != null ? name : proxy.getClass().getName()) + "@" + Integer.toHexString(System.identityHashCode(proxy)); } if (log.isDebugEnabled()) { log.debug("Method invoked: " + method); } args = args == null ? EMPTY_ARGUMENTS : args; // 拦截器处理可以对输入参数做一些处理 if (interceptor != null) { args = interceptor.modify(args); } // lookup方法去加载context StateContext context = contextLookup.lookup(args); if (context == null) { if (ignoreStateContextLookupFailure) { return null; } throw new IllegalStateException("Cannot determine state context for method invocation: " + method); } // 事件工厂去创建事件，statematchine其实最终还是由事件去驱动的 Event event = eventFactory.create(context, method, args); try { // statemachine处理传入时间，触发状态处理 sm.handle(event); } catch (UnhandledEventException uee) { if (!ignoreUnhandledEvents) { throw uee; } } return null; } }
这里可以看到主要是会由StateContextLookup去根据传入参数查找相应的StateContext，然后由EventFactory去创建一个Event，然后stateMachine去处理这个事件来完成状态机的调用，内部状态的轮转，状态机最终还是由事件去驱动的。
private void handle(State state, Event event) { StateContext context = event.getContext(); // 获取state上面绑定的transitions for (Transition t : state.getTransitions()) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Trying transition {}", t); } try { // transition实际执行相关的事件 if (t.execute(event)) { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Transition {} executed successfully.", t); } // 执行成功执行onExits,OnEntries设置相应的状态 setCurrentState(context, t.getNextState()); return; } } ... ... /* * No transition could handle the event. Try with the parent state if * there is one. */ // 如果没有当前state没有绑定transition，或者没有符合条件的transition，去找parent state，如果还没有就是说明是不支持的，抛出没有处理的Envet异常 if (state.getParent() != null) { handle(state.getParent(), event); } else { throw new UnhandledEventException(event); } }
事件最终的执行还是有transition去执行，这里获取了state上的transition然后去处理event，然后通过执行的结果，以及实际方法处理中抛出的：BreakAndContinueException，BreakAndGotoException，BreakAndCallException，BreakAndReturnException异常来进行流程控制。
看一下实际的transition处理类，MethodTransition
public boolean doExecute(Event event) { Class<?>[] types = method.getParameterTypes(); if (types.length == 0) { invokeMethod(EMPTY_ARGUMENTS); return true; } // 如果参数长度大于2+原始参数失败 if (types.length > 2 + event.getArguments().length) { return false; } Object[] args = new Object[types.length]; int i = 0; // 如果第一个参数是Event，则将event对象放入参数列表 if (match(types[i], event, Event.class)) { args[i++] = event; } // 如果第二个参数是StateContext则将context对象放入参数列表 if (i < args.length && match(types[i], event.getContext(), StateContext.class)) { args[i++] = event.getContext(); } Object[] eventArgs = event.getArguments(); // 判定剩余参数类型是否匹配，如果不匹配则执行失败 for (int j = 0; i < args.length && j < eventArgs.length; j++) { if (match(types[i], eventArgs[j], Object.class)) { args[i++] = eventArgs[j]; } } if (args.length > i) { return false; } // 执行method invokeMethod(args); return true; }
这里主要做了参数的校验与绑定，对实际处理方法中如果加了Event或者是StateContext也把相应的数据塞到参数列表里面，实际执行时候大概率也会用到StateContext。
private void invokeMethod(Object[] arguments) { try { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Executing method " + method + " with arguments " + Arrays.asList(arguments)); } method.invoke(target, arguments); } catch (InvocationTargetException ite) { if (ite.getCause() instanceof RuntimeException) { throw (RuntimeException) ite.getCause(); } throw new MethodInvocationException(method, ite); } catch (IllegalAccessException iae) { throw new MethodInvocationException(method, iae); } }
invokeMethod是实际的方法执行类，这里会对Exception区别处理，对RuntimeException直接抛出，这里处理BreakException是不更好点。
这里整个调用过程也分析完了，可以看到状态机的流转主要是由Event驱动，获取State绑定的transition来执行处理Event，StateMachineProxyBuilder就是用代理的方式提供了方便的对外接口类。
如果不使用这个也照样可以玩转状态机，如前面这段示例程序：
StateContext context = new DefaultStateContext(); context.setCurrentState(sm.getState(TaskHandler.CREATED)); context.setAttribute("task", new Task()); Event event = new Event("take", context, new Object[]{123, "Jack"}); sm.handle(event);
可以看到整个状态机的设计还是很清晰、巧妙的。运用了工厂模式、代理模式等设计模式，对外提供简单易懂的API，内部流转也清晰明了，还是很值得我们学习的。
