從未有人將代理模式分析得如此透徹-有解無憂

1 從靜態代理到動態代理

舉個例子，有些人到了適婚年齡，會被父母催婚，而現在在各種壓力之下，很多人都選擇晚婚晚育，于是著急的父母就開始到處為子女相親，比子女自己還著急，下面來看代碼實作，創建頂層介面IPerson的代碼如下，


public interface IPerson {

    void findLove();

}

兒子張三要找物件，實作ZhangSan類，


public class ZhangSan implements IPerson {

    public void findLove() {
        System.out.println("兒子張三提出要求");
    }

}

父親張老三要幫兒子張三相親，實作ZhangLaosan類，


public class ZhangLaosan implements IPerson {

    private ZhangSan zhangsan;

    public ZhangLaosan(ZhangSan zhangsan) {
        this.zhangsan = zhangsan;
    }

    public void findLove() {
        System.out.println("張老三開始物色");
        zhangsan.findLove();
        System.out.println("開始交往");
    }

}

來看客戶端測驗代碼，


public class Test {
    public static void main(String[] args) {
        ZhangLaosan zhangLaosan = new ZhangLaosan(new ZhangSan());
        zhangLaosan.findLove();
    }
}

運行結果如下圖所示，

file

但是，上面的場景有個弊端，就是自己的父親只會幫自己的子女去物色物件，別人家的孩子是不會管的，但社會上這項業務發展成了一個產業，出現了媒婆、婚介所等，還有各種各樣的定制套餐，如果還使用靜態代理成本就太高了，需要一個更加通用的解決方案，滿足任何單身人士找物件的需求，這就由靜態代理升級到了動態代理，采用動態代理基本上只要是人（IPerson）就可以提供相親服務，動態代理的底層實作一般不用我們親自去實作，已經有很多現成的API，在Java生態中，目前普遍使用的是JDK自帶的代理和CGLib提供的類別庫，首先基于JDK的動態代理支持來升級一下代碼，
首先創建媒婆（婚介所）類JdkMeipo，


public class JdkMeipo implements InvocationHandler {
    private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }

    private void after() {
        System.out.println("雙方同意，開始交往");
    }

    private void before() {
        System.out.println("我是媒婆，已經收集到你的需求，開始物色");
    }
}

然后創建一個類ZhaoLiu，


public class ZhaoLiu implements IPerson {

    public void findLove() {
        System.out.println("符合趙六的要求");
    }

    public void buyInsure() {

    }

}

最后客戶端測驗代碼如下，


    public static void main(String[] args) {
        JdkMeipo jdkMeipo = new JdkMeipo();

        IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
        zhaoliu.findLove();

    }

運行結果如下圖所示，

file

2 三層架構中的靜態代理

小伙伴們可能會覺得還是不知道如何將代理模式應用到業務場景中，我們來看一個實際的業務場景，在分布式業務場景中，通常會對資料庫進行分庫分表，分庫分表之后使用Java操作時就可能需要配置多個資料源，我們通過設定資料源路由來動態切換資料源，首先創建Order訂單類，


public class Order {
    private Object orderInfo;
    private Long createTime;
    private String id;

    public Object getOrderInfo() {
        return orderInfo;
    }
    public void setOrderInfo(Object orderInfo) {
        this.orderInfo = orderInfo;
    }
    public Long getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Long createTime) {
        this.createTime = createTime;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}

創建OrderDao持久層操作類，


public class OrderDao {
    public int insert(Order order){
        System.out.println("OrderDao創建Order成功!");
        return 1;
    }
}

創建IOrderService介面，


public interface IOrderService {
    int createOrder(Order order);
}

創建OrderService實作類，



public class OrderService implements IOrderService {
    private OrderDao orderDao;

    public OrderService(){
        //如果使用Spring，則應該是自動注入的
        //為了使用方便，我們在構造方法中直接將orderDao初始化
        orderDao = new OrderDao();
    }

    @Override
    public int createOrder(Order order) {
        System.out.println("OrderService呼叫orderDao創建訂單");
        return orderDao.insert(order);
    }
}

然后使用靜態代理，主要完成的功能是：根據訂單創建時間自動按年進行分庫，根據開閉原則，我們修改原來寫好的代碼邏輯，通過代理物件來完成，創建資料源路由物件，使用ThreadLocal的單例實作DynamicDataSourceEntry類，


//動態切換資料源
public class DynamicDataSourceEntry {
   
    //默認資料源  
    public final static String DEFAULT_SOURCE = null;  
  
