太好了！總算有人把動態代理、CGlib、AOP都說清楚了！

2019 年 10 月 6 日
筆記

作者：幾米憧憬  原文：https://note.youdao.com/share/?id=1b50d57ce1f7544da238d2051046ccc6&type=note#/

Java 代理模式實現方式，主要有如下五種方法

靜態代理，工程師編輯代理類程式碼，實現代理模式；在編譯期就生成了代理類。
基於 JDK 實現動態代理，通過jdk提供的工具方法Proxy.newProxyInstance動態構建全新的代理類(繼承Proxy類，並持有InvocationHandler介面引用 )位元組碼文件並實例化對象返回。(jdk動態代理是由java內部的反射機制來實例化代理對象，並代理的調用委託類方法)
基於CGlib 動態代理模式基於繼承被代理類生成代理子類，不用實現介面。只需要被代理類是非final 類即可。(cglib動態代理底層是藉助asm位元組碼技術
基於 Aspectj 實現動態代理（修改目標類的位元組，織入代理的位元組，在程式編譯的時候插入動態代理的位元組碼，不會生成全新的Class ）
基於 instrumentation 實現動態代理（修改目標類的位元組碼、類裝載的時候動態攔截去修改，基於javaagent） -javaagent:spring-instrument-4.3.8.RELEASE.jar （類裝載的時候插入動態代理的位元組碼，不會生成全新的Class ）

Notes

委託類即指的是代理模式中的被代理對象
代理類指的是生成的代表委託類的一個角色

靜態代理實現

靜態代理是代理類在編譯期間就創建好了，不是編譯器生成的代理類，而是手動創建的類。在編譯時就已經將介面，被代理類，代理類等確定下來。，軟體設計中所指的代理一般是指靜態代理，也就是在程式碼中顯式指定的代理。

實現步驟

委託類和代理類之間的約束介面Cat
約束介面實現類 Lion，實現 Cat 介面，委託角色
代理類實現 FeederProxy，實現Cat 介面，並含有一個 Cat介面引用屬性。代理角色，代理 cat介面屬性引用實例的行為並可以新增公共邏輯

Cat介面

package org.vincent.proxy.staticproxy;/**   * @author PengRong   * @package org.vincent.proxy.staticproxy   * @date 2018/12/15 - 17:12   * @ProjectName JavaAopLearning   * @Description: 靜態代理類介面, 委託類和代理類都需要實現的介面規範。   * 定義了一個貓科動物的兩個行為介面，吃東西，奔跑。   * 作為代理類 和委託類之間的約束介面   */public interface Cat {    public String eatFood(String foodName);    public boolean running();  }

委託類 Lion

package org.vincent.proxy.staticproxy;/**   * @author PengRong   * @package org.vincent.proxy.staticproxy   * @date 2018/12/15 - 17:15   * @ProjectName JavaAopLearning   * @Description: 獅子 實現了貓科動物介面Cat， 並實現了具體的行為。作為委託類實現   */public class Lion implements Cat {    private String name;    private int runningSpeed;    public String getName() {        return name;      }    public void setName(String name) {        this.name = name;      }    public int getRunningSpeed() {        return runningSpeed;      }    public void setRunningSpeed(int runningSpeed) {        this.runningSpeed = runningSpeed;      }    public Lion() {      }    @Override      public String eatFood(String foodName) {          String eat = this.name + " Lion eat food. foodName = " + foodName;          System.out.println(eat);        return eat;      }    @Override      public boolean running() {          System.out.println(this.name + " Lion is running . Speed :" + this.runningSpeed);        return false;      }  }

代理類角色(FeederProxy)

package org.vincent.proxy.staticproxy;/**   * @author PengRong   * @package org.vincent.proxy.staticproxy   * @date 2018/12/15 - 17:19   * @ProjectName JavaAopLearning   * @Description: 飼養員 實現Cat介面，作為靜態代理類實現。代理獅子的行為。   * 代理類中可以新增一些其他行為，在實踐中主要做的是參數校驗的功能。   */public class FeederProxy implements Cat {    private Cat cat;    public FeederProxy(){}    public FeederProxy(Cat cat) {        if (cat instanceof Cat) {            this.cat = cat;          }      }    public void setCat(Cat cat) {        if (cat instanceof Cat) {            this.cat = cat;          }      }    @Override      public String eatFood(String foodName) {          System.out.println("proxy Lion exec eatFood ");        return cat.eatFood(foodName);      }    @Override      public boolean running() {          System.out.println("proxy Lion exec running.");        return cat.running();      }  }

靜態代理類測試

package org.vincent.proxy;import org.vincent.proxy.staticproxy.Cat;import org.vincent.proxy.staticproxy.FeederProxy;import org.vincent.proxy.staticproxy.Lion;/**   * @author PengRong   * @package org.vincent.proxy   * @date 2018/12/15 - 18:31   * @ProjectName JavaAopLearning   * @Description: 靜態代理類測試   */public class staticProxyTest {    public static void main(String[] args) {          Lion lion = new Lion();          lion.setName("獅子 小王");          lion.setRunningSpeed(100);        /**           * new 靜態代理類，靜態代理類在編譯前已經創建好了，和動態代理的最大區別點           */          Cat proxy = new FeederProxy(lion);            System.out.println(Thread.currentThread().getName()+" -- " + proxy.eatFood("水牛"));          proxy.running();      }  }

靜態代理很好的詮釋了代理設計模式，代理模式最主要的就是有一個公共介面（Cat），一個委託類（Lion），一個代理類（FeederProxy）,代理類持有委託類的實例，代為執行具體類實例方法。上面說到，代理模式就是在訪問實際對象時引入一定程度的間接性，因為這種間接性，可以附加多種用途。這裡的間接性就是指客戶端不直接調用實際對象的方法，客戶端依賴公共介面並使用代理類。那麼我們在代理過程中就可以加上一些其他用途。就這個例子來說在 eatFood方法調用中，代理類在調用具體實現類之前添加System.out.println("proxy Lion exec eatFood ");語句就是添加間接性帶來的收益。代理類存在的意義是為了增加一些公共的邏輯程式碼。

動態代理類(基於介面實現)

靜態代理是代理類在程式碼運行前已經創建好，並生成class文件；動態代理類是代理類在程式運行時創建的代理模式。

動態代理類的代理類並不是在Java程式碼中定義的，而是在運行時根據我們在Java程式碼中的「指示」動態生成的。相比於靜態代理，動態代理的優勢在於可以很方便的對代理類的函數進行統一的處理，而不用修改每個代理類中的方法。想想你有100個靜態代理類，現在有一個需求，每個代理類都需要新增一個處理邏輯，你需要打開100個代理類在每個代理方法裡面新增處理邏輯嗎？有或者代理類有5個方法，每個方法都需要新增一個處理邏輯，你需要在每個方法都手動新增處理邏輯嗎？想想就挺無趣的。動態代理類幫你一鍵搞定。

動態代理類涉及角色

委託類和代理類實現的公共介面(Person.java)
實現公共介面的具體委託類(SoftwareEngineer.java)
InvocationHandler介面被Proxy類回調處理，一般實現 InvocationHandler 介面的類具有委託類引用，介面方法 invoke 中添加公共程式碼並調用委託類的介面方法。(PersonInvocationHandler.java)
JDK提供生成動態代理類的核心類Proxy ( JDK 提供的Proxy.java)

基於JDK技術動態代理類技術核心 Proxy類和一個 InvocationHandler 介面

java的java.lang.reflect包下提供了Proxy類和一個 InvocationHandler 介面，這個類Proxy定義了生成JDK動態代理類的方法 getProxyClass(ClassLoader loader,Class<?>... interfaces)生成動態代理類,返回class實例代表一個class文件。可以保存該 class 文件查看jdk生成的代理類文件長什麼樣

該生成的動態代理類繼承Proxy類，(重要特性) ，並實現公共介面。

InvocationHandler這個介面是被動態代理類回調的介面，我們所有需要增加的針對委託類的統一處理邏輯都增加到invoke 方法裡面在調用委託類介面方法之前或之後結束戰鬥。

案例

公共介面

package org.vincent.proxy.dynamicproxy;/**   * Created by PengRong on 2018/12/25.   * 創建Person 介面 用於定義 委託類和代理類之間的約束行為   */public interface Person{    /**       *       * @param name 人名       * @param dst 工作目的地       */      void goWorking(String name, String dst);    /**       * 獲取名稱       * @return       */      String getName( );    /**       * 設置名稱       * @param name       */      void  setName(String name);  }

具體實現類，等下被委託，被代理的類 SoftwareEngineer.java

package org.vincent.proxy.dynamicproxy;/**   * Created by PengRong on 2018/12/25.   * 動態代理委託類實現， 實現介面 Person。 被動態生成的代理類代理   */public class SoftwareEngineer implements Person{    public  SoftwareEngineer(){}    public  SoftwareEngineer(String name){        this.name=name;      }    private  String name;    public String getName() {        return name;      }    public void setName(String name) {        this.name = name;      }    @Override      public void goWorking(String name, String dst) {          System.out.println("name ="+name+" ， 去 "+dst +" 工作");      }  }

InvocationHandler 介面實現 PersonInvocationHandler.java

package org.vincent.proxy.dynamicproxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.util.Arrays;/**   * Created by PengRong on 2018/12/25.   * PersonInvocationHandler 類 實現InvocationHandler介面，這個類中持有一個被代理對象(委託類)的實例target。該類別JDK Proxy類回調   * InvocationHandler 介面中有一個invoke方法，當一個代理實例的方法被調用時，代理方法將被編碼並分發到 InvocationHandler介面的invoke方法執行。   */public class PersonInvocationHandler<T> implements InvocationHandler {    /**       * 被代理對象引用，invoke 方法裡面method 需要使用這個 被代理對象       */      T target;    public PersonInvocationHandler(T target) {        this.target = target;      }    /**       * 在       * @param proxy  代表動態生成的 動態代理 對象實例       * @param method 代表被調用委託類的介面方法，和生成的代理類實例調用的介面方法是一致的，它對應的Method 實例       * @param args   代表調用介面方法對應的Object參數數組，如果介面是無參，則為null； 對於原始數據類型返回的他的包裝類型。       * @return       * @throws Throwable       */      @Override      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        /**           * 在轉調具體目標對象之前，可以執行一些功能處理           */          System.out.println("被動態代理類回調執行, 代理類 proxyClass ="+proxy.getClass()+" 方法名: " + method.getName() + "方法. 方法返回類型："+method.getReturnType()          +" 介面方法入參數組: "+(args ==null ? "null" : Arrays.toString(args)));        /**           * 代理過程中插入監測方法,計算該方法耗時           */          MonitorUtil.start();          Thread.sleep(1);        /** 調用唄代理對象的真實方法，*/          Object result = method.invoke(target, args);          MonitorUtil.finish(method.getName());        return result;      }  }

