feat: 状态机切换状态时更灵活.

src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java

@@ -81,89 +81,21 @@ public abstract class AbstractStateMachine<S> extends AbstractStateManager<S> im
     }
 
     @Override
-    public S switchPrevAndGet() {
+    public void reset(boolean invokeHandlers) {
         try {
             writeLock.lock();
             S oldState = get();
-            prev();
+            super.reset();
             S newState = get();
-            invokeHandlers(oldState, newState);
+            if (invokeHandlers)
-            return newState;
+                invokeHandlers(oldState, newState);
         } finally {
             writeLock.unlock();
         }
     }
 
     @Override
-    public S getAndSwitchPrev() {
+    public boolean switchTo(S state, boolean invokeHandlers) {
-        try {
-            writeLock.lock();
-            S oldState = get();
-            prev();
-            S newState = get();
-            invokeHandlers(oldState, newState);
-            return oldState;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public void switchPrev() {
-        try {
-            writeLock.lock();
-            S oldState = get();
-            prev();
-            S newState = get();
-            invokeHandlers(oldState, newState);
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public S switchNextAndGet() {
-        try {
-            writeLock.lock();
-            S oldState = get();
-            next();
-            S newState = get();
-            invokeHandlers(oldState, newState);
-            return newState;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public S getAndSwitchNext() {
-        try {
-            writeLock.lock();
-            S oldState = get();
-            next();
-            S newState = get();
-            invokeHandlers(oldState, newState);
-            return oldState;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public void switchNext() {
-        try {
-            writeLock.lock();
-            S oldState = get();
-            next();
-            S newState = get();
-            invokeHandlers(oldState, newState);
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public boolean switchTo(S state) {
         int i = indexOf(state);
         if (i == -1 || i == currentIndex()) {
             return false;
@@ -179,7 +111,8 @@ public abstract class AbstractStateMachine<S> extends AbstractStateManager<S> im
             updateCurrentIndex(i);
 
             S newState = get();
-            invokeHandlers(oldState, newState);
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
             return true;
         } finally {
             writeLock.unlock();
@@ -187,18 +120,133 @@ public abstract class AbstractStateMachine<S> extends AbstractStateManager<S> im
     }
 
     @Override
-    public void reset() {
+    public S switchPrevAndGet(boolean invokeHandlers) {
         try {
             writeLock.lock();
             S oldState = get();
-            super.reset();
+            prev();
             S newState = get();
-            invokeHandlers(oldState, newState);
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
+            return newState;
         } finally {
             writeLock.unlock();
         }
     }
 
+    @Override
+    public S getAndSwitchPrev(boolean invokeHandlers) {
+        try {
+            writeLock.lock();
+            S oldState = get();
+            prev();
+            S newState = get();
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
+            return oldState;
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public void switchPrev(boolean invokeHandlers) {
+        try {
+            writeLock.lock();
+            S oldState = get();
+            prev();
+            S newState = get();
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public S switchNextAndGet(boolean invokeHandlers) {
+        try {
+            writeLock.lock();
+            S oldState = get();
+            next();
+            S newState = get();
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
+            return newState;
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public S getAndSwitchNext(boolean invokeHandlers) {
+        try {
+            writeLock.lock();
+            S oldState = get();
+            next();
+            S newState = get();
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
+            return oldState;
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public void switchNext(boolean invokeHandlers) {
+        try {
+            writeLock.lock();
+            S oldState = get();
+            next();
+            S newState = get();
+            if (invokeHandlers)
+                invokeHandlers(oldState, newState);
+        } finally {
+            writeLock.unlock();
+        }
+    }
+
+    @Override
+    public S switchPrevAndGet() {
+        return switchPrevAndGet(true);
+    }
+
+    @Override
+    public S getAndSwitchPrev() {
+        return getAndSwitchPrev(true);
+    }
+
+    @Override
+    public void switchPrev() {
+        switchPrev(true);
+    }
+
+    @Override
+    public S switchNextAndGet() {
+        return switchNextAndGet(true);
+    }
+
+    @Override
+    public S getAndSwitchNext() {
+        return getAndSwitchNext(true);
+    }
+
+    @Override
+    public void switchNext() {
+        switchNext(true);
+    }
+
+    @Override
+    public boolean switchTo(S state) {
+        return switchTo(state, true);
+    }
+
+    @Override
+    public void reset() {
+        reset(true);
+    }
+
     /**
      * 触发处理器
      *

src/main/java/com/serliunx/statemanagement/machine/StateMachine.java

@@ -22,6 +22,69 @@ import com.serliunx.statemanagement.manager.BidirectionalStateManager;
  */
 public interface StateMachine<S> extends BidirectionalStateManager<S>, AutoCloseable {
 
+    /**
+     * 切换至下一个状态
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     */
+    void switchNext(boolean invokeHandlers);
+
+    /**
+     * 返回并切换至下一个状态
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     * @return 切换前的状态
+     */
+    S getAndSwitchNext(boolean invokeHandlers);
+
+    /**
+     * 切换至下一个状态并返回切换后的状态
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     * @return 切换后的状态
+     */
+    S switchNextAndGet(boolean invokeHandlers);
+
+    /**
+     * 切换至上一个状态
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     */
+    void switchPrev(boolean invokeHandlers);
+
+    /**
+     * 获取当前状态并切换至上一个状态
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     * @return 切换前的状态
+     */
+    S getAndSwitchPrev(boolean invokeHandlers);
+
+    /**
+     * 切换至上一个状态并返回切换后的状态
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     * @return 切换后的状态
+     */
+    S switchPrevAndGet(boolean invokeHandlers);
+
+    /**
+     * 重置回默认状态, 一般为状态集合中的第一个
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     */
+    void reset(boolean invokeHandlers);
+
+    /**
+     * 切换至指定状态
+     * <li> 在使用状态机的情况, 仅切换成功才会触发注册的各种事件.
+     *
+     * @param invokeHandlers    是否唤醒状态处理器
+     * @param state             新的状态
+     * @return 切换成功返回真, 否则返回假
+     */
+    boolean switchTo(S state, boolean invokeHandlers);
+
     /**
      * 发布事件
      *

src/test/java/com/serliunx/statemanagement/MachineTest.java

@@ -24,8 +24,8 @@ public class MachineTest {
 				.async()
 				.standard()
 				.executor(Executors.newFixedThreadPool(16))
-				.whenLeave(PrinterState.PRINTING, h -> {
+				.whenLeave(PrinterState.IDLE, h -> {
-					System.out.println(Thread.currentThread().getName() + ": leave PRINTING");
+					System.out.println(Thread.currentThread().getName() + ": leave IDLE");
 				})
 				.whenEntry(PrinterState.STOPPING, h -> {
 					System.out.println(Thread.currentThread().getName() + ": entry STOPPING, from " + h.getFrom());
@@ -35,14 +35,7 @@ public class MachineTest {
 				})
 				.build();
 
-		System.out.println(stateMachine.getClass());
+		stateMachine.switchNext(false);
-
-		stateMachine.switchTo(PrinterState.PRINTING);
-		stateMachine.switchNext();
-		stateMachine.switchNext();
-
-		System.out.println(stateMachine.current());
-
 		stateMachine.close();
 	}
 }