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

關於Java中的動態代理，我們首先需要了解的是一種常用的設計模式--代理模式，而對於代理，根據創建代理類的時間點，又可以分爲靜態代理和動態代理。

一、代理模式

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

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

二、靜態代理

1、靜態代理

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

2、靜態代理簡單實現

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

班長就是學生的代理。

首先，我們創建一個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），我們能在一個切點之前執行一些操作，在一個切點之後執行一些操作，這個切點就是一個個方法。這些方法所在類肯定就是被代理了，在代理過程中切入了一些其他操作。

三、動態代理

1.動態代理

代理類在程序運行時創建的代理方式被成爲動態代理。我們上面靜態代理的例子中，代理類(studentProxy)是自己定義好的，在程序運行之前就已經編譯完成。然而動態代理，代理類並不是在Java代碼中定義的，而是在運行時根據我們在Java代碼中的“指示”動態生成的。相比於靜態代理，動態代理的優勢在於可以很方便的對代理類的函數進行統一的處理，而不用修改每個代理類中的方法。比如說，想要在每個代理的方法前都加上一個處理方法：

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

這裏只有一個giveMoney方法，就寫一次beforeMethod方法，但是如果出了giveMonney還有很多其他的方法，那就需要寫很多次beforeMethod方法，麻煩。那看看下面動態代理如何實現。

2、動態代理簡單實現

在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方法中統一處理，就可以對所有被代理的方法進行相同的操作了。例如，這裏的方法計時，所有的被代理對象執行的方法都會被計時，然而我只做了很少的代碼量。

java動態代理

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

一、代理模式

二、靜態代理

三、動態代理

如何使用 JS 判斷用戶是否處於活躍狀態

通過HPA+CronHPA組合應對業務複雜彈性伸縮場景

數據庫知識面試總結

Tomcat日誌總結

java動態代理

關於在myeclipse裏查看jar包的源代碼

關於樹表結構的查找算法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結