2. 程式人生 > >代理模式

代理模式

阿新 • • 發佈：2017-05-21
implement ndt 內部 cti rri 但是 llb void client

概述：

代理模式，提供了對目標對象另外的訪問方式。簡單講在不改變目標對象的提前下，為其添加額外功能以供其他對象使用。而對於開發人員來講，其實就是不改變原有的代碼，對相應功能進行擴展，比如限制對原有代碼的訪問權限，記錄原有代碼的執行時間，對運行過的代碼寫日誌.....

代理模式有靜態代理和動態代理。其關鍵點是，代理對象與目標對象、代理對象是對目標對象的擴展,並調用目標對象。

代理模式的角色：

抽象對象：聲明了目標對象和代理對象的共同接口，這樣一來在任何可以使用目標對象的地方都可以使用代理對象。

目標對象：定義了代理對象所代表的目標對象。

代理對象：代理對象內部含有目標對象的引用，從而可以在任何時候操作目標對象。

一、靜態代理

靜態代理有聚合和繼承兩種實現方式。下面我們以“一只程序猿在寫代碼為例子”，分別為其記錄日誌和時間。

1、繼承實現方式：

//抽象對象：
public interface People {
    public void code();
}
//目標對象
public class Programmer implements People {
    @Override
    public void code() {
        System.out.println("我在寫代碼");
    }
}
//繼承代理  
public class TimeProxy extends
 
 Programmer {
    public void proxy(){
        System.out.println("time Strat");
        super.code();
        System.out.println("time end");
    }
}

此時我們對程序猿的代理進行執行：

public class Client {
    public static void main(String[] args) {
        TimeProxy timpProxty = new TimeProxy();    
        timpProxty.proxy();    
    }
}

輸出結果：

技術分享

這裏代理模式（繼承）就實現了，但這裏有一個問題如果我要先記錄對這只程序猿的行為的時間，然後為他記錄日誌。此時我們的代碼可能是

public class LogAndTimeProxy extends  Programmer {
    public void logAndTimeProxy(){
        System.out.println("time start");
        System.out.println("log start");
        super.code();
    }    
}

但是如果需要先記錄日誌再記錄時間，那此時就要修改原有的代理或者新增代理類，這種做法代碼的實現不靈活。我們應該要做到分別定義一個時間代理，一個日誌代理，不管時間、日誌誰先誰後，都不需要去修改原有的代理或許添加新代理類

2、聚合實現方式： 

//抽象對象：
public interface People {
    public void code();
}
//目標對象
public class Programmer implements People {
    @Override
    public void code() {
        System.out.println("我在寫代碼");
    }
}
//時間代理類（聚合）
public class TimeProxy implements People {
    private People people;
    
    public TimeProxy(People people){
        this.people=people;
    }

    @Override
    public void code() {
        System.out.println("time start");
        people.code();
        System.out.println("time end");
    }
}
//日誌代理類（聚合）
public class LogProxy  implements People {
    private People people;
    
    public LogProxy(People people){
        this.people=people;
    }
    
    @Override
    public void code() {
        System.out.println("logging start");
        people.code();
        System.out.println("logging end");
    }
}
//如果我們要先記錄時間，後記錄日誌實現方式
public class Client {
    public static void main(String[] args) {
        People p = new Programmer();
        TimeProxy timpProxty = new TimeProxy(p);
        LogProxy logProxty = new LogProxy(timpProxty);
        logProxty.code();    
    }
}

執行結果：

技術分享

如果要實現新記錄日誌再記錄時間 

public class Client {
    public static void main(String[] args) {
        People p = new Programmer();
        LogProxy logProxty = new LogProxy(p);    
        TimeProxy timpProxty = new TimeProxy(logProxty);
        timpProxty.code();    
    }
}

結果：

技術分享

這樣就可以不用修改代理類的情況下，更改代理類了。

但這裏有一個問題就是每個代理類要繼承一個接口或者實現一個類。如果一個項目比較大的話，那就需要添加很多的類，一旦接口增加方法,目標對象與代理對象都要維護。工作量會很大。

