五、代理模式詳解

7.代理模式

7.1.課程目標

1、掌握代理模式的應用場景和實現原理。

2、瞭解靜態代理和動態代理的區別。

3、瞭解CGLib和JDK Proxy的根本區別。

4、手寫實現定義的動態代理。

7.2.內容定位

都知道 SpringAOP 是用代理模式實現，到底是怎麼實現的？我們來一探究竟，並且自己仿真手寫
還原部分細節。

7.3.代理模式定義

代理模式（ProxyPattern）是指爲其他對象提供一種代理，以控制對這個對象的訪問，屬於結構型模式。

在某些情況下，一個對象不適合或者不能直接引用另一個對象，而代理對象可以在客戶端和目標
對象之間起到中介的作用。

官方原文：Provide a surrogate or placeholder for another object to control access to it.

首先來看代理模式的通用UML類圖：

代理模式一般包含三種角色：

抽象主題角色（Subject）：抽象主題類的主要職責是聲明真實主題與代理的共同接口方法，該類可以是接口也可以是抽象類；

真實主題角色（RealSubject）：該類也被稱爲被代理類，該類定義了代理所表示的真實對象，是負責執行系統真正的邏輯業務對象；

代理主題角色（Proxy）：也被稱爲代理類，其內部持有 RealSubject 的引用，因此具備完全的對
RealSubject的代理權。客戶端調用代理對象的方法，同時也調用被代理對象的方法，但是會在代理對
象前後增加一些處理代碼。

在代碼中，一般代理會被理解爲代碼增強，實際上就是在原代碼邏輯前後增加一些代碼邏輯，而使調用者無感知。代理模式屬於結構型模式，分爲靜態代理和動態代理。

7.4.代理模式的應用場景

生活中的租房中介、售票黃牛、婚介、經紀人、快遞、事務代理、非侵入式日誌監聽等，都是代理
模式的實際體現。當無法或不想直接引用某個對象或訪問某個對象存在困難時，可以通過也給代理對象
來間接訪問。使用代理模式主要有兩個目的：一是保護目標對象，二是增強目標對象。

7.5.代理模式的通用寫法

下面是代理模式的通用代碼展示。

首先創建代理主題角色ISubject類：

public interface ISubject {
    void request();
}

創建真實主題角色RealSubject類：

public class RealSubject implements ISubject {
    public void request() {
        System.out.println("real service is called.");
    }
}

創建代理主題角色Proxy類：

public class Proxy implements ISubject {

    private ISubject subject;

    public Proxy(ISubject subject){
        this.subject = subject;
    }

    public void request() {
        before();
        subject.request();
        after();
    }

    public void before(){
        System.out.println("called before request().");
    }

    public void after(){
        System.out.println("called after request().");
    }
}

客戶端調用代碼：

public class Client {
    public static void main(String[] args) {
        Proxy proxy = new Proxy(new RealSubject());
        proxy.request();
    }
}

運行結果

called before request().
real service is called.
called after request().

7.6.從靜態代理到動態代理

舉個例子，有些人到了適婚年齡，其父母總是迫不及待地希望早點抱孫子。而現在在各種壓力之下，
很多人都選擇晚婚晚育。於是着急的父母就開始到處爲自己的子女相親，比子女自己還着急。下面來看代碼實現。

靜態代理：

創建頂層接口IPerson的代碼如下：

public interface IPerson {
    void findLove();
}

兒子張三要找對象，實現ZhangSan類：

public class ZhangSan implements IPerson {
    public void findLove() {
        System.out.println("兒子要求：膚白貌美大長腿");
    }
}

父親張老三要幫兒子張三相親，實現Father類：

public class ZhangLaosan implements IPerson {

