2. 程式人生 > >輕鬆學，Java 中的代理模式及動態代理

輕鬆學，Java 中的代理模式及動態代理

阿新 • • 發佈：2018-12-23

前幾天我寫了《秒懂，Java 註解 （Annotation）你可以這樣學》，因為註解其實算反射技術中的一部分，然後我想了一下，反射技術中還有個常見的概念就是動態代理，於是索性再寫一篇關於動態代理的博文好了。

我們先來分析代理這個詞。

代理

代理是英文 Proxy 翻譯過來的。我們在生活中見到過的代理，大概最常見的就是朋友圈中賣面膜的同學了。

她們從廠家拿貨，然後在朋友圈中宣傳，然後賣給熟人。

這裡寫圖片描述

按理說，顧客可以直接從廠家購買產品，但是現實生活中，很少有這樣的銷售模式。一般都是廠家委託給代理商進行銷售，顧客跟代理商打交道，而不直接與產品實際生產者進行關聯。

所以，代理就有一種中間人的味道。

接下來，我們說說軟體中的代理模式。

代理模式

代理模式是面向物件程式設計中比較常見的設計模式。
這裡寫圖片描述

這是常見代理模式常見的 UML 示意圖。

需要注意的有下面幾點：
1. 使用者只關心介面功能，而不在乎誰提供了功能。上圖中介面是 Subject。
2. 介面真正實現者是上圖的 RealSubject，但是它不與使用者直接接觸，而是通過代理。
3. 代理就是上圖中的 Proxy，由於它實現了 Subject 介面，所以它能夠直接與使用者接觸。
4. 使用者呼叫 Proxy 的時候，Proxy 內部呼叫了 RealSubject。所以，Proxy 是中介者，它可以增強 RealSubject 操作。

如果難於理解的話，我用事例說明好了。值得注意的是，代理可以分為靜態代理和動態代理兩種。先從靜態代理講起。

靜態代理

我們平常去電影院看電影的時候，在電影開始的階段是不是經常會放廣告呢？

電影是電影公司委託給影院進行播放的，但是影院可以在播放電影的時候，產生一些自己的經濟收益，比如賣爆米花、可樂等，然後在影片開始結束時播放一些廣告。

現在用程式碼來進行模擬。

首先得有一個介面，通用的介面是代理模式實現的基礎。這個介面我們命名為 Movie，代表電影播放的能力。


package com.frank.test;

public interface Movie {
    void
 
 play();
}

然後，我們要有一個真正的實現這個 Movie 介面的類，和一個只是實現介面的代理類。

package com.frank.test;

public class RealMovie implements Movie {

    @Override
    public void play() {
        // TODO Auto-generated method stub
        System.out.println("您正在觀看電影 《肖申克的救贖》");
    }

}

這個表示真正的影片。它實現了 Movie 介面，play() 方法呼叫時，影片就開始播放。那麼 Proxy 代理呢？

package com.frank.test;

public class Cinema implements Movie {

    RealMovie movie;

    public Cinema(RealMovie movie) {
        super();
        this.movie = movie;
    }


    @Override
    public void play() {

        guanggao(true);

        movie.play();

        guanggao(false);
    }

    public void guanggao(boolean isStart){
        if ( isStart ) {
            System.out.println("電影馬上開始了，爆米花、可樂、口香糖9.8折，快來買啊！");
        } else {
            System.out.println("電影馬上結束了，爆米花、可樂、口香糖9.8折，買回家吃吧！");
        }
    }

}

Cinema 就是 Proxy 代理物件，它有一個 play() 方法。不過呼叫 play() 方法時，它進行了一些相關利益的處理，那就是廣告。現在，我們編寫測試程式碼。

package com.frank.test;

public class ProxyTest {

    public static void main(String[] args) {

        RealMovie realmovie = new RealMovie();

        Movie movie = new Cinema(realmovie);

        movie.play();

    }

}

然後觀察結果：