二、動態代理

動態代理有兩種實現方法，分別是jdk代理和Cglib代理。

Jdk代理主要實現Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)。其中ClassLoader 表示當前目標對象使用的類加載器，Class<?>表示目標對象實現的接口的類型，InvocationHandler 表示事件處理，當執行目標對象是會觸發該方法。

這裏同樣使用“一只程序猿在寫代碼，休息中...”為例子

//抽象對象：
public interface DynamicPeople {
    public void codeing();
    public void doOtherThing(String things);
}
//目標對象
public class DynamicProgrammer implements DynamicPeople {
    @Override
    public void codeing() {
        System.out.println("我在寫代碼...");
    }
    @Override
    public void doOtherThing(String things) {
        System.out.println(things+"...");
    }
}
//動態代理類
public class JdkDynamicProxy {
    public Object object;
    
    public JdkDynamicProxy(Object object){
        this.object=object;
    }

    //獲取一個代理
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(), 
                object.getClass().getInterfaces(), 
                new InvocationHandler(){
                    @Override
                 //這裏proxy表示代理目標，methos表示方法，args表示參數
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {
                        System.out.println("寫日誌");
                        //執行對應的方法
                        Object result =method.invoke(object, args);
                        return result;
                    }                
                });
    }
}

調用程序猿的方法，看看代理效果：

public class DynamicClient {
    public static void main(String[] args) {
        DynamicPeople programmer = new DynamicProgrammer();
        DynamicPeople proxy = (DynamicPeople) new JdkDynamicProxy(programmer).getProxyInstance();
        
        proxy.codeing();
        System.out.println("*************");
        proxy.doOtherThing("休息中");
    }
}

執行結果

技術分享

可見動態代理已經成功了。但這時我們需要實現上面所說的“分別定義一個時間代理，一個日誌代理，不管時間、日誌誰先誰後，都不需要去修改原有的代理或許添加新代理類”。這些我們需要改下newProxyInstance的InvocationHandler。我們分別定義時間處理類DynamicTimeHandler和日誌處理類DynamicLogHandler，兩者都繼承InvocationHandler，代碼如下:

public class DynamicTimeHandler implements InvocationHandler {
    //目標對象
    private Object object;
    public DynamicTimeHandler(Object object){
        this.object=object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {    
        System.out.println("開始時間");
        Object result = method.invoke(object, args);
        return result;
    }
}
public class DynamicLogHandler implements InvocationHandler {
    private Object object;
    public DynamicLogHandler(Object object){
        this.object=object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("開始日誌");
        Object result = method.invoke(object, args);
        return result;
    }
}

修改代理類：

public class JdkDynamicProxy {
    public Object object;
    public InvocationHandler h;
    
    public JdkDynamicProxy(Object object,InvocationHandler h){
        this.object=object;
        this.h = h ;
    }

    //獲取一個代理
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                object.getClass().getClassLoader(), 
                object.getClass().getInterfaces(), 
                h);
    }
}

調用程序猿的方法，看看代理效果 

public class DynamicClient {
    public static void main(String[] args) {
        DynamicPeople programmer = new DynamicProgrammer();
        InvocationHandler time = new DynamicTimeHandler(programmer);
        DynamicPeople timeProxy = (DynamicPeople) new JdkDynamicProxy(programmer,time).getProxyInstance();
        
        InvocationHandler log  = new DynamicLogHandler(timeProxy);
        DynamicPeople logProxy = (DynamicPeople) new JdkDynamicProxy(programmer,log).getProxyInstance();
        
        logProxy.codeing();
        System.out.println("*************");
        logProxy.doOtherThing("休息中");    
    }
}

執行結果：

技術分享

這樣就實現了上面所說的效果了。但jdk的實現限制，就是目標對象必須實現一個接口。這個缺陷，我們用Cglib代理是可以解決的（Cglib在Spring的核心包中）。

這裏我們以“開車去看美女”為例子

