optimize: add StateType Enum

compatible/src/main/java/io/seata/saga/statelang/domain/State.java

@@ -43,7 +43,7 @@ public interface State {
      *
      * @return the state type
      */
-    String getType();
+    StateType getType();
 
     /**
      * next state name

compatible/src/main/java/io/seata/saga/statelang/domain/StateInstance.java

@@ -72,14 +72,14 @@ public interface StateInstance {
      *
      * @return state instance type
      */
-    String getType();
+    StateType getType();
 
     /**
      * set type
      *
      * @param type state instance type
      */
-    void setType(String type);
+    void setType(StateType type);
 
     /**
      * get service name

compatible/src/main/java/io/seata/saga/statelang/domain/StateType.java

@@ -0,0 +1,145 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.seata.saga.statelang.domain;
+
+/**
+ * StateType
+ */
+@Deprecated
+public enum StateType {
+
+    /**
+     * ServiceTask State
+     */
+    SERVICE_TASK("ServiceTask"),
+
+    /**
+     * Choice State
+     */
+    CHOICE("Choice"),
+
+    /**
+     * Fail State
+     */
+    FAIL("Fail"),
+
+    /**
+     * Succeed State
+     */
+    SUCCEED("Succeed"),
+
+    /**
+     * CompensationTrigger State
+     */
+    COMPENSATION_TRIGGER("CompensationTrigger"),
+
+    /**
+     * SubStateMachine State
+     */
+    SUB_STATE_MACHINE("SubStateMachine"),
+
+    /**
+     * CompensateSubMachine State
+     */
+    SUB_MACHINE_COMPENSATION("CompensateSubMachine"),
+
+    /**
+     * ScriptTask State
+     */
+    SCRIPT_TASK("ScriptTask"),
+
+    /**
+     * LoopStart State
+     */
+    LOOP_START("LoopStart");
+
+
+    private String value;
+
+    StateType(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public static StateType getStateType(String value) {
+        for (StateType stateType : values()) {
+            if (stateType.getValue().equalsIgnoreCase(value)) {
+                return stateType;
+            }
+        }
+
+        throw new IllegalArgumentException("Unknown StateType[" + value + "]");
+    }
+
+
+    public static StateType wrap(org.apache.seata.saga.statelang.domain.StateType target) {
+        if (target == null) {
+            return null;
+        }
+        switch (target) {
+            case SERVICE_TASK:
+                return SERVICE_TASK;
+            case CHOICE:
+                return CHOICE;
+            case FAIL:
+                return FAIL;
+            case SUCCEED:
+                return SUCCEED;
+            case COMPENSATION_TRIGGER:
+                return COMPENSATION_TRIGGER;
+            case SUB_STATE_MACHINE:
+                return SUB_STATE_MACHINE;
+            case SUB_MACHINE_COMPENSATION:
+                return SUB_MACHINE_COMPENSATION;
+            case SCRIPT_TASK:
+                return SCRIPT_TASK;
+            case LOOP_START:
+                return LOOP_START;
+            default:
+                throw new IllegalArgumentException("Cannot convert " + target.name());
+        }
+    }
+
+    public org.apache.seata.saga.statelang.domain.StateType unwrap() {
+        switch (this) {
+            case SERVICE_TASK:
+                return org.apache.seata.saga.statelang.domain.StateType.SERVICE_TASK;
+            case CHOICE:
+                return org.apache.seata.saga.statelang.domain.StateType.CHOICE;
+            case FAIL:
+                return org.apache.seata.saga.statelang.domain.StateType.FAIL;
+            case SUCCEED:
+                return org.apache.seata.saga.statelang.domain.StateType.SUCCEED;
+            case COMPENSATION_TRIGGER:
+                return org.apache.seata.saga.statelang.domain.StateType.COMPENSATION_TRIGGER;
+            case SUB_STATE_MACHINE:
+                return org.apache.seata.saga.statelang.domain.StateType.SUB_STATE_MACHINE;
+            case SUB_MACHINE_COMPENSATION:
+                return org.apache.seata.saga.statelang.domain.StateType.SUB_MACHINE_COMPENSATION;
+            case SCRIPT_TASK:
+                return org.apache.seata.saga.statelang.domain.StateType.SCRIPT_TASK;
+            case LOOP_START:
+                return org.apache.seata.saga.statelang.domain.StateType.LOOP_START;
+            default:
+                throw new IllegalArgumentException("Cannot convert " + this.name());
+        }
+    }
+
+}

compatible/src/main/java/io/seata/saga/statelang/domain/impl/StateImpl.java

@@ -20,6 +20,7 @@
 
 import io.seata.saga.statelang.domain.State;
 import io.seata.saga.statelang.domain.StateMachine;
+import io.seata.saga.statelang.domain.StateType;
 
 /**
  * The type State.
@@ -45,8 +46,8 @@ public String getComment() {
     }
 
     @Override
-    public String getType() {
-        return actual.getType();
+    public StateType getType() {
+        return StateType.wrap(actual.getType());
     }
 
     @Override

compatible/src/main/java/io/seata/saga/statelang/domain/impl/StateInstanceImpl.java

@@ -21,6 +21,7 @@
 import io.seata.saga.statelang.domain.ExecutionStatus;
 import io.seata.saga.statelang.domain.StateInstance;
 import io.seata.saga.statelang.domain.StateMachineInstance;
+import io.seata.saga.statelang.domain.StateType;
 
 /**
  * state execution instance
@@ -67,13 +68,17 @@ public void setName(String name) {
     }
 
     @Override
-    public String getType() {
-        return actual.getType();
+    public StateType getType() {
+        return StateType.wrap(actual.getType());
     }
 
     @Override
-    public void setType(String type) {
-        actual.setType(type);
+    public void setType(StateType type) {
+        if (type == null) {
+            actual.setType(null);
+        } else {
+            actual.setType(type.unwrap());
+        }
     }
 
     @Override

saga/seata-saga-engine/src/main/java/org/apache/seata/saga/engine/config/AbstractStateMachineConfig.java

@@ -54,6 +54,7 @@
 import org.apache.seata.saga.proctrl.impl.ProcessControllerImpl;
 import org.apache.seata.saga.proctrl.process.impl.CustomizeBusinessProcessor;
 import org.apache.seata.saga.statelang.domain.DomainConstants;
+import org.apache.seata.saga.statelang.domain.StateType;
 
 import javax.script.ScriptEngineManager;
 import java.io.InputStream;
@@ -214,20 +215,8 @@ public void init() throws Exception {
     }
 
     public ProcessControllerImpl createProcessorController(ProcessCtrlEventPublisher eventPublisher) throws Exception {
-        StateMachineProcessRouter stateMachineProcessRouter = new StateMachineProcessRouter();
-        stateMachineProcessRouter.initDefaultStateRouters();
-        loadStateRouterInterceptors(stateMachineProcessRouter.getStateRouters());
-
-        StateMachineProcessHandler stateMachineProcessHandler = new StateMachineProcessHandler();
-        stateMachineProcessHandler.initDefaultHandlers();
-        loadStateHandlerInterceptors(stateMachineProcessHandler.getStateHandlers());
-
-        DefaultRouterHandler defaultRouterHandler = new DefaultRouterHandler();
-        defaultRouterHandler.setEventPublisher(eventPublisher);
-
-        Map<String, ProcessRouter> processRouterMap = new HashMap<>(1);
-        processRouterMap.put(ProcessType.STATE_LANG.getCode(), stateMachineProcessRouter);
-        defaultRouterHandler.setProcessRouters(processRouterMap);
+        StateMachineProcessHandler stateMachineProcessHandler = buildStateMachineProcessHandler();
+        DefaultRouterHandler defaultRouterHandler = buildDefaultRouterHandler(eventPublisher);
 
         CustomizeBusinessProcessor customizeBusinessProcessor = new CustomizeBusinessProcessor();
 
@@ -245,7 +234,28 @@ public ProcessControllerImpl createProcessorController(ProcessCtrlEventPublisher
         return processorController;
     }
 
-    public void loadStateHandlerInterceptors(Map<String, StateHandler> stateHandlerMap) {
+    private StateMachineProcessHandler buildStateMachineProcessHandler() {
+        StateMachineProcessHandler stateMachineProcessHandler = new StateMachineProcessHandler();
+        stateMachineProcessHandler.initDefaultHandlers();
+        loadStateHandlerInterceptors(stateMachineProcessHandler.getStateHandlers());
+        return stateMachineProcessHandler;
+    }
+
+    private DefaultRouterHandler buildDefaultRouterHandler(ProcessCtrlEventPublisher eventPublisher) {
+        DefaultRouterHandler defaultRouterHandler = new DefaultRouterHandler();
+        defaultRouterHandler.setEventPublisher(eventPublisher);
+
+        StateMachineProcessRouter stateMachineProcessRouter = new StateMachineProcessRouter();
+        stateMachineProcessRouter.initDefaultStateRouters();
+        loadStateRouterInterceptors(stateMachineProcessRouter.getStateRouters());
+
+        Map<String, ProcessRouter> processRouterMap = new HashMap<>(2);
+        processRouterMap.put(ProcessType.STATE_LANG.getCode(), stateMachineProcessRouter);
+        defaultRouterHandler.setProcessRouters(processRouterMap);
+        return defaultRouterHandler;
+    }
+
+    public void loadStateHandlerInterceptors(Map<StateType, StateHandler> stateHandlerMap) {
         for (StateHandler stateHandler : stateHandlerMap.values()) {
             if (stateHandler instanceof InterceptableStateHandler) {
                 InterceptableStateHandler interceptableStateHandler = (InterceptableStateHandler) stateHandler;
@@ -259,7 +269,7 @@ public void loadStateHandlerInterceptors(Map<String, StateHandler> stateHandlerM
         }
     }
 
-    public void loadStateRouterInterceptors(Map<String, StateRouter> stateRouterMap) {
+    public void loadStateRouterInterceptors(Map<StateType, StateRouter> stateRouterMap) {
         for (StateRouter stateRouter : stateRouterMap.values()) {
             if (stateRouter instanceof InterceptableStateRouter) {
                 InterceptableStateRouter interceptableStateRouter = (InterceptableStateRouter) stateRouter;

saga/seata-saga-engine/src/main/java/org/apache/seata/saga/engine/impl/ProcessCtrlStateMachineEngine.java

@@ -38,6 +38,7 @@
 import org.apache.seata.saga.proctrl.ProcessContext;
 import org.apache.seata.saga.proctrl.ProcessType;
 import org.apache.seata.saga.statelang.domain.DomainConstants;
+import org.apache.seata.saga.statelang.domain.StateType;
 import org.apache.seata.saga.statelang.domain.ExecutionStatus;
 import org.apache.seata.saga.statelang.domain.State;
 import org.apache.seata.saga.statelang.domain.StateInstance;
@@ -280,7 +281,7 @@ protected StateMachineInstance forwardInternal(String stateMachineInstId, Map<St
 
         context.setVariable(lastForwardState.getName() + DomainConstants.VAR_NAME_RETRIED_STATE_INST_ID,
             lastForwardState.getId());
-        if (DomainConstants.STATE_TYPE_SUB_STATE_MACHINE.equals(lastForwardState.getType()) && !ExecutionStatus.SU
+        if (StateType.SUB_STATE_MACHINE.equals(lastForwardState.getType()) && !ExecutionStatus.SU
             .equals(lastForwardState.getCompensationStatus())) {
 
             context.setVariable(DomainConstants.VAR_NAME_IS_FOR_SUB_STATMACHINE_FORWARD, true);
@@ -418,7 +419,7 @@ public StateInstance findOutLastForwardStateInstance(List<StateInstance> stateIn
                     continue;
                 }
 
-                if (DomainConstants.STATE_TYPE_SUB_STATE_MACHINE.equals(stateInstance.getType())) {
+                if (StateType.SUB_STATE_MACHINE.equals(stateInstance.getType())) {
 
                     StateInstance finalState = stateInstance;
 

saga/seata-saga-engine/src/main/java/org/apache/seata/saga/engine/pcext/StateMachineProcessHandler.java

@@ -33,7 +33,7 @@
 import org.apache.seata.saga.engine.pcext.handlers.SucceedEndStateHandler;
 import org.apache.seata.saga.proctrl.ProcessContext;
 import org.apache.seata.saga.proctrl.handler.ProcessHandler;
-import org.apache.seata.saga.statelang.domain.DomainConstants;
+import org.apache.seata.saga.statelang.domain.StateType;
 import org.apache.seata.saga.statelang.domain.State;
 
 /**
@@ -43,13 +43,13 @@
  */
 public class StateMachineProcessHandler implements ProcessHandler {
 
-    private final Map<String, StateHandler> stateHandlers = new ConcurrentHashMap<>();
+    private final Map<StateType, StateHandler> stateHandlers = new ConcurrentHashMap<>();
 
     @Override
     public void process(ProcessContext context) throws FrameworkException {
         StateInstruction instruction = context.getInstruction(StateInstruction.class);
         State state = instruction.getState(context);
-        String stateType = state.getType();
+        StateType stateType = state.getType();
         StateHandler stateHandler = stateHandlers.get(stateType);
 
         List<StateHandlerInterceptor> interceptors = null;
@@ -84,28 +84,27 @@ public void process(ProcessContext context) throws FrameworkException {
     }
 
     public void initDefaultHandlers() {
-        if (stateHandlers.isEmpty()) {
-            stateHandlers.put(DomainConstants.STATE_TYPE_SERVICE_TASK, new ServiceTaskStateHandler());
-
-            stateHandlers.put(DomainConstants.STATE_TYPE_SCRIPT_TASK, new ScriptTaskStateHandler());
-
-            stateHandlers.put(DomainConstants.STATE_TYPE_SUB_MACHINE_COMPENSATION, new ServiceTaskStateHandler());
+        if (!stateHandlers.isEmpty()) {
+            return;
+        }
 
-            stateHandlers.put(DomainConstants.STATE_TYPE_SUB_STATE_MACHINE, new SubStateMachineHandler());
+        stateHandlers.put(StateType.SERVICE_TASK, new ServiceTaskStateHandler());
+        stateHandlers.put(StateType.SCRIPT_TASK, new ScriptTaskStateHandler());
+        stateHandlers.put(StateType.SUB_MACHINE_COMPENSATION, new ServiceTaskStateHandler());
+        stateHandlers.put(StateType.SUB_STATE_MACHINE, new SubStateMachineHandler());
+        stateHandlers.put(StateType.CHOICE, new ChoiceStateHandler());
+        stateHandlers.put(StateType.SUCCEED, new SucceedEndStateHandler());
+        stateHandlers.put(StateType.FAIL, new FailEndStateHandler());
+        stateHandlers.put(StateType.COMPENSATION_TRIGGER, new CompensationTriggerStateHandler());
+        stateHandlers.put(StateType.LOOP_START, new LoopStartStateHandler());
 
-            stateHandlers.put(DomainConstants.STATE_TYPE_CHOICE, new ChoiceStateHandler());
-            stateHandlers.put(DomainConstants.STATE_TYPE_SUCCEED, new SucceedEndStateHandler());
-            stateHandlers.put(DomainConstants.STATE_TYPE_FAIL, new FailEndStateHandler());
-            stateHandlers.put(DomainConstants.STATE_TYPE_COMPENSATION_TRIGGER, new CompensationTriggerStateHandler());
-            stateHandlers.put(DomainConstants.STATE_TYPE_LOOP_START, new LoopStartStateHandler());
-        }
     }
 
-    public Map<String, StateHandler> getStateHandlers() {
+    public Map<StateType, StateHandler> getStateHandlers() {
         return stateHandlers;
     }
 
-    public void setStateHandlers(Map<String, StateHandler> stateHandlers) {
+    public void setStateHandlers(Map<StateType, StateHandler> stateHandlers) {
         this.stateHandlers.putAll(stateHandlers);
     }
 }