電影馬上開始了，爆米花、可樂、口香糖9.8折，快來買啊！
您正在觀看電影 《肖申克的救贖》
電影馬上結束了，爆米花、可樂、口香糖9.8折，買回家吃吧！

現在可以看到，代理模式可以在不修改被代理物件的基礎上，通過擴充套件代理類，進行一些功能的附加與增強。值得注意的是，代理類和被代理類應該共同實現一個介面，或者是共同繼承某個類。

上面介紹的是靜態代理的內容，為什麼叫做靜態呢？因為它的型別是事先預定好的，比如上面程式碼中的 Cinema 這個類。下面要介紹的內容就是動態代理。

動態代理

既然是代理，那麼它與靜態代理的功能與目的是沒有區別的，唯一有區別的就是動態與靜態的差別。

那麼在動態代理的中這個動態體現在什麼地方？

上一節程式碼中 Cinema 類是代理，我們需要手動編寫程式碼讓 Cinema 實現 Movie 介面，而在動態代理中，我們可以讓程式在執行的時候自動在記憶體中建立一個實現 Movie 介面的代理，而不需要去定義 Cinema 這個類。這就是它被稱為動態的原因。

也許概念比較抽象。現在例項說明一下情況。

假設有一個大商場，商場有很多的櫃檯，有一個櫃檯賣茅臺酒。我們進行程式碼的模擬。

package com.frank.test;

public interface SellWine {

     void mainJiu();

}

SellWine 是一個介面，你可以理解它為賣酒的許可證。

package com.frank.test;

public class MaotaiJiu implements SellWine {

    @Override
    public void mainJiu() {
        // TODO Auto-generated method stub
        System.out.println("我賣得是茅臺酒。");

    }

}

然後建立一個類 MaotaiJiu,對的，就是茅臺酒的意思。

我們還需要一個櫃檯來賣酒：

package com.frank.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;


public class GuitaiA implements InvocationHandler {

    private Object pingpai;


    public GuitaiA(Object pingpai) {
        this.pingpai = pingpai;
    }



    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("銷售開始  櫃檯是： "+this.getClass().getSimpleName());
        method.invoke(pingpai, args);
        System.out.println("銷售結束");
        return null;
    }

}

GuitaiA 實現了 InvocationHandler 這個類，這個類是什麼意思呢？大家不要慌張，待會我會解釋。

然後，我們就可以賣酒了。

package com.frank.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();


        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);


        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);

        dynamicProxy.mainJiu();

    }

}

這裡，我們又接觸到了一個新的概念，沒有關係，先別管，先看結果。

銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束

看到沒有，我並沒有像靜態代理那樣為 SellWine 介面實現一個代理類，但最終它仍然實現了相同的功能，這其中的差別，就是之前討論的動態代理所謂“動態”的原因。

動態代理語法

放輕鬆，下面我們開始講解語法，語法非常簡單。

動態程式碼涉及了一個非常重要的類 Proxy。正是通過 Proxy 的靜態方法 newProxyInstance 才會動態建立代理。

Proxy

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

下面講解它的 3 個引數意義。

  • loader 自然是類載入器
  • interfaces 程式碼要用來代理的介面
  • h 一個 InvocationHandler 物件

初學者應該對於 InvocationHandler 很陌生，我馬上就講到這一塊。

InvocationHandler

InvocationHandler 是一個介面，官方文件解釋說，每個代理的例項都有一個與之關聯的 InvocationHandler 實現類，如果代理的方法被呼叫，那麼代理便會通知和轉發給內部的 InvocationHandler 實現類，由它決定處理。 

public interface InvocationHandler {

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

InvocationHandler 內部只是一個 invoke() 方法，正是這個方法決定了怎麼樣處理代理傳遞過來的方法呼叫。

  • proxy 代理物件
  • method 代理物件呼叫的方法
  • args 呼叫的方法中的引數

因為，Proxy 動態產生的代理會呼叫 InvocationHandler 實現類，所以 InvocationHandler 是實際執行者。

public class GuitaiA implements InvocationHandler {

