Java動態代理的實現機制

作者：溫布利往事 2015-09-28 15:59:00

開發后端

代理是一種設計模式，其目的是為其他對象提供一個代理以控制對某個對象的訪問，代理類負責為委托類預處理消息，過濾消息并轉發消息以及進行消息被委托類執行后的后續處理。為了保持行為的一致性，代理類和委托類通常會實現相同的接口。

一、概述

　　按照代理的創建時期，代理類可分為兩種：

靜態代理：由程序員創建代理類或特定工具自動生成源代碼再對其編譯，也就是說在程序運行前代理類的.class文件就已經存在。
動態代理：在程序運行時運用反射機制動態創建生成。

　　下面在將動態代理的實現機制之前先簡單介紹一下靜態代理。

二、靜態代理

　　上面說過，代理類和委托類一般都要實現相同的接口，下面先定義這個接口：

public interface Service 
{     
    public void add(); 
}

　　委托類作為接口的一種實現，定義如下：

public class ServiceImpl implements Service 
{ 
    public void add() 
    { 
        System.out.println("添加用戶！"); 
         
    } 
}

　　假如我們要對委托類加一些日志的操作，代理類可做如下定義：

public class ServiceProxy implements Service 
{ 
    private Service service; 
    public ServiceProxy(Service service) 
    { 
        super(); 
        this.service = service; 
    } 
    public void add() 
    { 
        System.out.println("服務開始"); 
        service.add(); 
        System.out.println("服務結束"); 
    } 
}

　　編寫測試類：

public class TestMain 
{ 
    public static void main(String[] args) 
    { 
        Service serviceImpl=new ServiceImpl(); 
        Service proxy=new ServiceProxy(serviceImpl); 
        proxy.add(); 
    } 
}

　　運行測試程序，結果如下圖：

　　從上面的代碼可以看到，靜態代理類只能為特定的接口服務，如果要服務多類型的對象，就要為每一種對象進行代理。我們就會想是否可以通過一個代理類完成全部的代理功能，于是引入的動態代理的概念。

三、動態代理

　　Java的動態代理主要涉及兩個類，Proxy和InvocationHandler。

　　Proxy：提供了一組靜態方法來為一組接口動態地生成代理類及其對象。

// 方法 1: 該方法用于獲取指定代理對象所關聯的調用處理器 
static InvocationHandler getInvocationHandler(Object proxy)  
 
// 方法 2：該方法用于獲取關聯于指定類裝載器和一組接口的動態代理類的類對象 
static Class getProxyClass(ClassLoader loader, Class[] interfaces)  
 
// 方法 3：該方法用于判斷指定類對象是否是一個動態代理類 
static boolean isProxyClass(Class cl)  
 
// 方法 4：該方法用于為指定類裝載器、一組接口及調用處理器生成動態代理類實例 
static Object newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h)

　　InvocationHandler：它是調用處理器接口，自定義了一個invok方法，用于集中處理在動態代理類對象上的方法調用，通常在該方法中實現對委托類的代理訪問

// 該方法負責集中處理動態代理類上的所有方法調用。***個參數既是代理類實例，第二個參數是被調用的方法對象// 第三個方法是調用參數。調用處理器根據這三個參數進行預處理或分派到委托類實例上發射執行 
Object invoke(Object proxy, Method method, Object[] args)

　　實現Java的動態代理，具體有以下四個步驟：

通過實現InvocationHandler接口創建自己的調用處理器
通過為Proxy類指定ClassLoader對象和一組interface來創建動態代理類
通過反射機制獲得動態代理類的構造函數，其***參數類型是調用處理器類接口類型
通過構造函數創建動態代理類實例，構造時調用處理器對象作為參數被傳入

　　下面根據上述的四個步驟來實現自己的動態代理的示例：

　　接口和接口的實現類(即委托類)跟上面靜態代理的代碼一樣，這里我們來實現InvocationHandler接口創建自己的調用處理器

public class ServiceHandle implements InvocationHandler 
{ 
    private Object s; 
     
    public ServiceHandle(Object s) 
    { 
        this.s = s; 
    } 
    public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable 
    { 
        System.out.println("服務開始"); 
        //invoke表示對帶有指定參數的指定對象調用由此 Method 對象表示的底層方法 
        Object result=method.invoke(s, args); 
        System.out.println("服務結束"); 
        return result; 
    } 
}

　　編寫測試類：

public class TestMain 
{ 
    public static void main(String[] args) 
    { 
        Service service=new ServiceImpl(); 
        InvocationHandler handler=new ServiceHandle(service); 
        Service s=(Service) Proxy.newProxyInstance(service.getClass().getClassLoader(), service.getClass().getInterfaces(), handler); 
        s.add(); 
    } 
}

　　運行測試程序，結果同靜態代理。我們可以看到上述代碼并沒有我們之前說的步驟2和3，這是因為Prox的靜態方法newProxyInstance已經為我們封裝了這兩個步驟。具體的內部實現如下：

