代理模式：為其他物件提供一種代理以控制對這個物件的訪問。

在某些情況下，一個物件不適合或者不能直接引用另一個物件，而代理物件可以在客戶端和目標物件之間起到中介的作用。

代理模式分為：

• 靜態代理
• 動態代理

由下面三部分組成：

抽象角色：通過介面或抽象類宣告真實角色實現的業務方法。

代理角色：實現抽象角色，是真實角色的代理，通過真實角色的業務邏輯方法來實現抽象方法，並可以附加自己的操作。

真實角色：實現抽象角色，定義真實角色所要實現的業務邏輯，供代理角色呼叫。

靜態代理

在程式執行前，就已經確定代理類和委託類的關係的代理方式，被稱為靜態代理。

例：小明請律師進行訴訟

訴訟流程可抽象為ILawsuit

類，如下：

import abc
class ILawsuit(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def submit(self):   # 提交申請
        pass
    @abc.abstractmethod
    def burden(self):   # 進行舉證
        pass
    @abc.abstractmethod
    def defend(self):   # 開始辯護
        pass    
    @abc.abstractmethod
    def finish(self):   # 訴訟完成
        pass
 

小明為具體訴訟人，可寫為Litigant類，如下：

class Litigant(ILawsuit):       # 繼承於ILawsuit
    def __init__(self, name):
        self.name = name
    def submit(self):
        print(f'{self.name}申請仲裁！')
    def burden(self):
        print('證據如下：XXXXXX') 
    def defend(self):
        print('辯護過程：XXXXXX')  
    def finish(self):
        print('訴訟結果如下：XXXXXX')     
 

律師可寫為Lawyer類，如下：

class Lawyer(ILawsuit):     # 繼承於ILawsuit
    def __init__(self, litigant):
        self.litigant = litigant    # 具體訴訟人 
    def submit(self):
        self.litigant.submit()
    def burden(self):
        self.litigant.burden()
    def defend(self):
        self.litigant.defend()
    def finish(self):
        self.litigant.finish()

訴訟過程，可表示為：

if __name__ == '__main__':
    xiaoming = Litigant('小明')       
    lawyer = Lawyer(xiaoming)       
    lawyer.submit()     # 律師提交訴訟申請
    lawyer.burden()     # 律師進行舉證
    lawyer.defend()     # 律師替小明辯護
    lawyer.finish()     # 完成訴訟
    
# 輸出結果
小明申請仲裁！
證據如下：XXXXXX
辯護過程：XXXXXX
訴訟結果如下：XXXXXX

靜態代理的優缺點

優點：業務類只需要關注業務邏輯本身，保證了業務類的重用性。

缺點：代理物件的一個介面只服務於一種型別的物件，如果要代理的方法很多，勢必要為每一種方法都進行代理，靜態代理在程式規模稍大時就無法勝任了。

動態代理

代理類在程式執行時建立的代理方式被稱為 動態代理。

也就是說，這種情況下，代理類並不是在程式碼中定義的，而是在執行時根據我們在程式碼中的指示動態生成的。

同樣，我們舉例說明：

通常我們呼叫REST API通常可能是這樣的：

import urllib
import json

def fetch_resource(resource_id):
    opener = urllib.urlopen('http://remote.server/api/resource/' + resource_id)
    if opener.code != 200:
        raise RuntimeError('invalid return code!')
    content = opener.read()
    try:
        return json.loads(content)
    except ValueError:
        return content

對於每一個REST操作，都會有類似的程式碼。差別僅在於API的地址和HTTP method（GET、POST、等）。此時，可以引入一個GetProxy，可以代替我們實現這些繁雜的工作。

import urllib
import json

class GetProxy(object):
    def __getattr__(self, api_path):
        def _rest_fetch(*paras):
            opener = urllib.urlopen('http://remote.server/api/' + api_path + '/' + '/'.join(resource_id))
            if opener.code != 200:
                raise RuntimeError('invalid return code!')
            content = opener.read()
            try:
                return json.loads(content)
            except ValueError:
                return content

        return _rest_fetch

此時，新的呼叫方式如下：

proxy = GetProxy()

# 呼叫API
proxy.user(123) # http://remote.server/api/user/123
proxy.resource('switch', 456) # http://remote.server/api/resource/switch/456

可見，通過動態代理，極大簡化了呼叫過程。

相比於靜態代理， 動態代理的優勢在於可以很方便的對代理類的函式進行統一的處理，而不用修改每個代理類的函式。

參考

http://adolph.cc/15712984956484.html
https://blog.zhangyu.so/python/2016/02/24/design-patterns-of-python-proxy/

相關推薦