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

2025-01-13 14:25:38 +08:00
parent 08cca7ae61
commit 7a8d5187b9
3 changed files with 191 additions and 87 deletions
--- a/src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java
+++ b/src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java
@@ -81,40 +81,13 @@ 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();
-            S newState = get();
-            invokeHandlers(oldState, newState);
-            return newState;
-        } finally {
-            writeLock.unlock();
-        }
-    }
-
-    @Override
-    public S getAndSwitchPrev() {
-        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();
+            super.reset();
            S newState = get();
+            if (invokeHandlers)
                invokeHandlers(oldState, newState);
        } finally {
            writeLock.unlock();
@@ -122,48 +95,7 @@ public abstract class AbstractStateMachine<S> extends AbstractStateManager<S> im
    }

    @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) {
+    public boolean switchTo(S state, boolean invokeHandlers) {
        int i = indexOf(state);
        if (i == -1 || i == currentIndex()) {
            return false;
@@ -179,6 +111,7 @@ public abstract class AbstractStateMachine<S> extends AbstractStateManager<S> im
            updateCurrentIndex(i);

            S newState = get();
+            if (invokeHandlers)
                invokeHandlers(oldState, newState);
            return true;
        } finally {
@@ -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();
+            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);
+    }
+
    /**
     * 触发处理器
     *
--- a/src/main/java/com/serliunx/statemanagement/machine/StateMachine.java
+++ b/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);
+
    /**
     * 发布事件
     *
--- a/src/test/java/com/serliunx/statemanagement/MachineTest.java
+++ b/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 -> {
-					System.out.println(Thread.currentThread().getName() + ": leave PRINTING");
+				.whenLeave(PrinterState.IDLE, h -> {
+					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.switchTo(PrinterState.PRINTING);
-		stateMachine.switchNext();
-		stateMachine.switchNext();
-
-		System.out.println(stateMachine.current());
-
+		stateMachine.switchNext(false);
 		stateMachine.close();
 	}
 }