    private ZhangSan zhangsan;

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

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

來看測試代碼：

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

運行結果:

張老三開始物色
兒子要求：膚白貌美大長腿
開始交往

但上面的場景有個弊端，就是自己父親只會給自己的子女去物色對象，別人家的孩子是不會管的。

但社會上這項業務發展成了一個產業，出現了媒婆、婚介所等，還有各種各樣的定製套餐。如果還使用靜態代理成本就太高了，需要一個更加通用的解決方案，滿足任何單身人士找對象的需求。

這就是由靜態代理升級到了動態代理。

採用動態代理基本上只要是人（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 class Test {
    public static void main(String[] args) {
        JdkMeipo jdkMeipo = new JdkMeipo();
        IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());
        zhangsan.findLove();
        
        IPerson zhaoliu = jdkMeipo.getInstance(new ZhaoLiu());
        zhaoliu.findLove();
    }
}

運行效果如下：

我是媒婆，已經收集到你的需求，開始物色
張三要求：膚白貌美大長腿
雙方同意，開始交往
我是媒婆，已經收集到你的需求，開始物色
趙六要求：有車有房學歷高
雙方同意，開始交往

7.7.靜態模式在業務中的應用

這裏“小夥伴們”可能會覺得還是不知道如何將代理模式應用到業務場景中，我們來看一個實際的業務場景。

在分佈式業務場景中，通常會對數據庫進行分庫分表，分庫分表之後使用 Java操作時就可能需要配置多個數據源，我們通過設置數據源路由來動態切換數據源。

先創建Order訂單類：

@Data
public class Order {
    private Object orderInfo;
    //訂單創建時間進行按年分庫
    private Long createTime;
    private String 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();
    }

    public int createOrder(Order order) {
        System.out.println("OrderService調用orderDao創建訂單");
        return orderDao.insert(order);
    }
}

接下來使用靜態代理，主要完成的功能是：根據訂單創建時間自動按年進行分庫。

根據開閉原則，我們修改原來寫好的代碼邏輯，通過代理對象來完成。

先創建數據源路由對象，使用ThreadLocal的單例實現DynamicDataSourceEntity類：

public class DynamicDataSourceEntity {

    public final static String DEFAULE_SOURCE = null;

    private final static ThreadLocal<String> local = new ThreadLocal<String>();

    private DynamicDataSourceEntity(){}

    public static String get(){return  local.get();}

    public static void restore(){
         local.set(DEFAULE_SOURCE);
    }

    //DB_2018
    //DB_2019
    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 + "】數據源處理數據" );
        DynamicDataSourceEntity.set(dbRouter);
        this.orderService.createOrder(order);
        DynamicDataSourceEntity.restore();
        after();
        return 0;
    }

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

來看測試代碼：

