1. 程式人生 > >java動態代理中的invoke方法是如何被自動呼叫的

java動態代理中的invoke方法是如何被自動呼叫的

轉載宣告:本文轉載至 zcc_0015的專欄

一、動態代理與靜態代理的區別。 (1)Proxy類的程式碼被固定下來,不會因為業務的逐漸龐大而龐大; (2)可以實現AOP程式設計,這是靜態代理無法實現的; (3)解耦,如果用在web業務下,可以實現資料層和業務層的分離。 (4)動態代理的優勢就是實現無侵入式的程式碼擴充套件。 靜態代理這個模式本身有個大問題,如果類方法數量越來越多的時候,代理類的程式碼量是十分龐大的。所以引入動態代理來解決此類問題

二、動態代理

Java中動態代理的實現,關鍵就是這兩個東西:Proxy、InvocationHandler,下面從InvocationHandler介面中的invoke方法入手,簡單說明一下Java如何實現動態代理的。 
首先,invoke方法的完整形式如下:

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
	method.invoke(obj, args);  
	return null;  
}

首先猜測一下,method是呼叫的方法,即需要執行的方法;args是方法的引數;proxy,這個引數是什麼?以上invoke()方法的實現即是比較標準的形式,我們看到,這裡並沒有用到proxy引數。檢視JDK文件中Proxy的說明,如下:
A method invocation on a proxy instance through one of its proxy interfaces will be dispatched to the invoke method of the instance's invocation handler, 
passing the proxy instance,a java.lang.reflect.Method object identifying the method that was invoked, and an array of type Object containing the arguments.  
由此可以知道以上的猜測是正確的,同時也知道,proxy引數傳遞的即是代理類的例項。

為了方便說明,這裡寫一個簡單的例子來實現動態代理。

 //抽象角色(動態代理只能代理介面)  
public interface Subject {  
      
    public void request();  
}

 //真實角色:實現了Subject的request()方法  
public class RealSubject implements Subject{  
      
    public void request(){  
        System.out.println("From real subject.");  
    }  
} 

    //實現了InvocationHandler  
    public class DynamicSubject implements InvocationHandler  
    {  
        private Object obj;//這是動態代理的好處,被封裝的物件是Object型別,接受任意型別的物件  
      
        public DynamicSubject()  
        {  
        }  
      
        public DynamicSubject(Object obj)  
        {  
            this.obj = obj;  
        }  
      
        //這個方法不是我們顯示的去呼叫  
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable  
        {  
            System.out.println("before calling " + method);  
      
            method.invoke(obj, args);  
      
            System.out.println("after calling " + method);  
      
            return null;  
        }  
      
    }  

    //客戶端:生成代理例項,並呼叫了request()方法  
    public class Client {  
      
        public static void main(String[] args) throws Throwable{  
            // TODO Auto-generated method stub  
      
            Subject rs=new RealSubject();//這裡指定被代理類  
            InvocationHandler ds=new DynamicSubject(rs);  
            Class<?> cls=rs.getClass();  
              
            //以下是一次性生成代理  
              
            Subject subject=(Subject) Proxy.newProxyInstance(  
                    cls.getClassLoader(),cls.getInterfaces(), ds);  
              
            //這裡可以通過執行結果證明subject是Proxy的一個例項,這個例項實現了Subject介面  
            System.out.println(subject instanceof Proxy);  
              
            //這裡可以看出subject的Class類是$Proxy0,這個$Proxy0類繼承了Proxy,實現了Subject介面  
            System.out.println("subject的Class類是:"+subject.getClass().toString());  
              
            System.out.print("subject中的屬性有:");  
              
            Field[] field=subject.getClass().getDeclaredFields();  
            for(Field f:field){  
                System.out.print(f.getName()+", ");  
            }  
              
            System.out.print("\n"+"subject中的方法有:");  
              
            Method[] method=subject.getClass().getDeclaredMethods();  
              
            for(Method m:method){  
                System.out.print(m.getName()+", ");  
            }  
              
            System.out.println("\n"+"subject的父類是:"+subject.getClass().getSuperclass());  
              
            System.out.print("\n"+"subject實現的介面是:");  
              
            Class<?>[] interfaces=subject.getClass().getInterfaces();  
              
            for(Class<?> i:interfaces){  
                System.out.print(i.getName()+", ");  
            }  
      
            System.out.println("\n\n"+"執行結果為:");  
            subject.request();  
        }  
    }  

    執行結果如下:此處省略了包名,***代替  
    true  
    subject的Class類是:class $Proxy0  
    subject中的屬性有:m1, m3, m0, m2,   
    subject中的方法有:request, hashCode, equals, toString,   
    subject的父類是:class java.lang.reflect.Proxy  
    subject實現的介面是:cn.edu.ustc.dynamicproxy.Subject,   
      
    執行結果為:  
    before calling public abstract void ***.Subject.request()  
    From real subject.  
    after calling public abstract void ***.Subject.request()  

PS:這個結果的資訊非常重要,至少對我來說。因為我在動態代理犯暈的根源就在於將上面的subject.request()理解錯了,至少是被表面所迷惑,沒有發現這個subject和Proxy之間的聯絡,一度糾結於最後呼叫的這個request()是怎麼和invoke()聯絡上的,而invoke又是怎麼知道request存在的。其實上面的true和class $Proxy0就能解決很多的疑問,再加上下面將要說的$Proxy0的原始碼,完全可以解決動態代理的疑惑了。