PersonInvocationHandler invoke 方法中添加的公共程式碼，這裡簡單以統計方法執行時間為邏輯

package org.vincent.proxy.dynamicproxy;/**   * Created by PengRong on 2018/12/25.   * 方法用時監控類   */public class MonitorUtil {    private static ThreadLocal<Long> tl = new ThreadLocal<>();    public static void start() {          tl.set(System.currentTimeMillis());      }    /**       * 結束時列印耗時       * @param methodName 方法名       */      public static void finish(String methodName) {        long finishTime = System.currentTimeMillis();          System.out.println(methodName + "方法執行耗時" + (finishTime - tl.get()) + "ms");      }  }

最後的是怎麼創建代理類

package org.vincent.proxy.jdkdynamicProxy;import org.vincent.proxy.dynamicproxy.Person;import org.vincent.proxy.dynamicproxy.PersonInvocationHandler;import org.vincent.proxy.dynamicproxy.SoftwareEngineer;import sun.misc.ProxyGenerator;import java.io.FileOutputStream;import java.lang.reflect.Constructor;import java.lang.reflect.Field;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;import java.nio.file.Path;import java.nio.file.Paths;import java.util.Arrays;import java.util.Properties;/**   * 動態代理類測試   * Created by PengRong on 2018/12/25.   */public class JdkDynamicProxyTest {    public static void main(String[] args) throws Exception {        // 打開保存JDK動態代理生成的類文件          saveGeneratedJdkProxyFiles();        /**           * 第一種方法: 通過 Proxy.newProxyInstance 方法 獲取代理對象           */          System.out.println("-------------------第一種創建代理類方法--------------");        //創建一個實例對象，這個對象是被代理的對象，委託類          Person person = new SoftwareEngineer("Vincent");        //創建一個與代理類相關聯的InvocationHandler,每一個代理類都有一個關聯的 InvocationHandler，並將代理類引用傳遞進去          InvocationHandler Handler = new PersonInvocationHandler<>(person);        //創建一個 代理對象 personProxy 來代理 person，創建的代理對象的每個執行方法都會被替換執行Invocation介面中的invoke方法          Person personProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, Handler);        /** 代理類資訊 */          System.out.println("package = " + personProxy.getClass().getPackage() + " SimpleName = " + personProxy.getClass().getSimpleName() + " name =" + personProxy.getClass().getName() + " CanonicalName = " +                "" + personProxy.getClass().getCanonicalName() + " 實現的介面 Interfaces = " + Arrays.toString(personProxy.getClass().getInterfaces()) +                " superClass = " + personProxy.getClass().getSuperclass() + " methods =" + Arrays.toString(personProxy.getClass().getMethods()));        // 通過 代理類 執行 委託類的程式碼邏輯          personProxy.goWorking(personProxy.getName(), "深圳");            System.out.println("-------------------第二種創建代理類方法--------------");        /**           *  動態代理對象步驟           *      1、 創建一個與代理對象相關聯的 InvocationHandler，以及真實的委託類實例           *      2、Proxy類的getProxyClass靜態方法生成一個動態代理類stuProxyClass，該類繼承Proxy類，實現 Person.java介面；JDK動態代理的特點是代理類必須繼承Proxy類           *      3、通過代理類 proxyClass 獲得他的帶InvocationHandler 介面的構造函數 ProxyConstructor           *      4、通過 構造函數實例 ProxyConstructor 實例化一個代理對象，並將  InvocationHandler 介面實例傳遞給代理類。           */          // 1、創建 InvocationHandler 實例並設置代理的目標類對象          Person persontwo = new SoftwareEngineer("Vincent");          InvocationHandler Handlertwo = new PersonInvocationHandler<>(persontwo);        // 2 創建代理類,是一個位元組碼文件, 把 proxyClass 保存起來就能看到 他繼承Proxy 類，實現Person介面          Class<?> proxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class<?>[]{Person.class});        /** 代理類資訊 */          System.out.println("package = " + proxyClass.getPackage() + " SimpleName = " + proxyClass.getSimpleName() + " name =" + proxyClass.getName() + " CanonicalName = " +                "" + proxyClass.getCanonicalName() + " 實現的介面 Interfaces = " + Arrays.toString(proxyClass.getInterfaces()) +                " superClass = " + proxyClass.getSuperclass() + " methods =" + Arrays.toString(proxyClass.getMethods()));        // 3、  通過 proxyClass 獲得 一個帶有InvocationHandler參數的構造器constructor          Constructor<?> ProxyConstructor = proxyClass.getConstructor(InvocationHandler.class);        // 4、通過構造器創建一個  動態代理類 實例          Person stuProxy = (Person) ProxyConstructor.newInstance(Handlertwo);        /** 檢測生成的類是否是代理類 */          System.out.println("stuProxy isProxy "+Proxy.isProxyClass(stuProxy.getClass()));        /** 獲取 代理類關聯的 InvocationHandler 是哪個*/          InvocationHandler handlerObject = Proxy.getInvocationHandler(stuProxy);          System.out.println(handlerObject.getClass().getName());          stuProxy.goWorking(stuProxy.getName(), "廣州");        // 保存代理類          saveClass("$PersonProxy0", proxyClass.getInterfaces(), "D:/123/");      }    /**       * 生成代理類 class 並保持到文件中       *       * @param className  生成的代理類名稱       * @param interfaces 代理類需要實現的介面       * @param pathdir    代理類保存的目錄路徑,以目錄分隔符結尾       */      public static void saveClass(String className, Class<?>[] interfaces, String pathdir) {        /**           * 第一個參數是 代理類 名 。           * 第二個參數是 代理類需要實現的介面           */          byte[] classFile = ProxyGenerator.generateProxyClass(className, interfaces);        /**           * 如果目錄不存在就新建所有子目錄           */          Path path1 = Paths.get(pathdir);        if (!path1.toFile().exists()){              path1.toFile().mkdirs();          }          String path = pathdir + className + ".class";        try (FileOutputStream fos = new FileOutputStream(path)) {              fos.write(classFile);              fos.flush();              System.out.println("代理類class文件寫入成功");          } catch (Exception e) {              System.out.println("寫文件錯誤");          }      }    /**       * 設置保存Java動態代理生成的類文件。       *       * @throws Exception       */      public static void saveGeneratedJdkProxyFiles() throws Exception {          Field field = System.class.getDeclaredField("props");          field.setAccessible(true);          Properties props = (Properties) field.get(null);          props.put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");      }    }

解析JDK生成的動態代理類

saveGeneratedJdkProxyFiles方法打開了存儲jdk生成的動態代理類以介面方法 goWorking 為例講解

//// Source code recreated from a .class file by IntelliJ IDEA// (powered by Fernflower decompiler)//package com.sun.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;import org.vincent.proxy.dynamicproxy.Person;public final class $Proxy0 extends Proxy implements Person {    private static Method m1;    private static Method m4;    private static Method m3;    private static Method m2;    private static Method m5;    private static Method m0;    public $Proxy0(InvocationHandler var1) throws  {        super(var1);      }    public final boolean equals(Object var1) throws  {        try {            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();          } catch (RuntimeException | Error var3) {            throw var3;          } catch (Throwable var4) {            throw new UndeclaredThrowableException(var4);          }      }    public final void setName(String var1) throws  {        try {            super.h.invoke(this, m4, new Object[]{var1});          } catch (RuntimeException | Error var3) {            throw var3;          } catch (Throwable var4) {            throw new UndeclaredThrowableException(var4);          }      }    public final String getName() throws  {        try {            return (String)super.h.invoke(this, m3, (Object[])null);          } catch (RuntimeException | Error var2) {            throw var2;          } catch (Throwable var3) {            throw new UndeclaredThrowableException(var3);          }      }    public final String toString() throws  {        try {            return (String)super.h.invoke(this, m2, (Object[])null);          } catch (RuntimeException | Error var2) {            throw var2;          } catch (Throwable var3) {            throw new UndeclaredThrowableException(var3);          }      }    /**      * 對介面  goWorking 的調用 轉變成   super.h.invoke(this, m5, new Object[]{var1, var2}); 調用。      * h 就是Proxy.java類的一個 InvocationHandler 介面 屬性，      * 我們在創建 動態代理類實例時候都必須 傳一個 InvocationHandler 介面的實例過去。 這裡就是剛才我們定義的 PersonInvocationHandler 。      * 回到過後是不是就回到了 PersonInvocationHandler.invoke方法裡面，所以 PersonInvocationHandler 是我們生成的動態代理類的攔截器，攔截所有方法調用。      */      public final void goWorking(String var1, String var2) throws  {        try {            super.h.invoke(this, m5, new Object[]{var1, var2});          } catch (RuntimeException | Error var4) {            throw var4;          } catch (Throwable var5) {            throw new UndeclaredThrowableException(var5);          }      }    public final int hashCode() throws  {        try {            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();          } catch (RuntimeException | Error var2) {            throw var2;          } catch (Throwable var3) {            throw new UndeclaredThrowableException(var3);          }      }/**  * 靜態程式碼塊，根據動態代理實現的公共介面類介面方法 獲取到所有介面方法 的 Method 實例*/      static {        try {              m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});              m4 = Class.forName("org.vincent.proxy.dynamicproxy.Person").getMethod("setName", new Class[]{Class.forName("java.lang.String")});              m3 = Class.forName("org.vincent.proxy.dynamicproxy.Person").getMethod("getName", new Class[0]);              m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);              m5 = Class.forName("org.vincent.proxy.dynamicproxy.Person").getMethod("goWorking", new Class[]{Class.forName("java.lang.String"), Class.forName("java.lang.String")});              m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);          } catch (NoSuchMethodException var2) {            throw new NoSuchMethodError(var2.getMessage());          } catch (ClassNotFoundException var3) {            throw new NoClassDefFoundError(var3.getMessage());          }      }  }

Jdk為我們的生成了一個叫$Proxy0（這個名字後面的0是編號，有多個代理類會一次遞增）的代理類，這個類文件時默認不會保存在文件，放在記憶體中的，我們在創建代理對象時，就是通過反射獲得這個類的構造方法，然後創建代理對象實例。通過對這個生成的代理類源碼的查看，我們很容易能看出，動態代理實現的具體過程。

我們可以對 InvocationHandler 看做一個中介類，中介類持有一個被代理對象，被Proxy類回調。在invoke方法中調用了被代理對象的相應方法。通過聚合方式持有被代理對象的引用，把客戶端對invoke的調用最終都轉為對被代理對象的調用。

客戶端程式碼通過代理類引用調用介面方法時，通過代理類關聯的中介類對象引用來調用中介類對象的invoke方法，從而達到代理執行被代理對象的方法。也就是說，動態代理Proxy類提供了模板實現，對外提供擴展點，外部通過實現InvocationHandler介面將被代理類納入JDK代理類Proxy。

一個典型的基於JDK動態代理創建對象過程可分為以下四個步驟：

1、通過實現InvocationHandler介面創建自己的調用處理器 IvocationHandler handler = new InvocationHandlerImpl(…);

2、通過為Proxy類指定ClassLoader對象和一組interface代理類需要實現的介面，創建動態代理類類文件，默認JDK並不會保存這個文件到文件中；可以保存起來觀察生成的代理類結構Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});