public class DbRouteProxyTest {
    public static void main(String[] args) {
        try {
            Order order = new Order();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2020/03/01");
            order.setCreateTime(date.getTime());
            IOrderService orderService = new OrderServiceStaticProxy(new OrderService());
            orderService.createOrder(order);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

運行結果如下：

Proxy before method.
靜態代理類自動分配到【DB_2020】數據源處理數據
OrderService調用orderDao創建訂單
OrderDao創建Order成功!
Proxy after method.

結果符合我們的預期。現在再來回顧一下類圖，看是不是和我們最先畫的一致，如下圖所示。

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

7.8.動態代理在業務中的應用

上面的案例理解了，我們再來看數據源動態路由業務，幫助“小夥伴們”加深對動態代理的印象。

創建動態代理的類OrderServiceDynamicProxy：

package com.gupaoedu.vip.pattern.proxy.dbroute.proxy;

import com.gupaoedu.vip.pattern.proxy.dbroute.db.DynamicDataSourceEntity;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.text.SimpleDateFormat;
import java.util.Date;

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 + "】數據源處理數據");
            DynamicDataSourceEntity.set(dbRouter);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

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

測試代碼如下：

public class DbRouteProxyTest {
    public static void main(String[] args) {
        try {
            Order order = new Order();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
            Date date = sdf.parse("2020/03/01");
            order.setCreateTime(date.getTime());
            IOrderService orderService = (IOrderService) new OrderServiceDynamicProxy().getInstance(new OrderService());
            orderService.createOrder(order);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

運行效果如下：

Proxy before method.
靜態代理類自動分配到【DB_2020】數據源處理數據
OrderService調用orderDao創建訂單
OrderDao創建Order成功!
Proxy after method.

依然能夠達到相同運行效果。但是，使用動態代理實現之後，我們不僅能實現 Order的數據源動態
路由，還可以實現其他任何類的數據源路由。當然，有個比較重要的約定，必須實現getCreateTime()
方法，因爲路由規則是根據時間來運算的。我們可以通過接口規範來達到約束的目的，在此就不再舉例。

7.9.手寫JDK動態代理實現原理

不僅知其然，還得知其所以然。既然JDK動態代理功能如此強大，那麼它是如何實現的呢？我們現
在來探究一下原理，並模仿JDK動態代理動手寫一個屬於自己的動態代理。

我們都知道JDK動態代理採用字節重組，重新生成對象來替代原始對象，以達到動態代理的目的。

JDK動態代理的實現原理

獲取被代理對象的引用，並且獲取它的所有接口（反射獲取）。
JDK Proxy類重新生成一個新的類，實現了被代理類所有接口的方法。
動態生成Java代碼，把增強邏輯加入到新生成代碼中。
編譯生成新的Java代碼的class文件。
加載並重新運行新的class，得到類就是全新類。

CGLib動態代理容易踩的坑

無法代理final修飾的方法。

以上過程就叫字節碼重組。JDK中有一個規範，在ClassPath下只要是$開頭的.class文件，一般都是自動生成的。那麼我們有沒有辦法看到代替後的對象的“真容”呢？做一個這樣測試，我們將內存中
的對象字節碼通過文件流輸出到一個新的.class文件，然後利用反編譯工具查看其源代碼。

public class Test {
    public static void main(String[] args) {
        JdkMeipo jdkMeipo = new JdkMeipo();
        IPerson zhangsan = jdkMeipo.getInstance(new Zhangsan());
        zhangsan.findLove();
        // 通過反編譯工具可以查看源代碼
        try {
            byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{IPerson.class});
            FileOutputStream os = new FileOutputStream("F://$Proxy0.class");
            os.write(bytes);
            os.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

運行以上代碼，我們能在E盤下找到一個$Proxy0.class 文件。使用Jad反編譯，得到$Proxy0.jad
文件，打開它可以看到如下內容：

import com.gupaoedu.vip.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});
        } 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);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("findLove");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("buyInsure");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } 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 {
    Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable;
}

創建GPProxy類：

/**
 * 用來生成源代碼的工具類
 */
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 = generateSrc(interfaces);

		   //System.out.println(src);
           //2、Java文件輸出磁盤
           String filePath = GPProxy.class.getResource("").getPath();
		   //System.out.println(filePath);
           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 class Test {
    public static void main(String[] args) {
        GpMeipo gpMeipo = new GpMeipo();
        IPerson zhangsan = gpMeipo.getInstance(new Zhangsan());
        zhangsan.findLove();
    }
}

運行效果如下：

我是媒婆，已經收集到你的需求，開始物色
張三要求：膚白貌美大長腿
雙方同意，開始交往

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

7.10.CGLib代理調用API及原理分析

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

public class CGlibMeipo implements MethodInterceptor {

    public Object getInstance(Class<?> clazz) throws Exception{
        //相當於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("OK的話，準備辦事");
    }
}

創建單身客戶類Customer：

public class Customer {
    public void findLove(){
        System.out.println("兒子要求：膚白貌美大長腿");
    }
}

有個小細節，CGLib代理的目標對象不需要實現任何接口，它是通過動態繼承目標對象實現動態代
理的。來看測試代碼：

public class CglibTest {
    public static void main(String[] args) {
        try {
            Customer obj = (Customer)new CGlibMeipo().getInstance(Customer.class);
            obj.findLove();         
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

CGLib 代理的實現原理又是怎樣的呢？我們可以在測試代碼中加上一句代碼，將 CGLib 代理後
的.class文件寫入磁盤，然後反編譯來一探究竟，代碼如下：

public class CglibTest {
    public static void main(String[] args) {
        try {
            //JDK是採用讀取接口的信息
            //CGLib覆蓋父類方法
            //目的：都是生成一個新的類，去實現增強代碼邏輯的功能

            //JDK Proxy 對於用戶而言，必須要有一個接口實現，目標類相對來說複雜
            //CGLib 可以代理任意一個普通的類，沒有任何要求

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

            //CGLib 有個坑，CGLib不能代理final的方法
            System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"E://cglib_proxy_classes");
            Customer obj = (Customer) new CGlibMeipo().getInstance(Customer.class);
            System.out.println(obj);
            obj.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

通過調試跟蹤發現，Customer$$EnhancerByCGLIB$$3feeb52a.class 就是 CGLib 代理生成的代
理類，繼承了Customer類。

package com.gupaoedu.vip.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.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class Customer$$EnhancerByCGLIB$$6d99cfc2 extends Customer implements Factory {
    ...
    final void CGLIB$findLove$0() {
        super.findLove();
    }

    public final void findLove() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy);
        } else {
            super.findLove();
        }
    }
    ...
}

我們重寫了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() {
    MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
    if (var10000 == null) {
        CGLIB$BIND_CALLBACKS(this);
        var10000 = this.CGLIB$CALLBACK_0;
    }

    if (var10000 != null) {
        var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy);
    } else {
        super.findLove();
    }
}

調用過程爲：代理對象調用 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 {
            init();
            FastClassInfo fci = fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    }

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

上面的代碼調用就是獲取代理類對應的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 Object invokeSuper(Object obj, Object[] args) throws Throwable {
        try {
            init();
            FastClassInfo fci = fastClassInfo;
            return fci.f2.invoke(fci.i2, obj, args);
        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    }

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

CGLib代理執行代理方法的效率之所以比JDK的高，是因爲CGlib採用了FastClass機制，它的原理簡單來說就是：爲代理類和被代理類各生成一個類，這個類會爲代理類或被代理類的方法分配一個
index（int類型）；這個index當作一個入參，FastClass就可以直接定位要調用的方法並直接進行調
用，省去了反射調用，所以調用效率比JDK代理通過反射調用高。下面我們反編譯一個FastClass看看：

public class test {
    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()
{
    /* 
     * Using a volatile invariant allows us to initialize the FastClass and
     * method index pairs atomically.
     * 
     * Double-checked locking is safe with volatile in Java 5.  Before 1.5 this 
     * code could allow fastClassInfo to be instantiated more than once, which
     * appears to be benign.
     */
    if (fastClassInfo == null)
    {
        synchronized (initLock)
        {
            if (fastClassInfo == null)
            {
                CreateInfo ci = createInfo;

                FastClassInfo fci = new FastClassInfo();
                fci.f1 = helper(ci, ci.c1);
                fci.f2 = helper(ci, ci.c2);
                fci.i1 = fci.f1.getIndex(sig1);
                fci.i2 = fci.f2.getIndex(sig2);
                fastClassInfo = fci;
            }
        }
    }
}

至此，CGLib代理的原理我們就基本搞清楚了，對代碼細節有興趣的“小夥伴”可以自行深入研究。

7.11.CGLib和JDK動態代理對比

（1）JDK動態代理實現了被代理對象的接口，CGLib代理繼承了被代理對象。

（2） JDK動態代理和CGLib代理都在運行期生成字節碼， JDK動態代理直接寫Class字節碼， CGLib
代理使用ASM框架寫Class字節碼，CGlib代理實現更復雜，生成代理類比JDK動態代理效率低。

（3）JDK動態代理調用代理方法是通過反射機制調用的，CGLib代理是通過FastClass機制直接調用方法的，CGLib代理的執行效率更高。

7.12.代理模式與Spring生態

1、代理模式在Spring中的應用

先看ProxyFactoryBean核心方法getObject()，源碼如下：

@Nullable
public Object getObject() throws BeansException {
    this.initializeAdvisorChain();
    if (this.isSingleton()) {
        return this.getSingletonInstance();
    } else {
        if (this.targetName == null) {
            this.logger.info("Using non-singleton proxies with singleton targets is often undesirable. Enable prototype proxies by setting the 'targetName' property.");
        }

        return this.newPrototypeInstance();
    }
}

在getObject()方法中，主要調用 getSingletonInstance()和 newPrototypeInstance()。在 Spring
的配置中如果不做任何設置，那麼 Spring 代理生成的 Bean 都是單例對象。如果修改 scope，則每次
創建一個新的原型對象。newPrototypeInstance()裏面的邏輯比較複雜，我們後面再做深入研究，這裏
先做簡單瞭解。

Spring 利用動態代理實現 AOP 時有兩個非常重要的類：JdkDynamicAopProxy 類和CglibAopProxy類，來看一下類圖，如下圖所示。

7.13.靜態代理和動態代理的本質區別

（1）靜態代理只能通過手動完成代理操作，如果被代理類增加了新的方法，代理類需要同步增加，
違背開閉原則。

（2）動態代理採用在運行時動態生成代碼的方式，取消了對被代理類的擴展限制，遵循開閉原則。

（3）若動態代理要對目標類的增強邏輯進行擴展，結合策略模式，只需要新增策略類便可完成，無須修改代理類的代碼。

7.14.代理模式的優缺點

代理模式具有以下優點：

（1）代理模式能將代理對象與真實被調用目標對象分離。

（2）在一定程度上降低了系統的耦合性，擴展性好。

（3）可以起到保護目標對象的作用。

（4）可以增強目標對象的功能。

當然，代理模式也有缺點：

（1）代理模式會造成系統設計中類的數量增加。

（2）在客戶端和目標對象中增加一個代理對象，會導致請求處理速度變慢。

（3）增加了系統的複雜度。

7.15.Spring中的代理選擇原則

（1）當Bean有實現接口時，Spring就會用JDK動態代理。

（2）當Bean沒有實現接口時，Spring會選擇CGLib代理。

（3）Spring可以通過配置強制使用CGLib代理，只需在Spring的配置文件中加入如下代碼：

<aop:aspectj-autoproxy proxy-target-class="true"/>

7.16.作業

1、請總結靜態代理和動態代理的根本區別。

靜態代理是硬編碼，動態代理是動態生成。

2、繼續完成手寫Proxy類中帶參數方法的代理實現。

Zhangsan添加一個新方法

public void setAge(int age) {
    System.out.println("年齡要求" + age);
}

生成字節碼

    private static Method m3;

	public final void setAge(int var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    static {
        try {        
            m3 = Class.forName("com.gupaoedu.vip.pattern.proxy.dynamicproxy.jdkproxy.IPerson").getMethod("setAge", Integer.TYPE);         
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }

五、代理模式詳解

7.代理模式

7.1.課程目標

7.2.內容定位

7.3.代理模式定義

7.4.代理模式的應用場景

7.5.代理模式的通用寫法

7.6.從靜態代理到動態代理

7.7.靜態模式在業務中的應用

7.8.動態代理在業務中的應用

7.9.手寫JDK動態代理實現原理

JDK動態代理的實現原理

CGLib動態代理容易踩的坑

7.10.CGLib代理調用API及原理分析

7.11.CGLib和JDK動態代理對比

7.12.代理模式與Spring生態

7.13.靜態代理和動態代理的本質區別

7.14.代理模式的優缺點

7.15.Spring中的代理選擇原則

7.16.作業

這個網絡爬蟲代碼，拿到數據之後如何存到csv文件中去？

BGE M3-Embedding 模型介紹

即刻放大鏡。跟隨鼠標，屏幕任意位置放大

【面試準備】【SQL】數據庫有哪些約束？

.NET開源強大、易於使用的緩存框架 - FusionCache

面試，有時候是個運氣活

《offer來了》第六章學習筆記

《offer來了》第四章學習筆記

《offer來了》第五章學習筆記

《offcer來了》第三章學習筆記

《offcer來了》第二章學習筆記

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

linux以太網驅動總結