// 通過 Proxy 為包括 Interface 接口在內的一組接口動態創建代理類的類對象 
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });  
 
// 通過反射從生成的類對象獲得構造函數對象 
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });  
 
// 通過構造函數對象創建動態代理類實例 
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

　　newProxyInstance函數的內部實現為:

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException 
　　{ 
             //檢查h不為空，否則拋異常 
            Objects.requireNonNull(h); 
            //獲得與制定類裝載器和一組接口相關的代理類類型對象 
            final Class<?>[] intfs = interfaces.clone(); 
             
            //檢查接口類對象是否對類裝載器可見并且與類裝載器所能識別的接口類對象是完全相同的 
            final SecurityManager sm = System.getSecurityManager();     
            if (sm != null)  
            { 
                checkProxyAccess(Reflection.getCallerClass(), loader, intfs); 
            } 
            //獲得與制定類裝載器和一組接口相關的代理類類型對象 
            Class<?> cl = getProxyClass0(loader, intfs); 
            try 
            { 
                if (sm != null)  
                { 
                    checkNewProxyPermission(Reflection.getCallerClass(), cl); 
                } 
                // 通過反射獲取構造函數對象并生成代理類實例 
                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); 
           } 
　}

四、模擬實現Proxy類

　　根據上面的原理介紹，我們可以自己模擬實現Proxy類：

public class Proxy 
{ 
    public static Object newProxyInstance(Class inface,InvocationHandle h) throws Exception 
    { 
        String rt="\r\n"; 
        String methodStr=""; 
        Method[] methods=inface.getMethods(); 
        for(Method m:methods) 
        { 
            methodStr+="@Override"+rt+ 
                     "public void "+m.getName()+"()"+rt+"{" + rt + 
                    "   try {"+rt+ 
                    "  Method md="+inface.getName()+".class.getMethod(\""+m.getName()+"\");"+rt+ 
                        "h.invoke(this,md);"+rt+ 
                    "   } catch(Exception e){e.printStackTrace();}"+rt+ 
                     
                    "}"; 
        } 
        String src="package test;"+rt+ 
                "import java.lang.reflect.Method;"+rt+ 
                "public class ServiceImpl2 implements "+inface.getName()+ rt+ 
                "{"+rt+ 
                    "public ServiceImpl2(InvocationHandle h)"+rt+ 
                    "{"+rt+ 
                        "this.h = h;"+rt+ 
                    "}"+rt+ 
                    " test.InvocationHandle h;"+rt+ 
                    methodStr+ 
                "}"; 
        String fileName="d:/src/test/ServiceImpl2.java"; 
        //compile 
        compile(src, fileName); 
        //load into memory and create instance 
        Object m = loadMemory(h); 
         
        return m; 
    } 
    private static void compile(String src, String fileName) throws IOException 
    { 
        File f=new File(fileName); 
        FileWriter fileWriter=new FileWriter(f); 
        fileWriter.write(src); 
        fileWriter.flush(); 
        fileWriter.close(); 
        //獲取此平臺提供的Java編譯器 
        JavaCompiler compiler=ToolProvider.getSystemJavaCompiler(); 
        //獲取一個標準文件管理器實現的新實例 
        StandardJavaFileManager fileManager=compiler.getStandardFileManager(null,null, null); 
        //獲取表示給定文件的文件對象 
        Iterable units=fileManager.getJavaFileObjects(fileName); 
        //使用給定組件和參數創建編譯任務的 future 
        CompilationTask t=compiler.getTask(null, fileManager, null, null, null, units); 
        //執行此編譯任務 
        t.call();     
        fileManager.close(); 
    } 
    private static Object loadMemory(InvocationHandle h) 
            throws MalformedURLException, ClassNotFoundException, 
            NoSuchMethodException, InstantiationException, 
            IllegalAccessException, InvocationTargetException 
    { 
        URL[] urls=new URL[] {new URL("file:/"+"d:/src/")}; 
        //從路徑d:/src/加載類和資源 
        URLClassLoader ul=new URLClassLoader(urls); 
        Class c=ul.loadClass("test.ServiceImpl2"); 
        //返回Class對象所表示的類的指定公共構造方法。     
        Constructor ctr=c.getConstructor(InvocationHandle.class); 
        //使用此 Constructor對象ctr表示的構造方法來創建該構造方法的聲明類的新實例，并用指定的初始化參數初始化該實例 
        Object m = ctr.newInstance(h); 
        return m; 
    } 
}

五、總結

　　1、所謂的動態代理就是這樣一種class，它是在運行時生成的class，在生成它時你必須提供一組interface給它，然后改 class就宣稱它實現了這些interface，但是其實它不會替你作實質性的工作，而是根據你在生成實例時提供的參數handler(即 InvocationHandler接口的實現類),由這個Handler來接管實際的工作。

　　2、Proxy的設計使得它只能支持interface的代理，Java的繼承機制注定了動態代理類無法實現對class的動態代理，因為多繼承在Java中本質上就行不通。

責任編輯：王雪燕來源：博客園

Java 動態代理機制