3、通過上面新建的代理clazz的反射機制獲取動態代理類的一個構造函數，其構造函數入參類型是調用處理器介面(IvocationHandler)類型 Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

4、通過構造函數實例創建代理類實例，此時需將調用處理器對象作為參數被傳入 Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler)); 為了簡化對象創建過程，Proxy類中的newInstance工具方法封裝了2~4，只需兩步即可完成代理對象的創建。

JDK動態代理特點總結

生成的代理類：$Proxy0 extends Proxy implements Person，我們看到代理類繼承了Proxy類，Java的繼承機制決定了JDK動態代理類們無法實現對類的動態代理。所以也就決定了java動態代理只能對介面進行代理，
每個生成的動態代理實例都會關聯一個調用處理器對象，可以通過 Proxy 提供的靜態方法 getInvocationHandler 去獲得代理類實例的調用處理器對象。在代理類實例上調用其代理的介面中所聲明的方法時，這些方法最終都會由調用處理器的 invoke 方法執行
代理類的根類 java.lang.Object 中有三個方法也同樣會被分派到調用處理器的 invoke 方法執行，它們是 hashCode，equals 和 toString，可能的原因有：一是因為這些方法為 public 且非 final 類型，能夠被代理類覆蓋；二是因為這些方法往往呈現出一個類的某種特徵屬性，具有一定的區分度，所以為了保證代理類與委託類對外的一致性，這三個方法也應該被調用處理器分派到委託類執行。