    private Object pingpai;


    public GuitaiA(Object pingpai) {
        this.pingpai = pingpai;
    }



    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("銷售開始  櫃檯是： "+this.getClass().getSimpleName());
        method.invoke(pingpai, args);
        System.out.println("銷售結束");
        return null;
    }

}

GuitaiA 就是實際上賣酒的地方。

現在，我們加大難度，我們不僅要賣茅臺酒，還想賣五糧液。

package com.frank.test;

public class Wuliangye implements SellWine {

    @Override
    public void mainJiu() {
        // TODO Auto-generated method stub
        System.out.println("我賣得是五糧液。");

    }

}

Wuliangye 這個類也實現了 SellWine 這個介面，說明它也擁有賣酒的許可證，同樣把它放到 GuitaiA 上售賣。

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();

        Wuliangye wu = new Wuliangye();

        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
        InvocationHandler jingxiao2 = new GuitaiA(wu);

        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);
        SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao2);

        dynamicProxy.mainJiu();

        dynamicProxy1.mainJiu();

    }

}

我們來看結果：

銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束
銷售開始  櫃檯是： GuitaiA
我賣得是五糧液。
銷售結束

有人會問，dynamicProxy 和 dynamicProxy1 什麼區別沒有？他們都是動態產生的代理，都是售貨員，都擁有賣酒的技術證書。

我現在擴大商場的經營，除了賣酒之外，還要賣煙。

首先，同樣要建立一個介面，作為賣煙的許可證。

package com.frank.test;

public interface SellCigarette {
    void sell();
}

然後，賣什麼煙呢？我是湖南人，那就芙蓉王好了。 

public class Furongwang implements SellCigarette {

    @Override
    public void sell() {
        // TODO Auto-generated method stub
        System.out.println("售賣的是正宗的芙蓉王，可以掃描條形碼查證。");
    }

}

然後再次測試驗證：

package com.frank.test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();

        Wuliangye wu = new Wuliangye();

        Furongwang fu = new Furongwang();

        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
        InvocationHandler jingxiao2 = new GuitaiA(wu);

        InvocationHandler jingxiao3 = new GuitaiA(fu);

        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);
        SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao2);

        dynamicProxy.mainJiu();

        dynamicProxy1.mainJiu();

        SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(Furongwang.class.getClassLoader(),
                Furongwang.class.getInterfaces(), jingxiao3);

        dynamicProxy3.sell();

    }

}

然後，檢視結果：

銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束
銷售開始  櫃檯是： GuitaiA
我賣得是五糧液。
銷售結束
銷售開始  櫃檯是： GuitaiA
售賣的是正宗的芙蓉王，可以掃描條形碼查證。
銷售結束

結果符合預期。大家仔細觀察一下程式碼，同樣是通過 Proxy.newProxyInstance() 方法，卻產生了 SellWine 和 SellCigarette 兩種介面的實現類代理，這就是動態代理的魔力。

動態代理的祕密

一定有同學對於為什麼 Proxy 能夠動態產生不同介面型別的代理感興趣，我的猜測是肯定通過傳入進去的介面然後通過反射動態生成了一個介面例項。
比如 SellWine 是一個介面，那麼 Proxy.newProxyInstance() 內部肯定會有


new SellWine();

這樣相同作用的程式碼，不過它是通過反射機制建立的。那麼事實是不是這樣子呢？直接檢視它們的原始碼好了。需要說明的是，我當前檢視的原始碼是 1.8 版本。

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();


        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {


            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }

            return cons.newInstance(new Object[]{h});

        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

newProxyInstance 的確建立了一個例項，它是通過 cl 這個 Class 檔案的構造方法反射生成。cl 由 getProxyClass0() 方法獲取。 

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}

直接通過快取獲取，如果獲取不到，註釋說會通過 ProxyClassFactory 生成。 

