状态机匹配（二）（从零实现）

状态机的组成及使用
状态机组件本身需要依赖很多泛型类型使用
1.比如状态节点的泛型，状态节点内部也需要节点传入请求体的泛型及节点返回体resultDto的泛型，mapFunc的容器map的keyvalue的泛型或其他，这样虽然可以灵活得控制每一块的强执行类型，但是却不容易快速使用，所以提供了一个默认子类组件，就是DefaultStateNodeComponent

@Slf4j
//@Component
@Accessors(chain = true)
public abstract class DefaultStateNodeComponent
        extends StateComponent<
        StateNode,Map,
        Map<StateNode,IMapRouterProcessStateNodeFunc<StateNode>>,
        ResultDTO,Exception> {

    public DefaultStateNodeComponent(IMapFunction<StateNode> iMapFunction) {
        super(iMapFunction);
    }

    public DefaultStateNodeComponent(Map<StateNode, IMapRouterProcessStateNodeFunc<StateNode>> stateNodeIMapRouterProcessStateNodeFuncMap) {
        super(stateNodeIMapRouterProcessStateNodeFuncMap);
    }
}

注：Accessors这是lombok的注解提供链式函数调用(就是他更改实际的调用，并返回调用者本身)
上述的类型都指定了状态组件的基础类型，自定义组装的范型也是继承此处泛型，俩个构造块，一个是实现了mapFunc的接口的实例（组件会优先扫描该class的mapFunc的注解，并产生到容器去），另一个就是本身的mapFunc容器

2.使用

    ResultDTO resultDTO = new DefaultStateNodeComponent(DemoFuncMap.builder().build()){
                            @Override
                            public StateNode onCreate() {
                                return StateNode
                                        .builder()
                                        .nodeCode("t_test01")
                                        .requestDto(new RequestDto(){{
                                            setPrincipal(new Principal() {
                                                @Override
                                                public String getName() {
                                                    return "f170427";
                                                }
                                            });
                                            setData(new HashMap(){{
                                                put("name","twp");
                                            }});
                                        }})
                                        .build();
                            }

                            @Override
                            public Pair<Map, StateNode> onStart() {
                                return Pair.with(new HashMap(),new StateNode().setNodeCode("t_test02"));
                            }

                            @Override
                            public void onException(Exception e) {

                            }

                            @Override
                            public void onDestroy() {

                            }
                        }.setIMapFunctionListenerProcess(iMapFunctionListenerProcess).setITranslateState(iTranslateState).runOnResp();
                log.info(resultDTO.toString());

requestDto属于节点的传入体，有俩个子属性

@AllArgsConstructor@NoArgsConstructor@Data@Builder
public class RequestDto<T> {
    private java.security.Principal principal;
    private T data;
}

Principal这个就用多说了，大家应该都知道是放什么的，
data是各状态节点自己处理的数据

onCreate() 是使用者须实现的抽象方法，用来提供开始节点给状态组件

//初始化state
            this.stateCode = this.onCreate();

onStart()的实现是用来，组装状态组件的属性对象，跟结束节点

//初始化属性
            if (iMapFunction!=null){
                this.container = this.onLoadContainer(this.iMapFunction,this.container);
            }
            val o = this.onStart();
            this.resource = o.getValue0();
            this.endStateCode = o.getValue1();

注：val是类型自动推导实现

 /*
    提供属性加载
    提供容器加载
    设置结束节点
     */
    public abstract Pair<Resource,T> onStart();

注: Pair是java的2元元组

onLoadContainer()提供从注解提取mapFunc容器

/*
    优先使用注解class的mapFunction
     */
    public Container onLoadContainer(IMapFunction<T> iMapFunction,Container injectContainer){
        Container container = injectContainer;
        if (this.iMapFunctionListenerProcess!=null){
            container = (Container) this.iMapFunctionListenerProcess.handler(iMapFunction);
        }
        return container;
    }

下面介绍提取方法
默认接口

public interface IMapFunctionListenerProcess<T,Container> {
    Container handler(IMapFunction<T> iMapFunction);
}

提供一个默认实现

public class MapFunctionListenerProcess<T extends StateNode,Container extends Map<T,IMapRouterProcessStateNodeFunc<T>>>
        implements IMapFunctionListenerProcess

拿到使用者提供实现IMapFunction接口，并且提供线程安全的map容器

/*
        mapFunction的容器，
        使用线程安全的map容器
         */
         Container container =(Container) new ConcurrentHashMap<T,IMapRouterProcessStateNodeFunc<T>>();
        Optional.ofNullable(
                iMapFunction
        ).ifPresent(
                existMapFunction->{
                    try{
                        //通过反射拿到实例
                        Class clazz =  existMapFunction.getClass();
                        Method[] methods = clazz.getMethods();
                        if (methods.length==0) return;
                        //1.过滤非特殊处理的注解方法
                        //2.TreeSet做排重操作
                        Set<StateNode> set =  new TreeSet<StateNode>((o1, o2) -> o1.match(o2)?0:-1);
                        for (Method method:methods){
                            MapFunctionListener mapFunctionListener = method.getAnnotation(MapFunctionListener.class);
                            if (mapFunctionListener==null) continue;

                            //函数转调method，带同代理注解方法
                            IMapRouterProcessStateNodeFunc<StateNode>
                                    iMapRouterProcessStateNodeFunc =
                                    currentNode -> {
                                        StateNode newStateNode = null;
                                        try {
                                            //newStateNode = (StateNode) method.invoke(clazz,currentNode);
                                            newStateNode = (StateNode) method.invoke(existMapFunction,currentNode);
                                        } catch (IllegalAccessException e) {
                                            e.printStackTrace();
                                            currentNode.setEx(e);
                                        } catch (InvocationTargetException e) {
                                            e.printStackTrace();
                                            currentNode.setEx(e);
                                        }finally {
                                            if (newStateNode==null){
                                                newStateNode = currentNode;

                                            }
                                        }
                                        return newStateNode;
                                    };
                            set.add(
                                    StateNode
                                            .builder()
                                            .nodeCode(mapFunctionListener.group()+"_"+mapFunctionListener.code())
                                            .iMapRouterProcessStateNodeFunc(iMapRouterProcessStateNodeFunc)
                                            .build()
                            );
                        }
                        //将处理后的set转换为container
                        if (set!=null&&set.size()>0){
                            set.forEach(
                                    stateNode -> {
                                        container.put((T) stateNode,stateNode.getIMapRouterProcessStateNodeFunc());
                                    }
                            );
                        }

                    }catch (Exception e){
                        log.error("MapFunctionListenerProcess:通过反射拿到实例:",e.getMessage());
                    }
                }
        );
        return container;

注：Optional是java8提供的可选使用类型
当传入的mapFunc的class ifPresent的话，提取他的methods(包含mapFunc的注解)并用TreeSet作排出判空操作，之后再做反射调用组装给容器的value的接口声明的实现。