From 7a8d5187b901d4143fdb64b0bc2bcd1c41e911ae Mon Sep 17 00:00:00 2001 From: SerLiunx-ctrl <17689543@qq.com> Date: Mon, 13 Jan 2025 14:25:38 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E7=8A=B6=E6=80=81=E6=9C=BA=E5=88=87?= =?UTF-8?q?=E6=8D=A2=E7=8A=B6=E6=80=81=E6=97=B6=E6=9B=B4=E7=81=B5=E6=B4=BB?= =?UTF-8?q?.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../machine/AbstractStateMachine.java | 202 +++++++++++------- .../statemanagement/machine/StateMachine.java | 63 ++++++ .../serliunx/statemanagement/MachineTest.java | 13 +- 3 files changed, 191 insertions(+), 87 deletions(-) diff --git a/src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java b/src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java index 529413d..4cf2f21 100644 --- a/src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java +++ b/src/main/java/com/serliunx/statemanagement/machine/AbstractStateMachine.java @@ -81,89 +81,21 @@ public abstract class AbstractStateMachine extends AbstractStateManager 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); - return newState; + if (invokeHandlers) + invokeHandlers(oldState, 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(); - 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) { + public boolean switchTo(S state, boolean invokeHandlers) { int i = indexOf(state); if (i == -1 || i == currentIndex()) { return false; @@ -179,7 +111,8 @@ public abstract class AbstractStateMachine extends AbstractStateManager 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 extends AbstractStateManager 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); + } + /** * 触发处理器 * diff --git a/src/main/java/com/serliunx/statemanagement/machine/StateMachine.java b/src/main/java/com/serliunx/statemanagement/machine/StateMachine.java index 9abe350..4f2fc1f 100644 --- 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 extends BidirectionalStateManager, 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); + + /** + * 切换至指定状态 + *
  • 在使用状态机的情况, 仅切换成功才会触发注册的各种事件. + * + * @param invokeHandlers 是否唤醒状态处理器 + * @param state 新的状态 + * @return 切换成功返回真, 否则返回假 + */ + boolean switchTo(S state, boolean invokeHandlers); + /** * 发布事件 * diff --git a/src/test/java/com/serliunx/statemanagement/MachineTest.java b/src/test/java/com/serliunx/statemanagement/MachineTest.java index ae4186b..7bf122d 100644 --- 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(); } }