行为型设计模式之不常用模式剖析：拨开迷雾见本质，智取真知灼见！

2023-11-05 19:11:31

不常用行为型设计模式：揭开它们的价值

在设计模式的世界中，策略模式、观察者模式等常用模式往往备受瞩目。然而，行为型设计模式中还有一群鲜为人知的模式，却蕴藏着不容小觑的价值。让我们踏上一段探索之旅，深入剖析这些不常用模式，发掘它们的精髓。

策略模式：动态切换，拥抱灵活性

想象你正准备进行一场精彩的比赛，却发现规则在比赛中途发生了改变。这时，策略模式就会派上用场。它允许你在运行时动态切换不同的算法或行为，就像更换比赛中的策略一样。通过将算法的实现与选择分离，你可以轻松适应不断变化的需求，而无需修改客户端代码。

代码示例：

class Context:
    def __init__(self, strategy):
        self.strategy = strategy

    def execute(self):
        return self.strategy.execute()

class ConcreteStrategyA:
    def execute(self):
        return "策略A执行"

class ConcreteStrategyB:
    def execute(self):
        return "策略B执行"

context = Context(ConcreteStrategyA())
print(context.execute())  # 输出: "策略A执行"

context.strategy = ConcreteStrategyB()
print(context.execute())  # 输出: "策略B执行"

命令模式：封装行为，解耦请求

就像一位将军向士兵下达指令，命令模式让你将请求封装成独立的对象，实现请求发送者和执行者的解耦。这种模式特别适合需要记录、重做或撤销操作的场景。它可以使代码更加模块化和可测试，同时提高可维护性。

代码示例：

class Command:
    def execute(self):
        pass

class ConcreteCommand(Command):
    def __init__(self, receiver):
        self.receiver = receiver

    def execute(self):
        self.receiver.action()

class Receiver:
    def action(self):
        print("执行动作")

command = ConcreteCommand(Receiver())
command.execute()  # 输出: "执行动作"

迭代器模式：优雅遍历，洞悉集合

想象你有一大堆杂物，需要一项一项地清理。迭代器模式就像一个向导，提供了一种统一的方式遍历集合中的元素，而无需关注集合的具体实现。它让你轻松遍历不同的集合，同时避免修改客户端代码。

代码示例：

class Iterator:
    def __init__(self, collection):
        self.collection = collection
        self.index = 0

    def next(self):
        if self.index < len(self.collection):
            item = self.collection[self.index]
            self.index += 1
            return item
        else:
            raise StopIteration

class ConcreteIterator(Iterator):
    def __init__(self, collection):
        super().__init__(collection)

class Collection:
    def __init__(self, items):
        self.items = items

    def create_iterator(self):
        return ConcreteIterator(self.items)

collection = Collection(['a', 'b', 'c'])
iterator = collection.create_iterator()
for item in iterator:
    print(item)  # 输出: "a", "b", "c"

观察者模式：发布订阅，信息共享

当多个对象密切相关，需要共享信息时，观察者模式就会大显身手。它定义了一种一对多的依赖关系，当发布者对象发生状态改变时，订阅者对象会立即收到通知并做出相应反应。这种模式使系统松散耦合，提高可扩展性和灵活性。

代码示例：

class Subject:
    def __init__(self):
        self.observers = []

    def attach(self, observer):
        self.observers.append(observer)

    def detach(self, observer):
        self.observers.remove(observer)

    def notify(self):
        for observer in self.observers:
            observer.update(self)

class Observer:
    def __init__(self, subject):
        self.subject = subject
        self.subject.attach(self)

    def update(self, subject):
        print(f"{self.__class__.__name__} 收到通知，主题状态为 {subject.state}")

subject = Subject()
observer1 = Observer(subject)
observer2 = Observer(subject)
subject.state = "新的状态"
subject.notify()  # 输出: "Observer1 收到通知，主题状态为 新的状态", "Observer2 收到通知，主题状态为 新的状态"

责任链模式：逐级处理，分担压力

责任链模式就像一个排队系统，当一个请求到来时，它会逐级传递给一系列处理者，直到有一个处理者能够处理该请求。这种模式可以使系统更加模块化和可扩展，同时提高性能和可靠性。

代码示例：

class Handler:
    def __init__(self, successor=None):
        self.successor = successor

    def handle(self, request):
        if self.can_handle(request):
            return self.handle_request(request)
        else:
            if self.successor:
                return self.successor.handle(request)
            else:
                raise Exception("无法处理请求")

class ConcreteHandler1(Handler):
    def can_handle(self, request):
        return request < 10

    def handle_request(self, request):
        return f"ConcreteHandler1 处理了请求 {request}"

class ConcreteHandler2(Handler):
    def can_handle(self, request):
        return request >= 10 and request < 20

    def handle_request(self, request):
        return f"ConcreteHandler2 处理了请求 {request}"

handler1 = ConcreteHandler1(ConcreteHandler2())
print(handler1.handle(5))  # 输出: "ConcreteHandler1 处理了请求 5"
print(handler1.handle(15))  # 输出: "ConcreteHandler2 处理了请求 15"