2. 程式人生 > >Proxy模式(代理[延遲]模式)

Proxy模式(代理[延遲]模式)

阿新 • • 發佈：2018-11-02

Proxy？？

Proxy是“代理人”的意思，它指的是代替別人進行工作的人。代理實際上就是使用委託的機制，在代理的過程中你可以做點其他的事情，然後再來執行被代理物件的程式碼。

  • 知識儲備

1.什麼時候使用：

GoF書（請參見附錄E[GoF]）在講解Proxy模式時，使用了一個可以在文字中嵌入圖形物件（例如圖片等）的文字編輯器作為例子。為了生成這些圖形物件，需要讀取圖片檔案，這很耗費時間。因此如果在開啟文件時就生成有所的圖形物件，就會導致文件開啟時間過長。所以，最好是當用戶瀏覽至文字中各個圖形物件時，再去生成它們的例項。這時，Proxy模式就有了用武之地。

2.有那些代理：

  • Virtual Proxy（虛擬代理）Virtual Proxy就是本章中學習的Proxy模式。只有當真正需要例項時，它才生成和初始化例項。
  • Remote Proxy（遠端代理）Remote Proxy可以讓我們完全不必在意RealSubject角色是否在遠端網路上，可以如同它在自己身邊一樣（透明性地）呼叫它的 方法。Java的RMI（RemoteMethodInvocation：遠端方法呼叫）就相當於Remote Proxy。

  • Access Proxy Access Proxy 用於在呼叫RealSubject角色的功能時設定訪問限制。例如，這種代理可以只允許指定的使用者呼叫方法，而當其他使用者呼叫方法時則報錯。

  • 靜態代理
    1.使用委託機制代理人只代理他能解決的問題。當遇到他不能解決的問題時，還是會“轉交”給本人去解決。
    這裡的“轉交”就是在本書中多次提到過的“委託”。從PrinterProxy類的print方法中呼叫real.print方法正是這種“委託”的體現。

  1. 為了實現PrinterProxy類可以從printer類中分離出來作為獨立的元件使用，而且只要是實現了Printable介面的類都可以扮演Proxy的角色。需要使用反射例項

private synchronized void realize(String classname) {
    if(real==null){
        try {
            real = ((Printable) Class.forName(classname).newInstance());
        }catch (ClassNotFoundException e){
            System.out.println("沒有發現"+classname);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
  • 動態代理

在java的動態代理機制中，有兩個重要的類或介面，一個是 InvocationHandler(Interface)、另一個則是 Proxy(Class)，這一個類和介面是實現我們動態代理所必須用到的。首先我們先來看看java的API幫助文件是怎麼樣對這兩個類進行描述的：
InvocationHandler:

InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 

Each proxy instance has an associated invocation handler. When a method is invoked on a proxy instance, the method invocation is encoded and dispatched to the invoke method of its invocation handler.

每一個動態代理類都必須要實現InvocationHandler這個介面，並且每個代理類的例項都關聯到了一個handler，當我們通過代理物件呼叫一個方法的時候，這個方法的呼叫就會被轉發為由InvocationHandler這個介面的 invoke 方法來進行呼叫。我們來看看
InvocationHandler這個介面的唯一一個方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable

我們看到這個方法一共接受三個引數，那麼這三個引數分別代表什麼呢？


Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:　　指代我們所代理的那個真實物件
method:　　指代的是我們所要呼叫真實物件的某個方法的Method物件
args:　　指代的是呼叫真實物件某個方法時接受的引數

理清職責

  • 實現一個帶名字的印表機
    名字=====》》說明
    Printer || 表示帶名字的印表機的類（本人）
    Printable || Printer和PrinterProxy的共同介面
    PrinterProxy || 表示帶名字的印表機的類（代理人）
    Main ||測試程式行為的類

UML

類圖：

時序圖：

Code

  • Printable
public interface Printable {

    // 設定列印名字
    void setPrinterName(String name);

    // 獲取列印名字
    String getPrinterName();

    // 顯示文字
    void print(String string);
}
  • Printer

···
public class Printer implements Printable{
private String name;

public Printer() {
    heavyjob("正在生成Printer例項");
}

public Printer(String name) {
    this.name = name;
    heavyjob("正在生成Printer例項（"+name+"）");
}

/**
 * 模擬一個高負載任務
 * @param string
 */
private void heavyjob(String string) {
    System.out.println(string);
    for (int i = 0; i < 5; i++) {
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.print(".");
    }
}

@Override
public void setPrinterName(String name) {
    this.name=name;
}

@Override
public String getPrinterName() {
    return name;
}

@Override
public void print(String string) {
    System.out.println("==="+name+"===");
    System.out.println(string);
}

}

···

  • PrinterProxy

public class PrinterProxy implements Printable{

    private String name;

    private Printer real;

    /**
     * 不論 setPrinterName 方法和getPrinterName 方法被呼叫多少次，
     * 都不會生成Printer類的例項。只有當真正需要本人時，
     * 才會生成printer類的例項（printerProxy類的呼叫者完全不知道是否生成了本人，也不用在意是否生成了本人）。
     * @param name
     */


    public PrinterProxy(String name) {
        this.name = name;
    }

    @Override
    public synchronized void setPrinterName(String name) {
        if(real!=null){
            real.setPrinterName(name);
        }
        this.name=name;
    }

    @Override
    public String getPrinterName() {
        return name;
    }

    @Override
    public void print(String string) {
            realize();
            real.print(string);
    }

    private synchronized void realize() {
        if(real==null) real=new Printer(name);
    }
}

public class MainT {
    public static void main(String[] args) {

        Printable p=new PrinterProxy("Tom");
        System.out.println("現在是"+p.getPrinterName());
        p.setPrinterName("Cat");
        System.out.println("現在是"+p.getPrinterName());
        p.print("我是 Tomcat");

    }
}
  • 結果：

現在是Tom
現在是Cat
正在生成Printer例項（Cat）
.....
===Cat===
我是 Tomcat

動態代理Code


public class Client {

    public static void main(String[] args) {

        Printable tom = new Printer("Tom");

        DynamicProxy proxy = new DynamicProxy(tom);

        Printable o = (Printable) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),
                tom.getClass().getInterfaces(), proxy);

        System.out.println(o.getClass().getName());

        System.out.println("現在是"+o.getPrinterName());
        o.print("Tomcat");
    }
}




public class DynamicProxy implements InvocationHandler {

    private Object object;

    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("準備執行");

        System.out.println("Method:" + method);

        Object o = method.invoke(object, args);

        System.out.println("執行完畢");
        return o;
    }
}