/**
     * A factory function that generates, defines and returns the proxy class given
     * the ClassLoader and array of interfaces.
     */
    private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // Proxy class 的字首是 “$Proxy”，
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

這個類的註釋說，通過指定的 ClassLoader 和 介面陣列 用工廠方法生成 proxy class。 然後這個 proxy class 的名字是：


// Proxy class 的字首是 “$Proxy”，
private static final String proxyClassNamePrefix = "$Proxy";

long num = nextUniqueNumber.getAndIncrement();

String proxyName = proxyPkg + proxyClassNamePrefix + num;

所以，動態生成的代理類名稱是包名+$Proxy+id序號。

生成的過程，核心程式碼如下：

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);


return defineClass0(loader, proxyName,
                    proxyClassFile, 0, proxyClassFile.length);

這兩個方法，我沒有繼續追蹤下去，defineClass0() 甚至是一個 native 方法。我們只要知道，動態建立代理這回事就好了。

現在我們還需要做一些驗證，我要檢測一下動態生成的代理類的名字是不是包名+$Proxy+id序號。

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        MaotaiJiu maotaijiu = new MaotaiJiu();

        Wuliangye wu = new Wuliangye();

        Furongwang fu = new Furongwang();

        InvocationHandler jingxiao1 = new GuitaiA(maotaijiu);
        InvocationHandler jingxiao2 = new GuitaiA(wu);

        InvocationHandler jingxiao3 = new GuitaiA(fu);

        SellWine dynamicProxy = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao1);
        SellWine dynamicProxy1 = (SellWine) Proxy.newProxyInstance(MaotaiJiu.class.getClassLoader(),
                MaotaiJiu.class.getInterfaces(), jingxiao2);

        dynamicProxy.mainJiu();

        dynamicProxy1.mainJiu();

        SellCigarette dynamicProxy3 = (SellCigarette) Proxy.newProxyInstance(Furongwang.class.getClassLoader(),
                Furongwang.class.getInterfaces(), jingxiao3);

        dynamicProxy3.sell();

        System.out.println("dynamicProxy class name:"+dynamicProxy.getClass().getName());
        System.out.println("dynamicProxy1 class name:"+dynamicProxy1.getClass().getName());
        System.out.println("dynamicProxy3 class name:"+dynamicProxy3.getClass().getName());

    }

}

結果如下：

銷售開始  櫃檯是： GuitaiA
我賣得是茅臺酒。
銷售結束
銷售開始  櫃檯是： GuitaiA
我賣得是五糧液。
銷售結束
銷售開始  櫃檯是： GuitaiA
售賣的是正宗的芙蓉王，可以掃描條形碼查證。
銷售結束

dynamicProxy class name:com.sun.proxy.$Proxy0
dynamicProxy1 class name:com.sun.proxy.$Proxy0
dynamicProxy3 class name:com.sun.proxy.$Proxy1

SellWine 介面的代理類名是：com.sun.proxy.$Proxy0
SellCigarette 介面的代理類名是：com.sun.proxy.$Proxy1

這說明動態生成的 proxy class 與 Proxy 這個類同一個包。

下面用一張圖讓大家記住動態代理涉及到的角色。
這裡寫圖片描述
紅框中 $Proxy0 就是通過 Proxy 動態生成的。
$Proxy0 實現了要代理的介面。
$Proxy0 通過呼叫 InvocationHandler 來執行任務。

代理的作用

可能有同學會問，已經學習了代理的知識，但是，它們有什麼用呢？

主要作用，還是在不修改被代理物件的原始碼上，進行功能的增強。

這在 AOP 面向切面程式設計領域經常見。

在軟體業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。

主要功能
日誌記錄，效能統計，安全控制，事務處理，異常處理等等。

上面的引用是百度百科對於 AOP 的解釋，至於，如何通過代理來進行日誌記錄功能、效能統計等等，這個大家可以參考 AOP 的相關原始碼，然後仔細琢磨。

同註解一樣，很多同學可能會有疑惑，我什麼時候用代理呢？