JDK動態代理不足

JDK動態代理的代理類位元組碼在創建時，需要實現業務實現類所實現的介面作為參數。如果業務實現類是沒有實現介面而是直接定義業務方法的話，就無法使用JDK動態代理了。(JDK動態代理重要特點是代理介面) 並且，如果業務實現類中新增了介面中沒有的方法，這些方法是無法被代理的（因為無法被調用）。

動態代理只能對介面產生代理，不能對類產生代理

基於CGlib 技術動態代理代理類實現 (基於繼承)

Cglib是針對類來實現代理的，他的原理是對代理的目標類生成一個子類，並覆蓋其中方法實現增強，因為底層是基於創建被代理類的一個子類，所以它避免了JDK動態代理類的缺陷。

但因為採用的是繼承，所以不能對final修飾的類進行代理。final修飾的類不可繼承。

導入maven 依賴

cglib 是基於asm 位元組修改技術。導入 cglib 會間接導入 asm, ant, ant-launcher 三個jar 包。

<!-- cglib 動態代理依賴 begin -->    <dependency>      <groupId>cglib</groupId>      <artifactId>cglib</artifactId>      <version>3.2.5</version></dependency><!-- cglib 動態代理依賴 stop -->

業務類實現

cglib是針對類來實現代理的，原理是對指定的業務類生成他的一個子類，並覆蓋其中的業務方法來實現代理。因為採用的是繼承，所以不能對final修飾的類進行代理。

