状态模式(State Pattern)

状态模式（State Pattern），通过将事件触发的状态转移和动作执行，拆分到不同的状态类中，来避免分支判断逻辑。

在实际的软件开发中，状态模式并不是很常用，但是在能够用到的场景里，它可以发挥很大的作用。

应用场景

当应用场景符合状态类不是很多，但是状态间的转换和行为较复杂时，状态模式就能派上大用场。

比如在oa工作流中，需要有限多种的审批状态，每种状态间的转换逻辑较为复杂，这种使用状态模式就较为好管理。

状态模式的构成

逻辑构成

状态模式逻辑上主要由三部分组成：

状态（State）：整个业务中所有的状态。
事件（Event）：也称转移条件，事件的触发会导致状态的转移以及相应的动作。
动作（Action）：状态转移或事件触发时执行的逻辑。

组成对象构成

1. 状态基类：抽象状态基类，定义了具体的状态类需要实现的规范。
2. 具体状态子类：继承状态基类，每个子类实现一个符合自己功能的状态相关行为。
3. 请求调用类：用于维护当前状态及封装状态间的流转,对外提供调用。

通过一个工作流审批的例子来说明。
在某公司的工作流审批中，会有小组审批、部门审批，审批拒绝、审批成功这些状态。
每个状态定义了各自转移到其它状态时触发的事件及对应的行为。

状态基类

class State:
    Allow = []

    def __init__(self):
        self.load_event()

    def switch(self, to):
        """"""
        state = to.get_current_state()

        assert state in self.Allow, "不被允许的状态转移 {} => {}".format(self.__class__.__name__,
                                                                to.__class__.__name__)
        self._event[state]()

    # 事件
    @abstractmethod
    def load_event(self):
        """子类规定自己的事件和动作"""
        pass

    def _to_department(self):
        raise Exception("不允许前往部门审批流程")

    def _to_success(self):
        raise Exception("不允许前往成功审批流程")

    def _to_refuse(self):
        raise Exception("不允许拒绝审批流程")

    def _to_group(self):
        raise Exception("不允许前往小组审批流程")

    @abstractmethod
    def get_current_state(self):
        """获取当前状态"""
        pass

上面的状态基类中，主要完成了以下几件事：

• 通过load_event方法定义具体状态子类允许转移的状态类模板。
• 通过switch方法定义不同状态之间转移时需要具体实现的事件及动作的模板。

状态子类

在具体的状态子类中，我们需要实现小组审批、部门审批，审批拒绝、审批成功这四种具体的状态类：

class Status(Enum):
    group = "group"
    department = "department"
    success = "success"
    refuse = "refuse"


# 小组状态
class GroupState(State):
    Allow = [
        Status.department.value,
        Status.refuse.value
    ]

    def load_event(self):
        self._event = {
            Status.department.value: self._to_department,
            Status.refuse.value: self._to_refuse
        }

    def _to_department(self):
        print("审批通过，流程到了department。")

    def _to_refuse(self):
        print("审批拒绝，流程被拒绝。")

    def get_current_state(self):
        return Status.group.value


# 部门状态
class DepartmentState(State):
    Allow = [
        Status.group.value,
        Status.refuse.value,
        Status.success.value
    ]

    def load_event(self):
        self._event = {
            Status.group.value: self._to_group,
            Status.success.value: self._to_success,
            Status.refuse.value: self._to_refuse
        }

    def _to_group(self):
        print("审批通过，流程到了group。")

    def _to_refuse(self):
        print("审批拒绝，流程被拒绝。")

    def _to_success(self):
        print("审批通过，流程执行成功。")

    def get_current_state(self):
        return Status.department.value


# 成功状态
class SuccessState(State):
    Allow = []

    def load_event(self):
        pass

    def get_current_state(self):
        return Status.success.value


# 拒绝状态
class RefuseState(State):
    Allow = []

    def load_event(self):
        pass

    def get_current_state(self):
        return Status.refuse.value

上面的状态具体类中，主要实现了以下功能：

• Allow是一个列表，规定了某个具体的状态类可以流转的状态，比如小组状态类GroupState，只允许流转到部门状态类或者拒绝状态类。
• Status是一个枚举类，定义了总共有哪些状态具体类，限定了子类的范围。
• 成功状态类SuccessState和拒绝状态类RefuseState必须作为最后的结束状态，不能再流转为其它状态，所以Allow为空。

请求调用类

class Flow:
    def __init__(self, state):
        self.current_state = state
        self.state_chain = [state]
        self.flow_str = state.get_current_state() + " ---> "

    def run(self, to):
        self.current_state.switch(to)

        self.current_state = to
        self.state_chain.append(to)

        self.add_flow(to)

    def add_flow(self, to):
        self.flow_str += (to.get_current_state() + " ---> ")

    def get_flow(self):
        print(self.flow_str)

    def end(self):
        self.flow_str += "end"