從以上程式碼和結果可以看出,我們並沒有顯示的呼叫invoke()方法,但是這個方法確實執行了。下面就整個的過程進行分析一下:
從Client中的程式碼看,可以從newProxyInstance這個方法作為突破口,我們先來看一下Proxy類中newProxyInstance方法的原始碼:

    public static Object newProxyInstance(ClassLoader loader,  
            Class<?>[] interfaces,  
            InvocationHandler h)  
    throws IllegalArgumentException  
    {  
        if (h == null) {  
            throw new NullPointerException();  
        }  
      
        /* 
         * Look up or generate the designated proxy class. 
         */  
        Class cl = getProxyClass(loader, interfaces);  
      
        /* 
         * Invoke its constructor with the designated invocation handler. 
         */  
        try {  
               /* 
                * Proxy原始碼開始有這樣的定義: 
                * private final static Class[] constructorParams = { InvocationHandler.class }; 
                * cons即是形參為InvocationHandler型別的構造方法 
               */  
            Constructor cons = cl.getConstructor(constructorParams);  
            return (Object) cons.newInstance(new Object[] { h });  
        } catch (NoSuchMethodException e) {  
            throw new InternalError(e.toString());  
        } catch (IllegalAccessException e) {  
            throw new InternalError(e.toString());  
        } catch (InstantiationException e) {  
            throw new InternalError(e.toString());  
        } catch (InvocationTargetException e) {  
            throw new InternalError(e.toString());  
        }  
    }  

Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下幾件事. 
(1)根據引數loader和interfaces呼叫方法 getProxyClass(loader, interfaces)建立代理類$Proxy0.$Proxy0類 實現了interfaces的介面,並繼承了Proxy類. 
(2)例項化$Proxy0並在構造方法中把DynamicSubject傳過去,接著$Proxy0呼叫父類Proxy的構造器,為h賦值,如下:
    class Proxy{  
        InvocationHandler h=null;  
        protected Proxy(InvocationHandler h) {  
            this.h = h;  
        }  
        ...  
    }  

來看一下這個繼承了Proxy的$Proxy0的原始碼:
    public final class $Proxy0 extends Proxy implements Subject {  
        private static Method m1;  
        private static Method m0;  
        private static Method m3;  
        private static Method m2;  
      
        static {  
            try {  
                m1 = Class.forName("java.lang.Object").getMethod("equals",  
                        new Class[] { Class.forName("java.lang.Object") });  
      
                m0 = Class.forName("java.lang.Object").getMethod("hashCode",  
                        new Class[0]);  
      
                m3 = Class.forName("***.RealSubject").getMethod("request",  
                        new Class[0]);  
      
                m2 = Class.forName("java.lang.Object").getMethod("toString",  
                        new Class[0]);  
      
            } catch (NoSuchMethodException nosuchmethodexception) {  
                throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
            } catch (ClassNotFoundException classnotfoundexception) {  
                throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
            }  
        } //static  
      
        public $Proxy0(InvocationHandler invocationhandler) {  
            super(invocationhandler);  
        }  
      
        @Override  
        public final boolean equals(Object obj) {  
            try {  
                return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();  
            } catch (Throwable throwable) {  
                throw new UndeclaredThrowableException(throwable);  
            }  
        }  
      
        @Override  
        public final int hashCode() {  
            try {  
                return ((Integer) super.h.invoke(this, m0, null)).intValue();  
            } catch (Throwable throwable) {  
                throw new UndeclaredThrowableException(throwable);  
            }  
        }  
      
        public final void request() {  
            try {  
                super.h.invoke(this, m3, null);  
                return;  
            } catch (Error e) {  
            } catch (Throwable throwable) {  
                throw new UndeclaredThrowableException(throwable);  
            }  
        }  
      
        @Override  
        public final String toString() {  
            try {  
                return (String) super.h.invoke(this, m2, null);  
            } catch (Throwable throwable) {  
                throw new UndeclaredThrowableException(throwable);  
            }  
        }  
    }  

接著把得到的$Proxy0例項強制轉換成Subject,並將引用賦給subject。當執行subject.request()方法時,就呼叫了$Proxy0類中的request()方法,進而呼叫父類Proxy中的h的invoke()方法.即InvocationHandler.invoke()。 

PS:1、需要說明的一點是,Proxy類中getProxyClass方法返回的是Proxy的Class類。之所以說明,是因為我一開始犯了個低階錯誤,以為返回的是“被代理類的Class類”- -!推薦看一下getProxyClass的原始碼,很長=。= 
        2、從$Proxy0的原始碼可以看出,動態代理類不僅代理了顯示定義的介面中的方法,而且還代理了java的根類Object中的繼承而來的equals()、hashcode()、toString()這三個方法,並且僅此三個方法。 

Q:到現在為止,還有一個疑問,invoke方法中的第一個引數是Proxy的例項(準確說,最終用到的是$Proxy0的例項),但是有什麼用呢?或者說,程式內是怎樣顯示出作用的? 
A:就本人目前的水平看來,這個proxy引數並沒有什麼作用,在整個動態代理機制中,並沒有用到InvocationHandler中invoke方法的proxy引數。而傳入的這個引數實際是代理類的一個例項。我想可能是為了讓程式設計師在invoke方法中使用反射來獲取關於代理類的一些資訊吧。

相關推薦

no