    private final static ThreadLocal<String> local = new ThreadLocal<String>();  

    private DynamicDataSourceEntry(){}

    //清空資料源
    public static void clear() {
        local.remove();
    }  
    
    //獲取當前正在使用的資料源名字
    public static String get() {
         return local.get();  
    }  

    //還原當前切換的資料源
    public static void restore() {
        local.set(DEFAULT_SOURCE);
    }  
  
    //設定已知名字的資料源 
    public static void set(String source) {
        local.set(source); 
    }

    //根據年份動態設定資料源
    public static void set(int year) {
        local.set("DB_" + year);
    }
}

創建切換資料源的代理類OrderServiceSaticProxy，


public class OrderServiceStaticProxy implements IOrderService {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");

    private IOrderService orderService;
    public OrderServiceStaticProxy(IOrderService orderService){
        this.orderService = orderService;
    }

    public int createOrder(Order order) {
        before();
        Long time = order.getCreateTime();
        Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
        System.out.println("靜態代理類自動分配到【DB_" + dbRouter + "】資料源處理資料");
        DynamicDataSourceEntry.set(dbRouter);
        orderService.createOrder(order);
        after();
        return 0;
    }

    private void before(){
        System.out.println("Proxy before method.");
    }

    private void after(){
        System.out.println("Proxy after method.");
    }

}

來看客戶端測驗代碼，


    public static void main(String[] args) {

        try {

            Order order = new Order();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2017/02/01");
            order.setCreateTime(date.getTime());

            IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
            orderService.createOrder(order);
        }catch (Exception e){
            e.printStackTrace();;
        }

}

運行結果如下圖所示，

file

由上圖可知，結果符合預期，再來回顧一下類圖，看是否與我們最先畫的一致，如下圖所示，

file

動態代理和靜態代理的基本思路是一致的，只不過動態代理的功能更強大，隨著業務的擴展，適應性更強，

3 使用動態代理實作無感知切換資料源

在理解了上面的案例后，再來看資料源動態路由業務，幫助小伙伴們加深對動態代理的印象，創建動態代理的類OrderServiceDynamicProxy，代碼如下，


public class OrderServiceDynamicProxy implements InvocationHandler {

    private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
    private Object target;

    public Object getInstance(Object target){
        this.target = target;
        Class<?> clazz = target.getClass();
        return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(args[0]);
        Object object = method.invoke(target,args);
        after();
        return object;
    }

    private void before(Object target){
        try {
            System.out.println("Proxy before method.");
            Long time = (Long) target.getClass().getMethod("getCreateTime").invoke(target);
            Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
            System.out.println("靜態代理類自動分配到【DB_" + dbRouter + "】資料源處理資料");
            DynamicDataSourceEntry.set(dbRouter);
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    private void after(){
        System.out.println("Proxy after method.");
    }
}

撰寫客戶端測驗代碼如下，


public static void main(String[] args) {

    try {

        Order order = new Order();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
        Date date = sdf.parse("2018/02/01");
        order.setCreateTime(date.getTime());

        IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy(). 
        getInstance(new OrderService());
        orderService.createOrder(order);
    }catch (Exception e){
        e.printStackTrace();
    }

}

由上面代碼可以看出，依然能夠達到相同的運行效果，但是，使用動態代理實作之后，不僅能實作Order的資料源動態路由，還可以實作其他任何類的資料源路由，當然，有一個比較重要的約定，必須實作getCreateTime()方法，因為路由規則是根據時間來運算的，可以通過介面規范達到約束的目的，在此不再舉例，

4 手寫JDK動態代理核心原理

不僅知其然，還得知其所以然，既然JDK動態代理的功能如此強大，那么它是如何實作的呢？現在來探究一下原理，并模仿JDK動態代理手寫一個屬于自己的動態代理，
我們都知道JDK動態代理采用位元組重組，重新生成物件來替代原始物件，以達到動態代理的目的，JDK動態代理生成物件的步驟如下，
（1）獲取被代理物件的參考，并且獲取它的所有介面，反射獲取，
（2）JDK動態代理類重新生成一個新的類，同時新的類要實作被代理類實作的所有介面，
（3）動態生成Java代碼，新加的業務邏輯方法由一定的邏輯代碼呼叫（在代碼中體現），
（4）編譯新生成的Java代碼.class檔案，
（5）重新加載到JVM中運行，
以上程序就叫作位元組碼重組，JDK中有一個規范，在ClassPath下只要是$開頭的.class檔案，一般都是自動生成的，那么有沒有辦法看到代替后的物件的“真容”呢？做一個這樣的測驗，將記憶體中的物件位元組碼通過檔案流輸出到一個新的.class檔案，然后使用反編譯工具查看原始碼，


    public static void main(String[] args) {
        try {
            IPerson obj = (IPerson)new JdkMeipo().getInstance(new Zhangsan());
            obj.findLove();

            //通過反編譯工具查看源代碼
            byte [] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{IPerson.class});
            FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
            os.write(bytes);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

運行以上代碼，可以在E盤找到一個$Proxy0.class檔案，使用Jad反編譯，得到$Proxy0.jad檔案，打開檔案看到如下內容，


import com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements IPerson {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    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 findLove() throws  {
        try {
            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);
        }
    }

    public final void buyInsure() throws  {
        try {
            super.h.invoke(this, m4, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    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);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", 
					new Class[]{Class.forName("java.lang.Object")});
            m3 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
					.getMethod("findLove", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m4 = Class.forName("com.tom.pattern.proxy.dynamicproxy.jdkproxy.IPerson")
					.getMethod("buyInsure", new Class[0]);
            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());
        }
    }
}

我們發現，$Proxy0繼承了Proxy類，同時實作了Person介面，而且重寫了findLove()等方法，在靜態代碼塊中用反射查找到了目標物件的所有方法，而且保存了所有方法的參考，重寫的方法用反射呼叫目標物件的方法，小伙伴們此時一定會好奇：這些代碼是從哪里來的？其實是JDK自動生成的，現在我們不依賴JDK，自己來動態生成原始碼、動態完成編譯，然后替代目標物件并執行，
創建GPInvocationHandler介面，


public interface GPInvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

創建GPProxy類，


/**
 * 用來生成原始碼的工具類
 * Created by Tom.
 */
public class GPProxy {