在请求调用类Flow中，使用current_state维护当前状态，并且通过run方法实现状态之间的流转管理，封装了具体的状态子类细节。

具体使用

group = GroupState()
department = DepartmentState()
success = SuccessState()

# 创建一个流程，从小组开始
flow = Flow(group)
flow.get_flow()

# 流转到部门
flow.run(department)
flow.get_flow()

# 流转到成功
flow.run(success)
# 结束审批流程
flow.end()
flow.get_flow()


# 输出
group ---> 
审批通过，流程到了department。
group ---> department ---> 
审批通过，流程执行成功。
group ---> department ---> success ---> end

在上面Flow类的调用中，我们通过run方法传入需要流转到的具体状态，即可实现状态之间流转的管理。

mixin方式

当事件与事件触发的动作对于不同的状态来说，都相同或比较相似时，可以采用mixin组合的方式将事件单独拆分出来。
根据这个思路，我们对上面的抽象状态类和状态子类进行重组，使状态和事件解耦。

抽象基类

# ============== #
#    抽象状态基类
# ============== #
class StateNew:
    Allow = []

    def __init__(self):
        self.load_event()

    def switch(self, to):
        """"""
        state = to.get_current_state()

        assert state in self.Allow, "不被允许的状态转移 {} => {}".format(self.__class__.__name__,
                                                                to.__class__.__name__)
        self._event[state]()

    @abstractmethod
    def get_current_state(self):
        """获取当前状态"""
        pass

    # 事件
    @abstractmethod
    def load_event(self):
        """子类规定自己的事件和动作"""
        pass

抽象基类只定义所有状态类都需要实现的最基本功能方法。

mixin类

# ============== #
#    mixin
# ============== #
class ToGroup:
    def _to_group(self):
        print("审批通过，流程到了group。")


class ToDepartment:
    def _to_department(self):
        print("审批通过，流程到了department。")


class ToSuccess:
    def _to_success(self):
        print("审批通过，流程执行成功。")


class ToRefuse:
    def _to_refuse(self):
        print("审批拒绝，流程被拒绝。")

上面的代码中，我们将每种事件都独立了出来，形成单独的mixin类，每个mixin实现单一的事件功能，满足了单一职责和开闭原则，新增和修改都非常方便。

状态子类

# ============== #
#    状态子类
# ============== #
class GroupStateNew(ToDepartment, ToRefuse, StateNew):
    Allow = [
        Status.department.value,
        Status.refuse.value
    ]

    def load_event(self):
        self._event = {
            Status.department.value: self._to_department,
            Status.refuse.value: self._to_refuse
        }

    def get_current_state(self):
        return Status.group.value


class DepartmentStateNew(ToGroup, ToRefuse, ToSuccess, StateNew):
    Allow = [
        Status.group.value,
        Status.refuse.value,
        Status.success.value
    ]

    def load_event(self):
        self._event = {
            Status.group.value: self._to_group,
            Status.success.value: self._to_success,
            Status.refuse.value: self._to_refuse
        }

    def get_current_state(self):
        return Status.department.value


class SuccessStateNew(StateNew):

    def get_current_state(self):
        return Status.success.value

    def load_event(self):
        pass


class RefuseStateNew(StateNew):

    def get_current_state(self):
        return Status.refuse.value

    def load_event(self):
        pass

python支持多继承的方式，于是我们采取 mixin组合 + 抽象父类的方式，某个子类需要实现什么事件，就继承相关的mixin类，不需要实现额外不需要的事件，并且结构更加清晰。

在使用上，跟原来的方式差不多，只需要将具体的状态子类替换一下即可。

# group = GroupState()
# department = DepartmentState()
# success = SuccessState()

group = GroupStateNew()
department = DepartmentStateNew()
success = SuccessStateNew()

优缺点

优点

1. 封装了具体的状态类，及状态转换的规则，分摊了复杂性。
2. 方便扩展新的具体状态类，对原来的类改动很小。
3. 减少了大量分支和判断语句的逻辑，使逻辑更加清晰易于维护。
4. 可读性强，状态模式将每个状态的行为封装到对应的一个类中，能很容易看出功能实现的方式。

缺点

1. 每新增一种状态，都需要新增一个具体状态类，导致类的数目较多。
2. 新增的类，需要维护与原有状态之间的关系，依赖关系变复杂。

应用场景

当一个事件或者对象有很多种状态，状态之间会相互转换，对不同的状态要求有不同的行为的时候，可以考虑使用状态模式。