Python 实现命令模式、中介者模式和解释器模式-51CTO.COM

今天介绍三种行为型设计模式：命令模式、中介者模式和解释器模式。

1.命令模式

它将请求封装成一个对象，从而使得可以用不同的请求对客户进行参数化。命令模式也支持撤销操作。

(1) 命令模式的结构

命令模式的核心是命令对象和接收者对象之间的关系。命令对象封装了一个特定的请求，包含了执行该请求的方法。接收者对象负责实际执行请求。

以下是命令模式的基本结构：

# 命令对象接口
class Command:
    def execute(self):
        pass

    def undo(self):
        pass

# 具体命令对象类
class ConcreteCommandA(Command):
    def __init__(self, receiver):
        self.receiver = receiver

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

    def undo(self):
        self.receiver.undo_action_a()

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

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

    def undo(self):
        self.receiver.undo_action_b()

# 接收者对象类
class Receiver:
    def action_a(self):
        print("接收者执行动作A")

    def action_b(self):
        print("接收者执行动作B")

    def undo_action_a(self):
        print("接收者撤销动作A")

    def undo_action_b(self):
        print("接收者撤销动作B")

# 客户端代码
if __name__ == "__main__":
    receiver = Receiver()
    command_a = ConcreteCommandA(receiver)
    command_b = ConcreteCommandB(receiver)

    invoker = Invoker()
    invoker.set_command(command_a)
    invoker.execute_command()

    invoker.set_command(command_b)
    invoker.execute_command()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.

(2) 命令模式的应用场景

命令模式适用于以下场景：

需要将请求的发送者和接收者解耦，使得它们可以独立地变化。
需要支持撤销操作。

(3) 命令模式的优点

命令模式将请求的发送者和接收者解耦，使得它们可以独立地变化。
命令模式支持撤销操作。
命令模式遵循开闭原则，新的命令对象可以很容易地添加到系统中，而不会影响到原有的代码。

(4) 命令模式的缺点

命令模式中，命令对象和接收者对象之间存在循环依赖的关系，可能会导致循环引用的问题。

2.中介者模式

它通过封装一系列对象之间的交互，将对象之间的耦合度降低到最低。中介者模式将对象之间的交互转移给中介者对象，从而使得对象之间不再直接相互引用。

(1) 中介者模式的结构

中介者模式的核心是中介者对象，它封装了一系列对象之间的交互逻辑。中介者对象通常包含一个或多个接口，用于与其他对象进行通信。

以下是中介者模式的基本结构：

# 中介者接口
class Mediator:
    def send(self, message, colleague):
        pass

# 同事类接口
class Colleague:
    def set_mediator(self, mediator):
        pass

    def send(self, message):
        pass

    def receive(self, message):
        pass

# 具体中介者类
class ConcreteMediator(Mediator):
    def __init__(self):
        self.colleague_a = None
        self.colleague_b = None

    def set_colleague_a(self, colleague_a):
        self.colleague_a = colleague_a

    def set_colleague_b(self, colleague_b):
        self.colleague_b = colleague_b

    def send(self, message, colleague):
        if colleague == self.colleague_a:
            self.colleague_b.receive(message)
        elif colleague == self.colleague_b:
            self.colleague_a.receive(message)

# 具体同事类
class ConcreteColleagueA(Colleague):
    def __init__(self, mediator):
        self.mediator = mediator

    def set_mediator(self, mediator):
        self.mediator = mediator

    def send(self, message):
        self.mediator.send(message, self)

    def receive(self, message):
        print("同事A收到消息:", message)

class ConcreteColleagueB(Colleague):
    def __init__(self, mediator):
        self.mediator = mediator

    def set_mediator(self, mediator):
        self.mediator = mediator

    def send(self, message):
        self.mediator.send(message, self)

    def receive(self, message):
        print("同事B收到消息:", message)

# 客户端代码
if __name__ == "__main__":
    mediator = ConcreteMediator()

    colleague_a = ConcreteColleagueA(mediator)
    colleague_b = ConcreteColleagueB(mediator)

    mediator.set_colleague_a(colleague_a)
    mediator.set_colleague_b(colleague_b)

    colleague_a.send("Hello, colleague B!")
    colleague_b.send("Hi, colleague A!")1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.

(2) 中介者模式的应用场景

中介者模式适用于以下场景：

一组对象之间存在复杂的交互关系，导致对象之间的耦合度较高。
要求对象之间的交互逻辑可以灵活地改变，而不需要修改对象之间的引用关系。

(3) 中介者模式的优点

中介者模式将对象之间的交互逻辑封装到中介者对象中，从而使得对象之间的耦合度降低到最低。
中介者模式使得对象之间的交互逻辑可以灵活地改变，而不需要修改对象之间的引用关系。
中介者模式遵循开闭原则，新的同事类可以很容易地添加到系统中，而不会影响到原有的代码。

(4) 中介者模式的缺点

中介者模式中，中介者对象通常需要知道所有的同事类，可能会导致中介者对象的职责过重。

3.解释器模式

它定义了一种语言的文法，并解析相应的语句。解释器模式通过定义语言的文法，将文法中的每个规则映射到一个类，然后通过递归的方式解析语句。

(1) 解释器模式的结构

解释器模式的核心是解释器类，它封装了解释语句的逻辑。解释器类通常包含一个或多个解释方法，用于解释语句的不同部分。

以下是解释器模式的基本结构：

# 抽象表达式类
class AbstractExpression:
    def interpret(self, context):
        pass

# 终结符表达式类
class TerminalExpression(AbstractExpression):
    def interpret(self, context):
        # 解释终结符表达式的逻辑
        pass

# 非终结符表达式类
class NonterminalExpression(AbstractExpression):
    def __init__(self):
        self.expressions = []

    def add_expression(self, expression):
        self.expressions.append(expression)

    def interpret(self, context):
        # 解释非终结符表达式的逻辑
        for expression in self.expressions:
            expression.interpret(context)

# 上下文类
class Context:
    def __init__(self):
        self.input = None
        self.output = None

# 客户端代码
if __name__ == "__main__":
    context = Context()

    # 构建语法树
    expression1 = TerminalExpression()
    expression2 = NonterminalExpression()
    expression3 = TerminalExpression()

    expression2.add_expression(expression1)
    expression2.add_expression(expression3)

    # 解释语句
    expression2.interpret(context)1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.

(2) 解释器模式的应用场景

解释器模式适用于以下场景：

一种语言的文法比较简单，且文法的规则可以通过类来表达。
需要解析和执行一种特定的语言。

(3) 解释器模式的优点

解释器模式将解释语句的逻辑封装到解释器类中，使得解释语句的逻辑可以灵活地改变。
解释器模式遵循开闭原则，新的解释器类可以很容易地添加到系统中，而不会影响到原有的代码。

(4) 解释器模式的缺点

解释器模式中，解释器类通常需要知道所有的语法规则，可能会导致解释器类的职责过重。