這取決於你自己想幹什麼。你已經學會了語法了，其他的看業務需求。對於實現日誌記錄功能的框架來說，正合適。

至此，靜態代理和動態代理者講完了。

總結

  1. 代理分為靜態代理和動態代理兩種。
  2. 靜態代理，代理類需要自己編寫程式碼寫成。
  3. 動態代理，代理類通過 Proxy.newInstance() 方法生成。
  4. 不管是靜態代理還是動態代理，代理與被代理者都要實現兩樣介面，它們的實質是面向介面程式設計。
  5. 靜態代理和動態代理的區別是在於要不要開發者自己定義 Proxy 類。
  6. 動態代理通過 Proxy 動態生成 proxy class，但是它也指定了一個 InvocationHandler 的實現類。
  7. 代理模式本質上的目的是為了增強現有程式碼的功能。

這裡寫圖片描述

相關推薦

輕鬆學，Java 中的代理模式及動態代理

前幾天我寫了《秒懂，Java 註解 （Annotation）你可以這樣學》，因為註解其實算反射技術中的一部分，然後我想了一下，反射技術中還有個常見的概念就是動態代理，於是索性再寫一篇關於動態代理的博文好了。 我們先來分析代理這個詞。 代理 代理是英

輕鬆學，Java 中的代理模式（proxy）及動態代理

我們先來分析代理這個詞。 代理 代理是英文 Proxy 翻譯過來的。我們在生活中見到過的代理，大概最常見的就是朋友圈中賣面膜的同學了。 她們從廠家拿貨，然後在朋友圈中宣傳，然後賣給熟人。 按理說，顧客可以直接從廠家購買產品，但是現實生活中，很少有

輕松學Java 中的代理模式及動態代理

false spec 軟件 類名 提高 UNC factor targe AMM 前幾天我寫了《秒懂，Java 註解 （Annotation）你可以這樣學》，因為註解其實算反射技術中的一部分，然後我想了一下，反射技術中還有個常見的概念就是動態代理，於是索性再寫一篇關於動態代

Java 中的代理模式及動態代理

代理 代理是英文 Proxy 翻譯過來的。我們在生活中見到過的代理，大概最常見的就是朋友圈中賣面膜的同學了。 她們從廠家拿貨，然後在朋友圈中宣傳，然後賣給熟人。 按理說，顧客可以直接從廠家購買產品，但是現實生活中，很少有這樣的銷售模式。一般都是廠家委託給代理商進行銷

Java 代理模式及動態代理

代理 代理是英文 Proxy 翻譯過來的。我們在生活中見到過的代理，大概最常見的就是朋友圈中賣面膜的同學了。 她們從廠家拿貨，然後在朋友圈中宣傳，然後賣給熟人。 按理說，顧客可以直接從廠家購買產品，但是現實生活中，很少有這樣的銷售模式。一般都是廠家委託給代理商

Java設計模式---代理模式(二)---動態代理

動態代理 動態代理和代理模式實質是一樣的，只是要更加靈活。 代理模式請見本部落格另一篇文章 ”Java設計模式---代理模式(一)“ 例、 房東介面： package cn.hncu.pool.day2.proxy.demo1; public interf

Java設計模式之代理模式的動態代理

前言 什麼是動態代理呢？動態代理指的是在實現階段不需要關心代理誰，而是在執行階段才指定哪一個物件。   動態代理示例 首先要介紹一下JDK提供的一個動態代理介面 InvocationHandler。這個介面的用途在於對代理類的方法進行代理，我們先實現InvocationHandle

Java設計模式之代理模式的動態代理下篇

前言 上篇我們演示了使用JDK的InvocationHandler實現動態代理，本文我們採用cglib來實現動態代理。   動態代理示例 運用JDK的InvocationHandler是根據抽象介面來實現的，然而基於cglib來實現動態代理，被代理角色可以是一個普通的類，也可以是一個介面的實

25（java中的反射和動態代理）

