一、概述

　　代理是一種設(shè)計模式，其目的是為其他對象提供一個代理以控制對某個對象的訪問，代理類負(fù)責(zé)為委托類預(yù)處理消息，過濾消息并轉(zhuǎn)發(fā)消息以及進(jìn)行消息被委托類執(zhí)行后的后續(xù)處理。為了保持行為的一致性，代理類和委托類通常會實現(xiàn)相同的接口。

　　按照代理的創(chuàng)建時期，代理類可分為兩種：

• 靜態(tài)代理：由程序員創(chuàng)建代理類或特定工具自動生成源代碼再對其編譯，也就是說在程序運行前代理類的.class文件就已經(jīng)存在。

• 動態(tài)代理：在程序運行時運用反射機制動態(tài)創(chuàng)建生成。

　　下面在將動態(tài)代理的實現(xiàn)機制之前先簡單介紹一下靜態(tài)代理。

二、靜態(tài)代理

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

public interface Service 
{     
    public void add(); 
} 

　　委托類作為接口的一種實現(xiàn)，定義如下：

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("服務(wù)開始"); 
        service.add(); 
        System.out.println("服務(wù)結(jié)束"); 
    } 
} 

　　編寫測試類： 

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

　　運行測試程序，結(jié)果如下圖：

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

三、動態(tài)代理

　　Java的動態(tài)代理主要涉及兩個類，Proxy和InvocationHandler。

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

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

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

// 該方法負(fù)責(zé)集中處理動態(tài)代理類上的所有方法調(diào)用。***個參數(shù)既是代理類實例，第二個參數(shù)是被調(diào)用的方法對象// 第三個方法是調(diào)用參數(shù)。調(diào)用處理器根據(jù)這三個參數(shù)進(jìn)行預(yù)處理或分派到委托類實例上發(fā)射執(zhí)行 
Object invoke(Object proxy, Method method, Object[] args) 

　　實現(xiàn)Java的動態(tài)代理，具體有以下四個步驟：

1. 通過實現(xiàn)InvocationHandler接口創(chuàng)建自己的調(diào)用處理器

2. 通過為Proxy類指定ClassLoader對象和一組interface來創(chuàng)建動態(tài)代理類

3. 通過反射機制獲得動態(tài)代理類的構(gòu)造函數(shù)，其***參數(shù)類型是調(diào)用處理器類接口類型

4. 通過構(gòu)造函數(shù)創(chuàng)建動態(tài)代理類實例，構(gòu)造時調(diào)用處理器對象作為參數(shù)被傳入

　　下面根據(jù)上述的四個步驟來實現(xiàn)自己的動態(tài)代理的示例：

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

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("服務(wù)開始"); 
        //invoke表示對帶有指定參數(shù)的指定對象調(diào)用由此 Method 對象表示的底層方法 
        Object result=method.invoke(s, args); 
        System.out.println("服務(wù)結(jié)束"); 
        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(); 
    } 
} 

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

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

　　newProxyInstance函數(shù)的內(nèi)部實現(xiàn)為:

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

四、模擬實現(xiàn)Proxy類

　　根據(jù)上面的原理介紹，我們可以自己模擬實現(xiàn)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(); 
        //獲取一個標(biāo)準(zhǔn)文件管理器實現(xiàn)的新實例 
        StandardJavaFileManager fileManager=compiler.getStandardFileManager(null,null, null); 
        //獲取表示給定文件的文件對象 
        Iterable units=fileManager.getJavaFileObjects(fileName); 
        //使用給定組件和參數(shù)創(chuàng)建編譯任務(wù)的 future 
        CompilationTask t=compiler.getTask(null, fileManager, null, null, null, units); 
        //執(zhí)行此編譯任務(wù) 
        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對象所表示的類的指定公共構(gòu)造方法。     
        Constructor ctr=c.getConstructor(InvocationHandle.class); 
        //使用此 Constructor對象ctr表示的構(gòu)造方法來創(chuàng)建該構(gòu)造方法的聲明類的新實例，并用指定的初始化參數(shù)初始化該實例 
        Object m = ctr.newInstance(h); 
        return m; 
    } 
} 

五、總結(jié)

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

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