java動態代理實現與原理詳細分析

時間  2019-11-08
標籤 java 動態 代理 實現 原理 詳細 分析 欄目 Java 简体版
原文   原文鏈接

關於Java中的動態代理，咱們首先須要瞭解的是一種經常使用的設計模式--代理模式，而對於代理，根據建立代理類的時間點，又能夠分爲靜態代理和動態代理。java

 1、代理模式

   代理模式是經常使用的java設計模式，他的特徵是代理類與委託類有一樣的接口，代理類主要負責爲委託類預處理消息、過濾消息、把消息轉發給委託類，以及過後處理消息等。代理類與委託類之間一般會存在關聯關係，一個代理類的對象與一個委託類的對象關聯，代理類的對象自己並不真正實現服務，而是經過調用委託類的對象的相關方法，來提供特定的服務。簡單的說就是，咱們在訪問實際對象時，是經過代理對象來訪問的，代理模式就是在訪問實際對象時引入必定程度的間接性，由於這種間接性，能夠附加多種用途。在後面我會程序員

解釋這種間接性帶來的好處。代理模式結構圖（圖片來自《大話設計模式》）：編程

                                                          

2、靜態代理

    一、靜態代理設計模式

靜態代理：由程序員建立或特定工具自動生成源代碼，也就是在編譯時就已經將接口，被代理類，代理類等肯定下來。在程序運行以前，代理類的.class文件就已經生成。緩存

    二、靜態代理簡單實現ide

  根據上面代理模式的類圖，來寫一個簡單的靜態代理的例子。我這兒舉一個比較粗糙的例子，假如一個班的同窗要向老師交班費，可是都是經過班長把本身的錢轉交給老師。這裏，班長就是代理學生上交班費，函數

班長就是學生的代理。工具

    首先，咱們建立一個Person接口。這個接口就是學生（被代理類），和班長（代理類）的公共接口，他們都有上交班費的行爲。這樣，學生上交班費就可讓班長來代理執行。學習

/**
 * 建立Person接口
 * @author Gonjan
 */
public interface Person {
    //上交班費
    void giveMoney();
}

Student類實現Person接口。Student能夠具體實施上交班費的動做。測試

public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
       System.out.println(name + "上交班費50元");
    }
}

StudentsProxy類，這個類也實現了Person接口，可是還另外持有一個學生類對象，因爲實現了Peson接口，同時持有一個學生對象，那麼他能夠代理學生類對象執行上交班費（執行giveMoney()方法）行爲。

/**
 * 學生代理類，也實現了Person接口，保存一個學生實體，這樣既能夠代理學生產生行爲
 * @author Gonjan
 *
 */
public class StudentsProxy implements Person{
    //被代理的學生
    Student stu;
    
    public StudentsProxy(Person stu) {
        // 只代理學生對象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班費，調用被代理學生的上交班費行爲
    public void giveMoney() {
        stu.giveMoney();
    }
}

下面測試一下，看如何使用代理模式：

public class StaticProxyTest {
    public static void main(String[] args) {
        //被代理的學生張三，他的班費上交有代理對象monitor（班長）完成
        Person zhangsan = new Student("張三");
        
        //生成代理對象，並將張三傳給代理對象
        Person monitor = new StudentsProxy(zhangsan);
        
        //班長代理上交班費
        monitor.giveMoney();
    }
}

運行結果：

這裏並無直接經過張三（被代理對象）來執行上交班費的行爲，而是經過班長（代理對象）來代理執行了。這就是代理模式。

代理模式最主要的就是有一個公共接口（Person），一個具體的類（Student），一個代理類（StudentsProxy）,代理類持有具體類的實例，代爲執行具體類實例方法。上面說到，代理模式就是在訪問實際對象時引入必定程度的間接性，由於這種間接性，能夠附加多種用途。這裏的間接性就是指不直接調用實際對象的方法，那麼咱們在代理過程當中就能夠加上一些其餘用途。就這個例子來講，加入班長在幫張三上交班費以前想要先反映一下張三最近學習有很大進步，經過代理模式很輕鬆就能辦到：

public class StudentsProxy implements Person{
    //被代理的學生
    Student stu;
    