1 概述 反射獲取的都是class物件，以下是在不同的階段獲取物件的方式。 2 原始檔階段class物件的作用 可以利用全類名創造物件，具體程式碼為： 3 class物件獲取類中的欄位（即成員變數） 註釋：通過Class.forName()獲取到了Pe

Java代理模式之動態代理

    代理模式是設計模式中非常重要的一種型別。代理模式從型別上來說，可以分為靜態代理和動態代理兩種型別。     假設一個場景，有一個蛋糕店，賣的蛋糕都是用蛋糕機做的，而且不同種類的蛋糕由不同的蛋糕機來做，有水果蛋糕機，巧克力蛋糕機等。它們賣的麵包片也是麵包機做的，不同種

JAVA中的JDK的動態代理

在java的動態代理機制中，有兩個重要的類或介面，一個是 InvocationHandler(Interface)、另一個則是 Proxy(Class) 當我們通過代理物件呼叫一個方法的時候，這個方法的呼叫就會被轉發為由InvocationHandler這個介面的 invoke 方法來進行呼叫。

java代理模式和動態代理

1.代理模式 為什麼使用代理模式？ 當處理實際的業務邏輯之前或者之後，想要處理一些別的事。比如吃飯是我真實要做的事情，但是在吃飯之前我必須要做飯，之後必須要洗碗。 做飯洗碗可以讓別人代做。 吃飯介面 package com.wch.api; public i

Java設計模式-代理模式之動態代理(附原始碼分析)

具體有如下四步驟： 通過實現 InvocationHandler 介面建立自己的呼叫處理器；通過為 Proxy 類指定 ClassLoader 物件和一組 interface 來建立動態代理類；通過反射機制獲得動態代理類的建構函式，其唯一引數型別是呼叫處理器介面型別；通過建構函式建立動態代理類例項，構造時

Java的三種代理模式(Spring動態代理物件)

Java的三種代理模式 1.代理模式 代理(Proxy)是一種設計模式,提供了對目標物件另外的訪問方式;即通過代理物件訪問目標物件.這樣做的好處是:可以在目標物件實現的基礎上,增強額外的功能操作,即擴充套件目標物件的功能. 這裡使用到程式設計中的一個思想

java設計模式之代理模式（動態代理）

  今天給大家分享的是java設計模式之代理模式中的動態代理模式。如有不足，敬請指正。   我們上次說到靜態代理使用一個代理類

設計模式_代理模式_動態代理

ride new http devel override 主題 引入 一個 技術 轉自：https://www.ibm.com/developerworks/cn/java/j-lo-proxy-pattern/index.html 動態代理是指在運行時動態生成代理類。即，

設計模式之禪學習筆記09--代理模式（動態代理）

1.動態代理     動態代理還是屬於設計模式--代理模式的一種，代理類在程式執行時建立的代理方式被成為動態代理。動態代理是在實現階段不用關心代理誰，而在執行階段才指定代理哪一個物件。相對來說，自己寫代理類的方式就是靜態代理。現在有一個非常流行的名稱叫做面向橫切面程式設計，也

設計模式--代理模式（動態代理）

代理模式是常用的java設計模式，他的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理訊息等。代理類與委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物件本身並不真正實現服務，而是通過

設計模式之代理模式（動態代理）

概要 設計模式是一門藝術，如果真正瞭解這門藝術，你會發現，世界都將變得更加優美。 簡介 在上一篇已經大概講解了代理模式，相信大家對代理模式有一定的瞭解了，如果沒有 相信大家肯定有收穫，如果有了一定的基礎，那麼在去看，相信理解會更加快，而且非常容易

淺談java中內置的觀察者模式與動態代理的實現

所有 代理 notify play ani effect 一個 indicate protected 一.關於觀察者模式 1.將觀察者與被觀察者分離開來，當被觀察者發生變化時，將通知所有觀察者，觀察者會根據這些變化做出對應的處理。 2.jdk裏已經提供對應的Observer