Python 實作命令模式、中介者模式和解釋器模式

今天介紹三種行為型設計模式：指令模式、中介者模式、解釋者模式。

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) 解譯器模式的缺點

在解釋器模式中，解釋器類別通常需要知道所有的語法規則，可能會導致解釋器類別的職責過重。

NEWS

Python 實作命令模式、中介者模式和解釋器模式

1.命令模式

2.中介者模式

3.解釋器模式

玩轉Redis！非常強大的Redisson分散式集合，少寫60%程式碼

全光無線星空”照亮津亞電子智能製造之路

Hong Kong

Philippines