    public static final String ln = "\r\n";

    public static Object newProxyInstance(GPClassLoader classLoader, Class<?> [] interfaces, 
    GPInvocationHandler h){
       try {
           //1.動態生成原始碼.java檔案
           String src = https://www.cnblogs.com/gupaoedu-tom/p/generateSrc(interfaces);
           //2.Java檔案輸出磁盤
           String filePath = GPProxy.class.getResource("").getPath();

           File f = new File(filePath + "$Proxy0.java");
           FileWriter fw = new FileWriter(f);
           fw.write(src);
           fw.flush();
           fw.close();

           //3.把生成的.java檔案編譯成.class檔案
           JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
           StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
           Iterable iterable = manage.getJavaFileObjects(f);

          JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
          task.call();
          manage.close();

           //4.編譯生成的.class檔案加載到JVM中
          Class proxyClass =  classLoader.findClass("$Proxy0");
          Constructor c = proxyClass.getConstructor(GPInvocationHandler.class);
          f.delete();

           //5.回傳位元組碼重組以后的新的代理物件
           return c.newInstance(h);
       }catch (Exception e){
           e.printStackTrace();
       }
        return null;
    }

    private static String generateSrc(Class<?>[] interfaces){
            StringBuffer sb = new StringBuffer();
            sb.append(GPProxy.class.getPackage() + ";" + ln);
            sb.append("import " + interfaces[0].getName() + ";" + ln);
            sb.append("import java.lang.reflect.*;" + ln);
            sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
                sb.append("GPInvocationHandler h;" + ln);
                sb.append("public $Proxy0(GPInvocationHandler h) { " + ln);
                    sb.append("this.h = h;");
                sb.append("}" + ln);
                for (Method m : interfaces[0].getMethods()){
                    Class<?>[] params = m.getParameterTypes();

                    StringBuffer paramNames = new StringBuffer();
                    StringBuffer paramValues = new StringBuffer();
                    StringBuffer paramClasses = new StringBuffer();

                    for (int i = 0; i < params.length; i++) {
                        Class clazz = params[i];
                        String type = clazz.getName();
                        String paramName = toLowerFirstCase(clazz.getSimpleName());
                        paramNames.append(type + " " +  paramName);
                        paramValues.append(paramName);
                        paramClasses.append(clazz.getName() + ".class");
                        if(i > 0 && i < params.length-1){
                            paramNames.append(",");
                            paramClasses.append(",");
                            paramValues.append(",");
                        }
                    }

                    sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" 							  + paramNames.toString() + ") {" + ln);
                        sb.append("try{" + ln);
                            sb.append("Method m = " + interfaces[0].getName() + ".class. getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
                            sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
                        sb.append("}catch(Error _ex) { }");
                        sb.append("catch(Throwable e){" + ln);
                        sb.append("throw new UndeclaredThrowableException(e);" + ln);
                        sb.append("}");
                        sb.append(getReturnEmptyCode(m.getReturnType()));
                    sb.append("}");
                }
            sb.append("}" + ln);
            return sb.toString();
    }

    private static Map<Class,Class> mappings = new HashMap<Class, Class>();
    static {
        mappings.put(int.class,Integer.class);
    }

    private static String getReturnEmptyCode(Class<?> returnClass){
        if(mappings.containsKey(returnClass)){
            return "return 0;";
        }else if(returnClass == void.class){
            return "";
        }else {
            return "return null;";
        }
    }

    private static String getCaseCode(String code,Class<?> returnClass){
        if(mappings.containsKey(returnClass)){
            return "((" + mappings.get(returnClass).getName() +  ")" + code + ")." + 							returnClass.getSimpleName() + "Value()";
        }
        return code;
    }

    private static boolean hasReturnValue(Class<?> clazz){
        return clazz != void.class;
    }

    private static String toLowerFirstCase(String src){
        char [] chars = src.toCharArray();
        chars[0] += 32;
        return String.valueOf(chars);
    }

}

創建GPClassLoader類，


public class GPClassLoader extends ClassLoader {