public interface Printable {

    // 設定列印名字
    void setPrinterName(String name);

    // 獲取列印名字
    String getPrinterName();

    // 顯示文字
    void print(String string);
}



public class Printer implements Printable{
    private String name;

    public Printer() {
        heavyjob("正在生成Printer例項");
    }

    public Printer(String name) {
        this.name = name;
        heavyjob("正在生成Printer例項（"+name+"）");
    }

    /**
     * 模擬一個高負載任務
     * @param string
     */
    private void heavyjob(String string) {
        System.out.println(string);
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            System.out.print(".");
        }
    }

    @Override
    public void setPrinterName(String name) {
        this.name=name;
    }

    @Override
    public String getPrinterName() {
        return name;
    }

    @Override
    public void print(String string) {
        System.out.println("==="+name+"===");
        System.out.println(string);
    }
}

相關推薦

Proxy模式(代理[延遲]模式)

Proxy？？ Proxy是“代理人”的意思，它指的是代替別人進行工作的人。代理實際上就是使用委託的機制，在代理的過程中你可以做點其他的事情，然後再來執行被代理物件的程式碼。 知識儲備 1.什麼時候使用： GoF書（請參見附錄E[GoF]）在講解Proxy模式時，使用了一個可以在文字中嵌入圖

android設計模式——代理者模式

定義：也稱委託模式，為其他物件提供一種代理以控制對這個物件的訪問。 使用場景：有些物件由於某些原因（比如物件建立開銷很大，或者某些操作需要安全控制，或者需要程序外的訪問），直接訪問會給使用者或者系統結構帶來很多麻煩，我們可以在訪問此物件時加上一個對此物件的訪問層。 應用舉例：支票可以當錢的使

java設計模式--代理設計模式

代理模式 特點：兩個子類共同實現一個介面，其中一個子類負責真實業務實現，另外一個子類完成輔助真實業務主題的操作 舉例： 玩遊戲--介面                               買口紅--介面 真實主題類：你                      