//定義一個目標對象汽車類
public class Car {
    public void running(){
        System.out.println("開著汽車...");
    }
    public void doSomething(String things){
        System.out.println("開著汽車"+things);
    }
}
//寫代理方法
public class CglibDynamicProxy implements MethodInterceptor{
    public Object b;
    
    public CglibDynamicProxy(Object b){
        this.b=b;
    }
    
    public Object getProxyInstance(){
        //1.工具類
        Enhancer en = new Enhancer();
        //2.設置父類
        en.setSuperclass(b.getClass());
        //3.設置回調函數
        en.setCallback(this);
        //4.創建子類(代理對象)
        return en.create();

    }

    @Override
    public Object intercept(Object arg0, Method method, Object[] arg2,
            MethodProxy arg3) throws Throwable {
            System.out.println("開始代理...");
            //執行目標對象的方法
            Object returnValue = method.invoke(b, arg2);
            return returnValue;
    }
}

調用方法，看一下執行效果

public class DynamicClient {
    public static void main(String[] args) {
        Car car = new Car();
        Car newCar= (Car) new CglibDynamicProxy(car).getProxyInstance();
        newCar.doSomething("看美女");
        newCar.running();
    }    
}

執行結果

技術分享

對於如何“分別定義一個時間代理，一個日誌代理，不管時間、日誌誰先誰後，都不需要去修改原有的代理或許添加新代理類”還沒研究，等以後補上，O(∩_∩)O

代理模式

相關推薦

設計模式之代理模式

append class copyright ssis pen 事件綁定 video play 模塊 設計模式之代理模式 Aug 12, 2015 代理，顧名思義就是幫助別人做事，GoF 對代理模式的定義如下： 代理模式（Proxy），為其他對象提供一種代理以控制對這個對

java設計模式之代理模式

單擊 [] 部分 空間 快遞公司 存儲 交互 idt encoding 【學習難度：★★★☆☆，使用頻率：★★★★☆】 代理模式是常用的結構型設計模式之一，當無法直接訪問某個對象或訪問某個對象存在困難時可以通過一個代理對象來間接訪問，為了保證客戶端使用的透明性，所訪問的真實

代理模式-Proxy

遠程 對象的訪問 功能 size 增加 pro 訪問 作用 16px 代理模式：為其他對象提供一種代理以控制這個對象的訪問。 　　代理對象起到的作用，可以去掉功能服務或增加額外的服務。 常見代理模式： 　　遠程代理、虛擬代理、保護代理、智能引用代理 靜態代理概念和實現方法方

【java設計模式】代理模式