    public StudentsProxy(Person stu) {
        // 只代理學生對象
        if(stu.getClass() == Student.class) {
            this.stu = (Student)stu;
        }
    }
    
    //代理上交班費，調用被代理學生的上交班費行爲
    public void giveMoney() {
        System.out.println("張三最近學習有進步！");
        stu.giveMoney();
    }
}

運行結果：

能夠看到，只須要在代理類中幫張三上交班費以前，執行其餘操做就能夠了。這種操做，也是使用代理模式的一個很大的優勢。最直白的就是在Spring中的面向切面編程（AOP），咱們能在一個切點以前執行一些操做，在一個切點以後執行一些操做，這個切點就是一個個方法。這些方法所在類確定就是被代理了，在代理過程當中切入了一些其餘操做。

3、動態代理

     1.動態代理

    代理類在程序運行時建立的代理方式被成爲動態代理。 咱們上面靜態代理的例子中，代理類(studentProxy)是本身定義好的，在程序運行以前就已經編譯完成。然而動態代理，代理類並非在Java代碼中定義的，而是在運行時根據咱們在Java代碼中的「指示」動態生成的。相比於靜態代理， 動態代理的優點在於能夠很方便的對代理類的函數進行統一的處理，而不用修改每一個代理類中的方法。 好比說，想要在每一個代理的方法前都加上一個處理方法：

 public void giveMoney() {
        //調用被代理方法前加入處理方法
        beforeMethod();
        stu.giveMoney();
    }

 

這裏只有一個giveMoney方法，就寫一次beforeMethod方法，可是若是出了giveMonney還有不少其餘的方法，那就須要寫不少次beforeMethod方法，麻煩。那看看下面動態代理如何實現。

     二、動態代理簡單實現

在java的java.lang.reflect包下提供了一個Proxy類和一個InvocationHandler接口，經過這個類和這個接口能夠生成JDK動態代理類和動態代理對象。

建立一個動態代理對象步驟，具體代碼見後面：

  • 建立一個InvocationHandler對象
//建立一個與代理對象相關聯的InvocationHandler
 InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);

 

 

  • 使用Proxy類的getProxyClass靜態方法生成一個動態代理類stuProxyClass 
  Class<?> stuProxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class<?>[] {Person.class});

 

  • 得到stuProxyClass 中一個帶InvocationHandler參數的構造器constructor
Constructor<?> constructor = PersonProxy.getConstructor(InvocationHandler.class);

 

  • 經過構造器constructor來建立一個動態實例stuProxy
Person stuProxy = (Person) cons.newInstance(stuHandler);

 

就此，一個動態代理對象就建立完畢，固然，上面四個步驟能夠經過Proxy類的newProxyInstances方法來簡化：

 //建立一個與代理對象相關聯的InvocationHandler
  InvocationHandler stuHandler = new MyInvocationHandler<Person>(stu);
//建立一個代理對象stuProxy，代理對象的每一個執行方法都會替換執行Invocation中的invoke方法
  Person stuProxy= (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);

 

到這裏確定都會很疑惑，這動態代理究竟是如何執行的，是如何經過代理對象來執行被代理對象的方法的，先不急，咱們先看看一個簡單的完整的動態代理的例子。仍是上面靜態代理的例子，班長鬚要幫學生代交班費。
首先是定義一個Person接口:

/**
 * 建立Person接口
 * @author Gonjan
 */
public interface Person {
    //上交班費
    void giveMoney();
}

 

建立須要被代理的實際類：

public class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
        try {
          //假設數錢花了一秒時間
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       System.out.println(name + "上交班費50元");
    }
}

 

再定義一個檢測方法執行時間的工具類，在任何方法執行前先調用start方法，執行後調用finsh方法，就能夠計算出該方法的運行時間，這也是一個最簡單的方法執行時間檢測工具。

public class MonitorUtil {
    
    private static ThreadLocal<Long> tl = new ThreadLocal<>();
    
