行爲型模式 ------ 設計模式第5章

1. 責任鏈模式

       責任鏈模式的內容：使多個對象都有機會處理請求，從而避免請求的發送者和接收者之間的耦合關係。將這些對象連成一條鏈並沿着這條鏈傳遞該請求，直到有一個對象處理它爲止。責任鏈的角色有抽象處理者、具體處理者和客戶端。

from abc import ABCMeta, abstractmethod

# 抽象的處理者
class Handler(metaclass=ABCMeta):
    @abstractmethod
    def handle_leave(self, day):
        pass

# 具體的處理者
class GeneralManager(Handler):
    def handle_leave(self, day):
        if day <= 30:
            print('總經理准假%d' % day)
        else:
            print('可以辭職了！')

# 具體的處理者
class DepartmentManager(Handler):
    def __init__(self):
        self.next = GeneralManager()

    def handle_leave(self, day):
        if day <= 7:
            print('項目主管准假%d' % day)
        else:
            print('部門經理職權不足')
            self.next.handle_leave(day)

# 具體的處理者
class ProjectDirector(Handler):
    def __init__(self):
        self.next = DepartmentManager()

    def handle_leave(self, day):
        if day <= 3:
            print('項目主管准假%d' % day)
        else:
            print('項目主管職權不足')
            self.next.handle_leave(day)

day = 20
p = ProjectDirector()
p.handle_leave(day)
"""
項目主管職權不足
部門經理職權不足
總經理准假20
"""

       使用場景：有多個對象可以處理一個請求，哪個對象處理由運行時決定；在不明確接收者的情況下，向多個對象中的一個提交一個請求。優點是降低耦合度，一個對象無需知道是其它哪一個對象處理其請求。

2. 觀察者模式

       觀察者模式應用比較廣泛，又被稱爲“發佈-訂閱”模式。它用來定義對象間一種一對多的依賴關係，當一個對象的狀態發生變化時，所有依賴它的對象都得到通知並被自動更新。觀察者模式的角色有：抽象主題、具體主題（發佈者）、抽象觀察者和具體觀察者（訂閱者）。

from abc import ABCMeta, abstractmethod

# 抽象的訂閱者
class Observer(metaclass=ABCMeta):
    @abstractmethod
    def update(self, notice):
        """
        :param notice: Notice類的對象
        :return:
        """
        pass

# 抽象的發佈者：可以是接口，子類不需要實現，所以不需要定義抽象方法！
class Notice:
    def __init__(self):
        self.observers = []

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

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

    def notify(self):
        """
        推送
        :return:
        """
        for obs in self.observers:
            obs.update(self)

# 具體的發佈者
class StaffNotice(Notice):
    def __init__(self, company_info):
        super().__init__()  # 調用父類對象聲明observers屬性
        self.__company_info = company_info

    @property
    def company_info(self):
        return self.__company_info

    @company_info.setter
    def company_info(self, info):
        self.__company_info = info
        self.notify()

# 具體的訂閱者
class Staff(Observer):
    def __init__(self):
        self.company_info = None

    def update(self, notice):
        self.company_info = notice.company_info

staff_notice = StaffNotice('初始化公司信息')
staff1 = Staff()
staff2 = Staff()
staff_notice.attach(staff1)
staff_notice.attach(staff2)
# print(staff1.company_info) None
# print(staff2.company_info) None
staff_notice.company_info = '假期放假通知！'
print(staff1.company_info)
print(staff2.company_info)
staff_notice.detach(staff2)
staff_notice.company_info = '明天開會！'
print(staff1.company_info)
print(staff2.company_info)
"""
假期放假通知！
假期放假通知！
明天開會！
假期放假通知！
"""

       使用場景：當一個抽象模型有兩個方面，其中一個方面依賴另一個方面。將這兩者封裝在獨立對象中以使它們可以各自獨立地改變和複用；當對一個對象的改變需要同時改變其它對象，而不知道具體有多少對象待改變；當一個對象必須通知其它對象，而它又不能假定其它對象是誰。換言之，你不希望這些對象是緊耦合的。優點：目標和觀察者之間的抽象耦合最小；支持廣播通信。

3. 策略模式

       定義一個個算法，把它們封裝起來，並且使它們可以相互替換。本模式使得算法可獨立於使用它的客戶而變化。角色有：抽象策略、具體策略和上下文。

from abc import abstractmethod, ABCMeta
from datetime import datetime

# 抽象策略
class Strategy(metaclass=ABCMeta):
    @abstractmethod
    def execute(self, data):
        pass

# 具體策略
class FastStrategy(Strategy):
    def execute(self, data):
        print("使用較快的策略處理%s" % data)

# 具體策略
class SlowStrategy(Strategy):
    def execute(self, data):
        print("使用較慢的策略處理%s" % data)

# 上下文
class Context:
    def __init__(self, strategy, data):
        self.data = data
        self.strategy = strategy
        # 可以定義用戶不知道的東西
        self.date = datetime.now()

    def set_strategy(self, strategy):
        self.strategy = strategy

    def do_strategy(self):
        self.strategy.execute(self.data)

data = "Hello!"
# 使用較快的策略處理
fast_strategy = FastStrategy()
context = Context(fast_strategy, data)
context.do_strategy()
# 使用較慢的策略處理
slow_strategy = SlowStrategy()
context = Context(slow_strategy, data)
context.do_strategy()
"""
使用較快的策略處理Hello!
使用較慢的策略處理Hello!
"""

       優點：定義了一些列可重用的算法和行爲；消除了一些條件語句；可以提供相同行爲的不同實現；缺點：客戶必須瞭解不同的策略。

4. 模板方法模式

       內容：定義一個操作中的算法骨架，將一些步驟延遲到子類中。模板方法使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。使用模板方法，需要用到兩種角色，分別是抽象類和具體類。抽象類的作用是是定義抽象類（鉤子操作），實現一個模板方法作爲算法的骨架。具體類的作用實現原子操作。

from abc import ABCMeta, abstractmethod
from time import sleep

# 抽象類
class Window(metaclass=ABCMeta):
    @abstractmethod
    def start(self):  # 原子操作/鉤子操作
        pass

    @abstractmethod
    def repaint(self):  # 原子操作/鉤子操作
        pass

    @abstractmethod
    def stop(self):  # 原子操作/鉤子操作
        pass

    def run(self):
        """
        模板方法(具體方法)，這個大邏輯就不需要自己寫了
        :return:
        """
        self.start()
        while True:
            try:
                self.repaint()
                sleep(1)
            except KeyboardInterrupt:
                break
        self.stop()

# 具體類
class MyWindow(Window):
    def __init__(self, msg):
        self.msg = msg

    def start(self):
        print('窗口開始運行！')

    def stop(self):
        print('窗口停止運行！')

    def repaint(self):
        print(self.msg)

MyWindow("Hello...").run()

       模板方法適用的場景：一次性實現一個算法的不變部分，各個子類中的公共行爲應該被提取出來並集中到一個公共父類中以避免代碼重複；控制子類擴展。