pro 運行時間 cli .get aggregate stopped clas cnblogs dex 計算類中方法運行時間的幾種方案： Client: 1 package com.tn.proxy; 2 3 public class Client { 4

設計模式—靜態代理模式（聚合與繼承方式比較）

rri 技術分享 ktr sta too div ide rup 增加 一、概述 1.目標：要在Tank的move()方法做時間代理及日誌代理(可以設想以後還要增加很多代理處理)，且代理間的順序可活更換 2.思路： (1)聚合：代理類聚合了被代理類，且代理類及被代理類都實現

代理模式

implement ndt 內部 cti rri 但是 llb void client 概述： 代理模式，提供了對目標對象另外的訪問方式。簡單講在不改變目標對象的提前下，為其添加額外功能以供其他對象使用。而對於開發人員來講，其實就是不改變原有的代碼，對相應功能進行擴展

js30--代理模式

org 對象實例 doctype dtd 電腦 訪問 ... ber javascrip <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd

設計思想與模式之四靜態代理模式

test 創建 靜態代理 pan 代理 對象的訪問 override todo 父類 一 概述 1.什麽是代理模式？ 為了隱藏與保護目標對象，為其他對象提供一個代理以控制對該目標對象的訪問。 2.什麽是靜態代理模式？ 代理模式有兩種： 靜態代理：代理對象固定。 動態代理：

Java靜態代理與動態代理模式的實現

loader 兩個 如何 圖片 ide 相同 catch 規範 png 前言： 在現實生活中，考慮以下的場景:小王打算要去租房，他相中了一個房子，準備去找房東洽談相關事宜。但是房東他很忙，平時上班沒時間，總沒有時間見面，他也沒辦法。後來，房東想了一個辦法，他找到了一個

代理模式（Proxy）

p s log 場景 private span 方法 陌生 機制 特殊 代理模式（Proxy） 代理模式：簡單明了。簡稱代理商，對代理這個詞想必大家都不陌生，現在微信上，幾乎全是各種代理商，哈哈哈。。。不錯。我們的代理模式，也是如此。用java語言來說。就是，替原對象進行一

JavaScript設計模式_03_代理模式

col img 文章 timer argument 設計 jpg 朋友 進行 代理模式是非常常見的模式，比如我們使用的VPN工具，明星的經紀人，都是代理模式的例子。但是，有人會疑問，明明可以直接訪問對象，為什麽中間還要加一個殼呢？這也就說到了代理模式的好處。在我看來，代理模

Java 代理模式

all object 控制 cglib動態代理 per 使用 sets back 概念 代理模式的概念：為其他對象提供一種代理一控制對這個對象的訪問。 應用場景：在開發中一些業務類中方法，除了需求的操作，還需要進行其他的非業務操作。比如提供給app的接口。除

《大話設計模式》——讀後感 （4）為別人做嫁衣？——靜態代理模式（1）

即使 pri 為我 div 結構 apple .cn string 想要 什麽是代理模式： 代理模式結構圖： 直接上代碼： GiveGift接口： package com.sjmx.staticProxy; public interface GiveG

【java項目實戰】代理模式（Proxy Pattern），靜態代理 VS 動態代理

自己 text 好的 trace use 代理 分類 plproxy this 這篇博文，我們主要以類圖和代碼的形式來對照學習一下靜態代理和動態代理。重點解析各自的優缺點。 定義 代理模式（Proxy Pattern）是對象的結構型模式，代理模

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

ride proxy idt object catch 實例化 圖片 null 人在 代理模式：代理是一種常用的設計模式，其目的就是為其他對象提供一個代理以控制對某個對象的訪問。代理類負責為委托類預處理消息，過濾消息並轉發消息，以及進行消息被委托類執行後的後續處理。很多可以

Java的三種代理模式

value 增加方法 三種 原始的 攔截 tro asm 必須 額外 1.代理模式 代理(Proxy)是一種設計模式,提供了對目標對象另外的訪問方式;即通過代理對象訪問目標對象.這樣做的好處是:可以在目標對象實現的基礎上,增強額外的功能操作,即擴展目標對象的功能.這裏使用到

設計模式之代理模式20170724

委托 fin lap zha think 負責 一件事 lose sizeof 結構型設計模式之代理模式: 一、含義 代理模式也叫做委托模式，其定義如下： 為其他對象提供一種代理以控制對這個對象的訪問。 二、代碼說明 1.主要有兩個角色 1)具體主題角色 也叫做委托角色

Java中的代理模式

appt repl 執行 @override lag mit 之前 lac replace 1、什麽是代理模式 代理模式：就是為其他對象提供一種代理以控制對這個對象的訪問。 代理可以在不改動目標對象的基礎上，增加其他額外的功能（擴展功能）。 舉個例子來說明代理的作

&lt;四&gt;讀&lt;&lt;大話設計模式&gt;&gt;之代理模式

flow 編程 運行 應該 nts popu rac gif 通過 代理模式我想大家即便不熟悉也都聽過吧，從字面意思上看就是替別人幹活的，比方代理商。在項目的實際應用中也有非常多地方用到。比方spring通過代理模式生成對象等。 代理模式的書

Head First設計模式之代理模式

collect prot indent margin 虛擬代理 ans sig smart ati 一、定義 定義：為其他對象提供一種代理以控制對這個對象的訪問 在代理模式中，我們創建具有現有對象的對象，以便向外界提供功能接口。 二、結構 代理模式一般會有三個角