    public static void start() {
        tl.set(System.currentTimeMillis());
    }
    
    //結束時打印耗時
    public static void finish(String methodName) {
        long finishTime = System.currentTimeMillis();
        System.out.println(methodName + "方法耗時" + (finishTime - tl.get()) + "ms");
    }
}

建立StuInvocationHandler類，實現InvocationHandler接口，這個類中持有一個被代理對象的實例target。InvocationHandler中有一個invoke方法，全部執行代理對象的方法都會被替換成執行invoke方法。

再再invoke方法中執行被代理對象target的相應方法。固然，在代理過程當中，咱們在真正執行被代理對象的方法前加入本身其餘處理。這也是Spring中的AOP實現的主要原理，這裏還涉及到一個很重要的關於java反射方面的基礎知識。

public class StuInvocationHandler<T> implements InvocationHandler {
   //invocationHandler持有的被代理對象
    T target;
    
    public StuInvocationHandler(T target) {
       this.target = target;
    }
    
    /**
     * proxy:表明動態代理對象
     * method：表明正在執行的方法
     * args：表明調用目標方法時傳入的實參
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理執行" +method.getName() + "方法");
     */   
        //代理過程當中插入監測方法,計算該方法耗時
        MonitorUtil.start();
        Object result = method.invoke(target, args);
        MonitorUtil.finish(method.getName());
        return result;
    }
}

作完上面的工做後，咱們就能夠具體來建立動態代理對象了，上面簡單介紹瞭如何建立動態代理對象，咱們使用簡化的方式建立動態代理對象：

 

public class ProxyTest {
    public static void main(String[] args) {
        
        //建立一個實例對象，這個對象是被代理的對象
        Person zhangsan = new Student("張三");
        
        //建立一個與代理對象相關聯的InvocationHandler
        InvocationHandler stuHandler = new StuInvocationHandler<Person>(zhangsan);
        
        //建立一個代理對象stuProxy來代理zhangsan，代理對象的每一個執行方法都會替換執行Invocation中的invoke方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler)；

       //代理執行上交班費的方法
        stuProxy.giveMoney();
    }
}

 

咱們執行這個ProxyTest類，先想一下，咱們建立了一個須要被代理的學生張三，將zhangsan對象傳給了stuHandler中，咱們在建立代理對象stuProxy時，將stuHandler做爲參數了的，上面也有說到全部執行代理對象的方法都會被替換成執行invoke方法，也就是說，最後執行的是StuInvocationHandler中的invoke方法。因此在看到下面的運行結果也就理所固然了。

運行結果：

上面說到，動態代理的優點在於能夠很方便的對代理類的函數進行統一的處理，而不用修改每一個代理類中的方法。是由於全部被代理執行的方法，都是經過在InvocationHandler中的invoke方法調用的，因此咱們只要在invoke方法中統一處理，就能夠對全部被代理的方法進行相同的操做了。例如，這裏的方法計時，全部的被代理對象執行的方法都會被計時，然而我只作了不多的代碼量。

動態代理的過程，代理對象和被代理對象的關係不像靜態代理那樣一目瞭然，清晰明瞭。由於動態代理的過程當中，咱們並無實際看到代理類，也沒有很清晰地的看到代理類的具體樣子，並且動態代理中被代理對象和代理對象是經過InvocationHandler來完成的代理過程的，其中具體是怎樣操做的，爲何代理對象執行的方法都會經過InvocationHandler中的invoke方法來執行。帶着這些問題，咱們就須要對java動態代理的源碼進行簡要的分析，弄清楚其中原因。

4、動態代理原理分析

    一、Java動態代理建立出來的動態代理類

上面咱們利用Proxy類的newProxyInstance方法建立了一個動態代理對象，查看該方法的源碼，發現它只是封裝了建立動態代理類的步驟(紅色標準部分)：

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

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */ Class<?> cl = getProxyClass0(loader, intfs); /*
         * Invoke its constructor with the designated invocation handler.
         */
        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);
        }
    }

 