    private File classPathFile;
    public GPClassLoader(){
        String classPath = GPClassLoader.class.getResource("").getPath();
        this.classPathFile = new File(classPath);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {

        String className = GPClassLoader.class.getPackage().getName() + "." + name;
        if(classPathFile  != null){
            File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
            if(classFile.exists()){
                FileInputStream in = null;
                ByteArrayOutputStream out = null;
                try{
                    in = new FileInputStream(classFile);
                    out = new ByteArrayOutputStream();
                    byte [] buff = new byte[1024];
                    int len;
                    while ((len = in.read(buff)) != -1){
                        out.write(buff,0,len);
                    }
                    return defineClass(className,out.toByteArray(),0,out.size());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
        return null;
    }
}

創建GPMeipo類，


public class GpMeipo implements GPInvocationHandler {
    private IPerson target;
    public IPerson getInstance(IPerson target){
        this.target = target;
        Class<?> clazz =  target.getClass();
        return (IPerson) GPProxy.newProxyInstance(new GPClassLoader(),clazz.getInterfaces(),this);
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(this.target,args);
        after();
        return result;
    }

    private void after() {
        System.out.println("雙方同意，開始交往");
    }

    private void before() {
        System.out.println("我是媒婆，已經收集到你的需求，開始物色");
    }
}

客戶端測驗代碼如下，


    public static void main(String[] args) {
        GpMeipo gpMeipo = new GpMeipo();
        IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());
        zhangsan.findLove();


    }

至此，手寫JDK動態代理就完成了，小伙伴們是不是又多了一個面試用的“撒手锏”呢？

5 CGLib動態代理API原理分析

簡單看一下CGLib動態代理的使用，還是以媒婆為例，創建CglibMeipo類，


public class CGlibMeipo implements MethodInterceptor {

    public Object getInstance(Class<?> clazz) throws Exception{
        //相當于JDK中的Proxy類，是完成代理的工具類
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) 						     throws Throwable {
        before();
        Object obj = methodProxy.invokeSuper(o,objects);
        after();
        return obj;
    }

    private void before(){
        System.out.println("我是媒婆，我要給你找物件，現在已經確認你的需求");
        System.out.println("開始物色");
    }

    private void after(){
        System.out.println("雙方同意，準備辦婚事");
    }
}

創建單身客戶類Customer，


public class Customer {

    public void findLove(){
        System.out.println("符合要求");
    }
}

這里有一個小細節，CGLib動態代理的目標物件不需要實作任何介面，它是通過動態繼承目標物件實作動態代理的，客戶端測驗代碼如下，


public static void main(String[] args) {

        try {

            //JDK采用讀取介面的資訊
            //CGLib覆寫父類方法
            //目的都是生成一個新的類，去實作增強代碼邏輯的功能

            //JDK Proxy對于用戶而言，必須要有一個介面實作，目標類相對來說復雜
            //CGLib可以代理任意一個普通的類，沒有任何要求

            //CGLib生成代理的邏輯更復雜，呼叫效率更高，生成一個包含了所有邏輯的FastClass，不再需				要反射呼叫
            //JDK Proxy生成代理的邏輯簡單，執行效率相對要低，每次都要反射動態呼叫

            //CGLib有一個缺點，CGLib不能代理final的方法

            Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
            System.out.println(obj);
            obj.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

CGLib動態代理的實作原理又是怎樣的呢？我們可以在客戶端測驗代碼中加上一句代碼，將CGLib動態代理后的.class檔案寫入磁盤，然后反編譯來一探究竟，代碼如下，


public static void main(String[] args) {
    try {

        //使用CGLib的代理類可以將記憶體中的.class檔案寫入本地磁盤
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E://cglib_proxy_class/");

        Customer obj = (Customer)new CglibMeipo().getInstance(Customer.class);
        obj.findLove();

    } catch (Exception e) {
        e.printStackTrace();
    }
}

重新執行代碼，我們會發現在E://cglib_proxy_class目錄下多了三個.class檔案，如下圖所示，

file

通過除錯跟蹤發現，Customer$$EnhancerByCGLIB$$3feeb52a.class就是CGLib動態代理生成的代理類，繼承了Customer類，


package com.tom.pattern.proxy.dynamicproxy.cglibproxy;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.*;

public class Customer$$EnhancerByCGLIB$$3feeb52a extends Customer
    implements Factory
{

    ...

    final void CGLIB$findLove$0()
    {
        super.findLove();
    }

    public final void findLove()
    {
        CGLIB$CALLBACK_0;
        if(CGLIB$CALLBACK_0 != null) goto _L2; else goto _L1
_L1:
        JVM INSTR pop ;
        CGLIB$BIND_CALLBACKS(this);
        CGLIB$CALLBACK_0;
_L2:
        JVM INSTR dup ;
        JVM INSTR ifnull 37;
           goto _L3 _L4
_L3:
        break MISSING_BLOCK_LABEL_21;
_L4:
        break MISSING_BLOCK_LABEL_37;
        this;
        CGLIB$findLove$0$Method;
        CGLIB$emptyArgs;
        CGLIB$findLove$0$Proxy;
        intercept();
        return;
        super.findLove();
        return;
    }

    ...
   
}

我們重寫了Customer類的所有方法，通過代理類的原始碼可以看到，代理類會獲得所有從父類繼承來的方法，并且會有MethodProxy與之對應，比如Method CGLIB$findLove$0$Method、MethodProxy CGLIB$findLove$0$Proxy等方法在代理類的findLove()方法中都有呼叫，



//代理方法（methodProxy.invokeSuper()方法會呼叫）
    final void CGLIB$findLove$0()
    {
        super.findLove();
    }

//被代理方法（methodProxy.invoke()方法會呼叫
//這就是為什么在攔截器中呼叫methodProxy.invoke會發生死回圈，一直在呼叫攔截器）
    public final void findLove()
    {
        ...
        //呼叫攔截器
        intercept();
        return;
        super.findLove();
        return;
    }

呼叫程序為：代理物件呼叫this.findLove()方法→呼叫攔截器→methodProxy.invokeSuper()→ CGLIB$findLove$0→被代理物件findLove()方法，
此時，我們發現MethodInterceptor攔截器就是由MethodProxy的invokeSuper()方法呼叫代理方法的，因此，MethodProxy類中的代碼非常關鍵，我們分析它具體做了什么，


package net.sf.cglib.proxy;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import net.sf.cglib.core.AbstractClassGenerator;
import net.sf.cglib.core.CodeGenerationException;
import net.sf.cglib.core.GeneratorStrategy;
import net.sf.cglib.core.NamingPolicy;
import net.sf.cglib.core.Signature;
import net.sf.cglib.reflect.FastClass;
import net.sf.cglib.reflect.FastClass.Generator;

public class MethodProxy {
    private Signature sig1;
    private Signature sig2;
    private MethodProxy.CreateInfo createInfo;
    private final Object initLock = new Object();
    private volatile MethodProxy.FastClassInfo fastClassInfo;

    public static MethodProxy create(Class c1, Class c2, String desc, String name1, String name2) {
        MethodProxy proxy = new MethodProxy();
        proxy.sig1 = new Signature(name1, desc);
        proxy.sig2 = new Signature(name2, desc);
        proxy.createInfo = new MethodProxy.CreateInfo(c1, c2);
        return proxy;
    }

    ...
    
    private static class CreateInfo {
        Class c1;
        Class c2;
        NamingPolicy namingPolicy;
        GeneratorStrategy strategy;
        boolean attemptLoad;

        public CreateInfo(Class c1, Class c2) {
            this.c1 = c1;
            this.c2 = c2;
            AbstractClassGenerator fromEnhancer = AbstractClassGenerator.getCurrent();
            if(fromEnhancer != null) {
                this.namingPolicy = fromEnhancer.getNamingPolicy();
                this.strategy = fromEnhancer.getStrategy();
                this.attemptLoad = fromEnhancer.getAttemptLoad();
            }

        }
    }
     ...
    
}

繼續看invokeSuper()方法，


public Object invokeSuper(Object obj, Object[] args) throws Throwable {
    try {
        this.init();
        MethodProxy.FastClassInfo fci = this.fastClassInfo;
        return fci.f2.invoke(fci.i2, obj, args);
    } catch (InvocationTargetException var4) {
        throw var4.getTargetException();
    }
}

...

private static class FastClassInfo {
    FastClass f1;
    FastClass f2;
    int i1;
    int i2;

    private FastClassInfo() {
    }
}

上面代碼呼叫獲取代理類對應的FastClass，并執行代理方法，還記得之前生成的三個.class檔案嗎？Customer$$EnhancerByCGLIB$$3feeb52a$$FastClassByCGLIB$$6aad62f1.class就是代理類的FastClass，Customer$$FastClassByCGLIB$$2669574a.class就是被代理類的FastClass，
CGLib動態代理執行代理方法的效率之所以比JDK高，是因為CGlib采用了FastClass機制，它的原理簡單來說就是：為代理類和被代理類各生成一個類，這個類會為代理類或被代理類的方法分配一個index（int型別）；這個index被當作一個入參，FastClass可以直接定位要呼叫的方法并直接進行呼叫，省去了反射呼叫，因此呼叫效率比JDK代理通過反射呼叫高，下面我們來反編譯一個FastClass，


public int getIndex(Signature signature)
    {
        String s = signature.toString();
        s;
        s.hashCode();
        JVM INSTR lookupswitch 11: default 223
        …
        JVM INSTR pop ;
        return -1;
    }

//部分代碼省略

    //根據index直接定位執行方法
    public Object invoke(int i, Object obj, Object aobj[])
        throws InvocationTargetException
    {
        (Customer)obj;
        i;
        JVM INSTR tableswitch 0 10: default 161
           goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8 _L9 _L10 _L11 _L12
_L2:
        eat();
        return null;
_L3:
        findLove();
        return null;
        …
        throw new IllegalArgumentException("Cannot find matching method/constructor");
    }

FastClass并不是跟代理類一起生成的，而是在第一次執行MethodProxy的invoke()或invokeSuper()方法時生成的，并被放在了快取中，


//MethodProxy的invoke()或invokeSuper()方法都呼叫了init()方法
private void init() {
    if(this.fastClassInfo == null) {
        Object var1 = this.initLock;
        synchronized(this.initLock) {
            if(this.fastClassInfo == null) {
                MethodProxy.CreateInfo ci = this.createInfo;
                MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
//如果在快取中，則取出；如果沒在快取中，則生成新的FastClass
                fci.f1 = helper(ci, ci.c1);
                fci.f2 = helper(ci, ci.c2);
                fci.i1 = fci.f1.getIndex(this.sig1);//獲取方法的index
                fci.i2 = fci.f2.getIndex(this.sig2);
                this.fastClassInfo = fci;
            }
        }
    }
}

至此，我們基本清楚了CGLib動態代理的原理，對代碼細節感興趣的小伙伴們可以自行深入研究，

6 CGLib和JDK Proxy對比分析

（1）JDK動態代理實作了被代理物件的介面，CGLib動態代理繼承了被代理物件，
（2）JDK動態代理和CGLib動態代理都在運行期生成位元組碼，JDK動態代理直接寫Class位元組碼，CGLib動態代理使用ASM框架寫Class位元組碼，CGLib動態代理實作更復雜，生成代理類比JDK動態代理效率低，
（3）JDK動態代理呼叫代理方法是通過反射機制呼叫的，CGLib動態代理是通過FastClass機制直接呼叫方法的，CGLib動態代理的執行效率更高，

本文為“Tom彈架構”原創，轉載請注明出處，技術在于分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支持是我堅持創作的動力，關注微信公眾號『 Tom彈架構』可獲取更多技術干貨！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/337877.html

標籤：Java

上一篇：從空格和未知空元素中清除Python字串

下一篇：Java版人臉檢測詳解下篇：編碼