Java介面設計模式---代理設計模式

  概念：兩個子類共同實現一個介面，其中一個子類負責真實業務實現，另一個子類完成輔助真實業務主題的操作。 package www.miao.java; interface ISubject{ //核心功能是買電腦 public void bu

java設計模式之代理設計模式（Proxy）

pub 客戶端 clas bject 模式 只需要 java 接口 new 一個簡單Proxy代理模式範例 interface Subject{ //定義核心主題所要完成的功能 public void make(); } class RealSubj

MOOC清華《面向對象程序設計》第8章：用代理模式實現延遲初始化

blank ngx cin www. oci 初始化 lanp margin 程序 Z9閃5PFVL衣坑9http://shequ.docin.com/zdfi78227 哦3O8b4z宦塹7http://huiyi.docin.com/dvok6368 W34搜6csiy

重走Java設計模式——代理模式（Proxy Pattern）

代理模式 定義 為其他物件提供一種代理以控制對這個物件的訪問。 程式碼示例 我們將建立一個Image 介面和實現了 Image 介面的實體類。ProxyImage 是一個代理類，減少 RealImage 物件載入的記憶體佔用。 ProxyPatternDem

用心理解設計模式——代理模式 (Proxy Pattern)

前置文章： 用心理解設計模式——設計模式的原則  設計模式相關程式碼已統一放至 我的 Github   一、定義   結構型模式之一。   Provide a surrogate or placeholder for anothe

設計模式-代理模式(Proxy)

代理模式(Proxy) 定義 : 為其他物件提供一種代理, 以控制對這個物件的訪問 代理物件在客戶端和目標物件之間起到中介的作用 型別 : 結構型 適用場景 保護目標物件 增強目標物件 優點 代理模式能將代理物件與

動態代理模式(概念) / JDK 的 Proxy 動態代理

動態代理模式（泛講）：1. 什麼是動態代理模式？         動態代理模式中的代理類是由工具類或工廠類動態生成的，而不是由程式設計師手工定義的。代理關係是在程式執行過程中確立的。 2. 使用動態代理模式需要注意的幾點：      

設計模式-代理模式（Proxy）

代理模式是構造型模式的一種，它可以為其他物件提供一種代理以控制對這個物件的訪問。 所為代理，是具有與代理元（被代理的物件）(RealSubject)具有相同的介面（Subject）的類。 角色和職責： 1.抽象主題（subject）-Subject：   抽象主題公共介面 2.具體主題（

（38）C#設計模式——代理模式（Proxy Pattern）

引言 在軟體開發過程中，有些物件有時候會由於網路或其他障礙，以至於不能夠或者不能直接訪問到這些物件，如果直接訪問物件給系統帶來不必要的複雜性，這時候可以在客戶端和目標物件之間增加一層中間層，讓代理物件代替目標物件，然後客戶端只需要訪問代理物件，由代理物件去幫我們請求目標物件

詳淡設計模式-代理（Proxy）

文章目錄 代理模式（英語：Proxy Pattern） 1.靜態代理  1.1 繼承  1.2 聚合 2.動態代理  2.1 jdk動態代理

設計模式-代理proxy

類似生活中的代購、中介，為什麼會有他們，因為他們在他們的領域是專業高效的，比起你(呼叫方)自己去直接 呼叫目標類，更高效、解耦。 設計的概念：呼叫者client、目標target、代理proxyTartget 共三個概念 特點：簡單 設計的類很少 代理也分類：靜態代理

設計模式:代理模式(Proxy)

代理模式：為其他物件提供一種代理以控制對這個物件的訪問 僅僅一句話自然是說明不了代理模式是什麼，我們先看看程式碼例子，什麼是代理： 舉一個栗子吧，假設有個人家裡有困難，A同學知道了這個人的情況，想捐點錢給他，但是又想做好事不留名，於是A同學讓B同學幫忙把錢給這個人。 那麼

JDK的Proxy動態代理模式和CGLIB動態代理模式的區別和共同點

首先我們來談談聯眾代理模式的不同之處：《1》代理類不同點：（1）Proxy的代理類的建立是通過工具類或者工廠類自動建立的，   我們只需要呼叫Proxy.newProxyInstance(Loader,interfaces,h);正確的傳入相應的引數，就可以得到餓哦們想要的目

MVP本質上就是一個Proxy靜態代理模式---so easy

什麼是MVP? M就是model資料層，就是承載資料的實體 V就是view介面層，就是展示資料的 P就是Presenter（百度翻譯為提出者; 贈送者）就是從Model中獲取資料並提供給View的層 我們來做一個及其簡單的例子，就是模擬一個插入動作，插入

優雅的表單驗證模式--策略設計模式和ES6的Proxy代理模式

轉載自 作者 @jawil 原文，原文有刪改 網站的互動，離不開表單的提交，而一個健壯的表單離不開對錶單內容的校驗。 假設我們正在編寫一個註冊的頁面，在點選註冊按鈕之前，有如下幾條校驗邏輯。 所有選項不能為空 使用者名稱長度不能少於6位

設計模式——代理(Proxy)

代理模式是一種結構型模式。代理模式給某一物件提供一個代理物件，並且由代理物件控制對原物件的引用。 #代理模式的結構 所謂代理就是由一個代理物件去代替處理目標物件，而處理的邏輯是由代理物件引用並呼叫目標物件進行處理的，也就是最終仍然是目標物件處理相應的邏輯

設計模式 —— 代理模式（Proxy Pattern）

代理模式（Proxy Pattern） 概念： 定義：代理模式 為另一個物件提供一個替身或佔位符以控制這個物件的訪問。 代理模式很好理解，在生活中也很常見。舉個簡單的例子，我們自己能做很多事情（動作），比如寫作業，出去玩等。當我們和父母在家的時候，