其實，咱們最應該關注的是 Class<?> cl = getProxyClass0(loader, intfs);這句，這裏產生了代理類，後面代碼中的構造器也是經過這裏產生的類來得到，能夠看出，這個類的產生就是整個動態代理的關鍵，因爲是動態生成的類文件，我這裏不具體進入分析如何產生的這個類文件，只須要知道這個類文件時緩存在java虛擬機中的，咱們能夠經過下面的方法將其打印到文件裏面，一睹真容：

        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Student.class.getInterfaces());
        String path = "G:/javacode/javase/Test/bin/proxy/StuProxy.class";
        try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理類class文件寫入成功");
        } catch (Exception e) {
           System.out.println("寫文件錯誤");
        }

對這個class文件進行反編譯，咱們看看jdk爲咱們生成了什麼樣的內容：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import proxy.Person;

public final class $Proxy0 extends Proxy implements Person
{
  private static Method m1;
  private static Method m2;
  private static Method m3;
  private static Method m0;
  
  /**
  *注意這裏是生成代理類的構造方法，方法參數爲InvocationHandler類型，看到這，是否是就有點明白
  *爲什麼代理對象調用方法都是執行InvocationHandler中的invoke方法，而InvocationHandler又持有一個
  *被代理對象的實例，不由會想難道是....？ 沒錯，就是你想的那樣。
  *
  *super(paramInvocationHandler)，是調用父類Proxy的構造方法。
  *父類持有：protected InvocationHandler h;
  *Proxy構造方法：
  *    protected Proxy(InvocationHandler h) {
  *         Objects.requireNonNull(h);
  *         this.h = h;
  *     }
  *
  */
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  
  //這個靜態塊原本是在最後的，我把它拿到前面來，方便描述
   static
  {
    try
    {
      //看看這兒靜態塊兒裏面有什麼，是否是找到了giveMoney方法。請記住giveMoney經過反射獲得的名字m3，其餘的先無論
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("proxy.Person").getMethod("giveMoney", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
  }
 
  /**
  * 
  *這裏調用代理對象的giveMoney方法，直接就調用了InvocationHandler中的invoke方法，並把m3傳了進去。
  *this.h.invoke(this, m3, null);這裏簡單，明瞭。
  *來，再想一想，代理對象持有一個InvocationHandler對象，InvocationHandler對象持有一個被代理的對象，
  *再聯繫到InvacationHandler中的invoke方法。嗯，就是這樣。
  */
  public final void giveMoney()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  //注意，這裏爲了節省篇幅，省去了toString，hashCode、equals方法的內容。原理和giveMoney方法一毛同樣。

}

 

jdk爲咱們的生成了一個叫$Proxy0（這個名字後面的0是編號，有多個代理類會一次遞增）的代理類，這個類文件時放在內存中的，咱們在建立代理對象時，就是經過反射得到這個類的構造方法，而後建立的代理實例。經過對這個生成的代理類源碼的查看，咱們很容易能看出，動態代理實現的具體過程。

咱們能夠對InvocationHandler看作一箇中介類，中介類持有一個被代理對象，在invoke方法中調用了被代理對象的相應方法。經過聚合方式持有被代理對象的引用，把外部對invoke的調用最終都轉爲對被代理對象的調用。

代理類調用本身方法時，經過自身持有的中介類對象來調用中介類對象的invoke方法，從而達到代理執行被代理對象的方法。也就是說，動態代理經過中介類實現了具體的代理功能。

5、總結

生成的代理類：$Proxy0 extends Proxy implements Person，咱們看到代理類繼承了Proxy類，因此也就決定了java動態代理只能對接口進行代理，Java的繼承機制註定了這些動態代理類們沒法實現對class的動態代理。
上面的動態代理的例子，其實就是AOP的一個簡單實現了，在目標對象的方法執行以前和執行以後進行了處理，對方法耗時統計。Spring的AOP實現其實也是用了Proxy和InvocationHandler這兩個東西的。

 

後面補充，知其然，還要知其因此然。

 

 

------------------------

本文原創，文中如有表述不清或存在問題，歡迎指正。共同窗習^_^。   ---2017.4.9 

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程