package org.vincent.proxy.cglibproxy;/**   * @Package: org.vincent.proxy.cglibproxy <br/>   * @Description： Cglib 代理模式中 被代理的委託類 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-17:55 <br/>   */public class Dog {    public String  call() {          System.out.println("wang wang wang");        return "Dog ..";      }  }

方法攔截器實現 MethodInterceptor 介面

package org.vincent.proxy.cglibproxy;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/**   * @Package: org.vincent.proxy.cglibproxy <br/>   * @Description： Cglib 方法攔截器,不用依賴被代理業務類的引用。  <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-17:56 <br/>   */public class CglibMethodInterceptor implements MethodInterceptor {    /**       * 用於生成 Cglib 動態代理類工具方法       * @param target 代表需要 被代理的 委託類的 Class 對象       * @return       */      public Object CglibProxyGeneratory(Class target) {        /** 創建cglib 代理類 start */          // 創建加強器，用來創建動態代理類          Enhancer enhancer = new Enhancer();        // 為代理類指定需要代理的類，也即是父類          enhancer.setSuperclass(target);        // 設置方法攔截器回調引用，對於代理類上所有方法的調用，都會調用CallBack，而Callback則需要實現intercept() 方法進行攔截          enhancer.setCallback(this);        // 獲取動態代理類對象並返回          return enhancer.create();        /** 創建cglib 代理類 end */      }    /**       * 功能主要是在調用業務類方法之前 之後添加統計時間的方法邏輯.       * intercept 因為  具有 MethodProxy proxy 參數的原因 不再需要代理類的引用對象了,直接通過proxy 對象訪問被代理對象的方法(這種方式更快)。       * 當然 也可以通過反射機制，通過 method 引用實例    Object result = method.invoke(target, args); 形式反射調用被代理類方法，       * target 實例代表被代理類對象引用, 初始化 CglibMethodInterceptor 時候被賦值 。但是Cglib不推薦使用這種方式       * @param obj    代表Cglib 生成的動態代理類 對象本身       * @param method 代理類中被攔截的介面方法 Method 實例       * @param args   介面方法參數       * @param proxy  用於調用父類真正的業務類方法。可以直接調用被代理類介面方法       * @return       * @throws Throwable       */      @Override      public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {          System.out.println("before");          MonitorUtil.start();          Object result = proxy.invokeSuper(obj, args);        //Object result = method.invoke(target, args);          System.out.println("after");          MonitorUtil.finish(method.getName());        return result;      }  }

一個切面，用於在方法攔截器中intercept 方法中調用真正業務方法之前之後處理邏輯

package org.vincent.proxy.cglibproxy;/**   * Created by PengRong on 2018/12/25.   * 方法用時監控類,作為一個切面 ，具有兩個方法   */public class MonitorUtil {    private static ThreadLocal<Long> tl = new ThreadLocal<>();    public static void start() {          tl.set(System.currentTimeMillis());      }    /**       * 結束時列印耗時       * @param methodName 方法名       */      public static void finish(String methodName) {        long finishTime = System.currentTimeMillis();          System.out.println(methodName + "方法執行耗時" + (finishTime - tl.get()) + "ms");      }  }

Cglib測試類

package org.vincent.proxy.cglibproxy;import net.sf.cglib.core.DebuggingClassWriter;import net.sf.cglib.proxy.Enhancer;import org.junit.Test;import java.lang.reflect.Field;import java.util.Properties;/**   * @Package: org.vincent.proxy.cglibproxy <br/>   * @Description： TODO <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-18:05 <br/>   */public class CglibTest {    @Test      public void testCglib() throws Exception {            System.out.println(System.getProperty("user.dir"));        /** 開啟 保存cglib生成的動態代理類類文件*/          saveGeneratedCGlibProxyFiles(System.getProperty("user.dir"));        /** 第一種方法: 創建cglib 代理類 start */          // 創建加強器，用來創建動態代理類          Enhancer enhancer = new Enhancer();        // 為代理類指定需要代理的類，也即是父類          enhancer.setSuperclass(Dog.class);        // new 一個新的方法攔截器          CglibMethodInterceptor cglibMethodInterceptor = new CglibMethodInterceptor();        // 設置方法攔截器回調引用，對於代理類上所有方法的調用，都會調用CallBack，而Callback則需要實現intercept() 方法進行攔截          enhancer.setCallback(cglibMethodInterceptor);        // 獲取動態代理類對象並返回          Dog dog = (Dog) enhancer.create();        /** 創建cglib 代理類 end */          System.out.println(dog.call());        // 對於上面這幾步，可以新增一個工具方法 放置在 CglibMethodInterceptor 裡面；也就有了第二種方法          // new 一個新的方法攔截器，該攔截器還順帶一個用於創建代理類的工具方法。看起來簡單很多          cglibMethodInterceptor = new CglibMethodInterceptor();          dog = (Dog) cglibMethodInterceptor.CglibProxyGeneratory(Dog.class);          System.out.println(dog.call());        }    /**       * 設置保存Cglib代理生成的類文件。       *       * @throws Exception       */      public void saveGeneratedCGlibProxyFiles(String dir) throws Exception {          Field field = System.class.getDeclaredField("props");          field.setAccessible(true);          Properties props = (Properties) field.get(null);          System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, dir);//dir為保存文件路徑          props.put("net.sf.cglib.core.DebuggingClassWriter.traceEnabled", "true");      }  }

Cglib 總結

CGlib可以傳入介面也可以傳入普通的類，介面使用實現的方式,普通類使用會使用繼承的方式生成代理類.
由於是繼承方式,如果是 static方法,private方法,final方法等描述的方法是不能被代理的
做了方法訪問優化，使用建立方法索引的方式避免了傳統JDK動態代理需要通過Method方法反射調用.
提供callback 和filter設計，可以靈活地給不同的方法綁定不同的callback。編碼更方便靈活。
CGLIB會默認代理Object中equals,toString,hashCode,clone等方法。比JDK代理多了clone。

靜態代理基於JDK動態代理基於Cglib 動態代理

靜態代理是通過在程式碼中顯式編碼定義一個業務實現類的代理類，在代理類中對同名的業務方法進行包裝，用戶通過代理類調用被包裝過的業務方法；

JDK動態代理是通過介面中的方法名，在動態生成的代理類中調用業務實現類的同名方法；

CGlib動態代理是通過繼承業務類，生成的動態代理類是業務類的子類，通過重寫業務方法進行代理；

靜態代理在編譯時產生class位元組碼文件，可以直接使用，效率高。動態代理必須實現InvocationHandler介面，通過invoke調用被委託類介面方法是通過反射方式，比較消耗系統性能，但可以減少代理類的數量，使用更靈活。cglib代理無需實現介面，通過生成類位元組碼實現代理，比反射稍快，不存在性能問題，但cglib會繼承目標對象，需要重寫方法，所以目標對象不能為final類。

AOP 實現案例

AOP的源碼中用到了兩種動態代理來實現攔截切入功能：jdk動態代理和cglib動態代理。兩種方法同時存在，各有優劣。jdk動態代理是由java內部的反射機制來實現的，cglib動態代理底層則是藉助asm來實現的。總的來說，反射機制在生成類的過程中比較高效，執行時候通過反射調用委託類介面方法比較慢；而asm在生成類之後的相關代理類執行過程中比較高效（可以通過將asm生成的類進行快取，這樣解決asm生成類過程低效問題）。還有一點必須注意：jdk動態代理的應用前提，必須是委託類基於統一的介面。如果沒有上述前提，jdk動態代理不能應用。由此可以看出，jdk動態代理有一定的局限性，cglib這種第三方類庫實現的動態代理應用更加廣泛，且在效率上更有優勢。

實現AOP關鍵特點是定義好兩個角色切點和切面。代理模式中被代理類委託類處於切點角色，需要添加的其他比如校驗邏輯，事務，審計邏輯屬於非功能實現邏輯通過切面類定義的方法插入進去。

JDK動態代理 aop 實現方式

定義切面介面，完成將通用公共方法注入到被代理類介面調用處理中

package org.vincent.aop.dynamicproxy;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： 定義切面介面，切面介面定義了兩個切面方法，分別在切點介面方法執行前和執行後執行 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public interface IAspect {    /**       * 在切點介面方法執行之前執行       * @param args 切點參數列表       * @return       */      boolean startTransaction(Object... args);    /**       * 在切點介面方法執行之後執行       */      void endTrasaction();  }

定義切面實現類

package org.vincent.aop.dynamicproxy;import java.util.Objects;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： 改類作為AOP 模型中切面角色類， 實現切面介面，切面介面定義了兩個切面方法，分別在切點介面方法執行前和執行後執行 。 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public class CustomAspect implements IAspect {    /**       * 對參數 做判空處理       * @param args 切點參數列表       * @return       */      @Override      public boolean startTransaction(Object... args) {          Objects.nonNull(args);        boolean result = true;        for (Object temp :args) {            if (Objects.isNull(temp)){                   result =false;                 break;              }          }        return result;      }    public void endTrasaction() {          System.out.println("I get datasource here and end transaction");      }  }

定義切點角色介面因為是基於JDK實現的Aop ，所以委託類需要基於介面實現。

package org.vincent.aop.dynamicproxy;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： AOP基於動態代理 實現  <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public interface IUserService {    void saveUser(String username, String password) throws Exception;  }

委託類實現

package org.vincent.aop.dynamicproxy;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： UserService介面實現類UserServiceImpl 該類 作為AOP中切點角色，切面定義的方法插入到切點的介面方法 執行前和執行後執行。 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public class UserServiceImpl implements IUserService{    @Override      public void saveUser(String username, String password) throws Exception {          System.out.println("save user[username=" + username + ",password=" + password + "]");      }  }

JDK動態代理生成器工具類

可以看到 generatorJDKProxy 方法入參只有兩個參數一個切點介面引用，一個切面介面引用；在InvocationHandler 內部類中可以完整看到切面類方法是怎麼影響切點程式碼執行邏輯的。

package org.vincent.aop.dynamicproxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.util.Arrays;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： JDK動態代理類生成器 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-16:48 <br/>   */public class JDKDynamicProxyGenerator {    /**       * @param targetPoint 需要被代理的委託類對象       * @param aspect 切面對象,該對象方法將在切點方法之前或之後執行       * @return       */      public static Object generatorJDKProxy(IUserService targetPoint, final IAspect aspect) {        return Proxy.newProxyInstance(                /**                   *   委託類使用的類載入器                   */                  targetPoint.getClass().getClassLoader(),                /**                   * 委託類實現的介面                   */                  targetPoint.getClass().getInterfaces(),                /**                   * 生成的動態代理類關聯的 執行處理器，代理我們的業務邏輯被生成的動態代理類回調                   * 具體邏輯程式碼執行,返回值為方法執行結果, 在aop模型中，委託類的介面方法稱為切點。                   */                  new InvocationHandler() {                    @Override                      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {                        // 執行切面方法,對入參進行校驗                         boolean prepareAction = aspect.startTransaction(args);                       if (prepareAction){                           // 具體邏輯程式碼執行,返回值為方法執行結果                             Object result = method.invoke(targetPoint, args);                             aspect.endTrasaction();                           return result;                         }else {                           throw  new RuntimeException("args: "+ Arrays.toString(args)+"不能為null ");                         }                      }                  });      }  }

測試類

package org.vincent.aop;import org.junit.Test;import org.vincent.aop.dynamicproxy.CustomAspect;import org.vincent.aop.dynamicproxy.IUserService;import org.vincent.aop.dynamicproxy.JDKDynamicProxyGenerator;import org.vincent.aop.dynamicproxy.UserServiceImpl;/**   * @Package: org.vincent <br/>   * @Description： 基於動態代理類AOP測試案例 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-16:56 <br/>   */public class testAopJDKProxy {    @Test      public void testJDKProxy() throws Exception {          System.out.println("無代理前 調用方法 userService.saveUser 輸出......");          IUserService userService = new UserServiceImpl();          userService.saveUser("zby", "1234567890");            System.out.println("有代理後AOP 是怎麼樣的？ Proxy......");          IUserService proxyUserService = (IUserService) JDKDynamicProxyGenerator.generatorJDKProxy(userService, new CustomAspect());          proxyUserService.saveUser("zby", "1234567890");        /** 製造異常,兩個入參都是null   */          proxyUserService.saveUser(null, null);      }  }

Cglib aop 實現方式

定義切面介面

package org.vincent.aop.cglib;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： 定義切面介面，切面介面定義了兩個切面方法，分別在切點介面方法執行前和執行後執行 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public interface IAspect {    /**       * 在切點介面方法執行之前執行       */      void startTransaction();    /**       * 在切點介面方法執行之後執行       */      void endTrasaction();  }

切面實現

package org.vincent.aop.cglib;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： 改類作為AOP 模型中切面角色類， 實現切面介面，切面介面定義了兩個切面方法，分別在切點介面方法執行前和執行後執行 。 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public class CustomAspect implements IAspect {    @Override      public void startTransaction() {          System.out.println("cglib. I get datasource here and start transaction");      }    public void endTrasaction() {          System.out.println("cglib I get datasource here and end transaction");      }  }

Cglib 是基於類實現的動態代理即業務類只需要實現類即可，不用強制必須實現某個介面為了突出這個優點這裡沒有實現介面

package org.vincent.aop.cglib;/**   * @Package: org.vincent.aop.dynamicproxy <br/>   * @Description： 業務實現類UserServiceImpl 該類 作為AOP中切點角色，切面定義的方法插入到切點的介面方法 執行前和執行後執行。 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26 <br/>   */public class UserServiceImpl {    public void saveUser(String username, String password) {          System.out.println("cglib save user[username=" + username + ",password=" + password + "]");      }  }

Cglib 動態代理生成器工具類

package org.vincent.aop.cglib;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;import java.lang.reflect.Method;/**   * @Package: org.vincent.aop.cglib <br/>   * @Description： 基於Cglib代理類生成器工具類 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-17:04 <br/>   */public class CglibProxyGenerator {    /**       * @param target 需要被代理的委託類對象，Cglib需要繼承該類生成子類       * @param aspect 切面對象,改對象方法將在切點方法之前或之後執行       * @return       */      public static  Object generatorCglibProxy(final Object target, final IAspect aspect){        //3.1 new Enhancer          Enhancer enhancer = new Enhancer();        //3.2 設置需要代理的父類          enhancer.setSuperclass(target.getClass());        //3.3 設置回調          enhancer.setCallback(new MethodInterceptor() {            @Override              public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)                      throws Throwable {                // 執行切面方法                  aspect.startTransaction();                // 具體邏輯程式碼執行,返回值為方法執行結果                  Object result = methodProxy.invokeSuper(proxy, args);                // 執行切面方法                  aspect.endTrasaction();                // 返回方法執行結果                  return result;              }          });        // 3.4 創建代理對象          return enhancer.create();      }    }

測試類

package org.vincent.aop;import org.junit.Test;import org.vincent.aop.cglib.CglibProxyGenerator;import org.vincent.aop.cglib.CustomAspect;import org.vincent.aop.cglib.UserServiceImpl;/**   * @Package: org.vincent <br/>   * @Description： 基於動態代理類AOP測試案例 <br/>   * @author: lenovo <br/>   * @Company: PLCC <br/>   * @Copyright: Copyright (c) 2019 <br/>   * @Version: 1.0 <br/>   * @Modified By: <br/>   * @Created by lenovo on 2018/12/26-16:56 <br/>   */public class testAopCglibKProxy {    @Test      public void testCglibProxy() {          System.out.println("before Proxy......");          UserServiceImpl userService = new UserServiceImpl();          userService.saveUser("zby", "1234567890");          System.out.println("引入Cglib  Proxy代理庫 後......");          UserServiceImpl proxyUserService = (UserServiceImpl) CglibProxyGenerator.generatorCglibProxy(userService, new CustomAspect());          proxyUserService.saveUser("zby", "1234567890");      }  }

AspectJ 實現 AOP 效果

AOP 實現的關鍵就在於 AOP 框架自動創建的 AOP 代理，AOP 代理則可分為靜態代理和動態代理兩大類:

靜態代理是指使用 AOP 框架提供的命令進行編譯，從而在編譯階段通過AOP框架指令生成 AOP 代理類，因此也稱為編譯時增強；還有一種靜態代理是編寫程式碼實現不用工具；這種方式一般是代理模式會使用。
動態代理則在運行時藉助於 JDK 動態代理、CGLIB 等在記憶體中「臨時」生成 AOP 動態代理類，因此也被稱為運行時增強。

基於 AspectJ 的編譯時增強進行 AOP POM 依賴

原生 AspectJ 不依賴Spring案例, 基於 AspectJ 的編譯時增強進行 AOP 它是在編譯期修改位元組碼，增強功能；並不會生成新的代理類位元組碼。

<!-- AspectJ begin--><dependency>      <groupId>org.aspectj</groupId>      <artifactId>aspectjrt</artifactId>      <version>1.9.2</version></dependency><dependency>      <groupId>org.aspectj</groupId>      <artifactId>aspectjweaver</artifactId>      <version>1.9.2</version></dependency><!-- AspectJ stop-->

動態代理使用場景

日誌集中列印
事務
許可權管理
AOP