这一期来聊一聊代理模式：

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。
代理这个词 很容易想到最直接的含义 就是A代替B执行B的内容/A是B的代理人。

我们创建一个接口hero 定义一个方法 attack。这意味它的实现类HeroA要具体实现这个方法。正常的逻辑下这就结束了。
但是这时候我们不想把HeroA直接暴露出去，我们想让一个代理类执行HeroA的方法。 所以我们再来一个HeroProxy ，
它内置了HeroA对象 并初始化一个实例调用Hero的方法。 这样调用HeroProxy.attack()就达到了代理的目的。

（注意如果代理类的方法名称是和被代理对象的方法相同的话，比如下面代码中都是attack（）方法，那么你需要让它也实现方法对应的接口。）

public interface Hero {
    void attack();
}
--------------------
public class HeroA implements Hero {
    @Override
    public void attack(){
        System.out.println("hero a ! attack!");
    }
}
--------------------
public class HeroProxy implements Hero {
    private HeroA heroA;

    @Override
    public void attack(){
        System.out.println("hero's proxy is execute!");
        heroA=new HeroA();
        heroA.attack(); //  $$$
    }
}

ok 这是代理模式的基础 也是最简单的范例，在这个基础上 有两个比较重要的拓展：

静态代理

和上一个例子性质是相同的，可能你发现了：
1 在$$$标注方法的前后 我们可以手动加一些其他的 作为代理类的增强。但是手动加是比较麻烦的
2 接口的方法一旦改动了 那么代理类和被代理类都要改动 这是非常麻烦的 在实际开发中

动态代理

（动态代理简直是天才的设计！我个人觉得）

JDK 动态代理机制

InvocationHandler 接口 和 Proxy 类 是这个机制的核心。

在Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象
在参数里面 会把被代理类的实现的接口传进来，（比如上一个例子中 Hero就是代理对象实现的接口）

要实现动态代理的话，还必须需要实现InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现InvocationHandler 接口类的 invoke 方法来调用。

invoke() 方法有下面三个参数：
proxy :动态生成的代理类
method : 与代理类对象调用的方法相对应
args : 当前 method 方法的参数

也就是说：你通过Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现InvocationHandler 接口的类的 invoke()方法。 你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

（了解java的朋友看到 这几个词汇 invoke InvocationHandler 、貌似眼熟 脑子里瞬间就会出现“反射”的影子，没错的它的核心机制就是依靠反射实现的）
（上面的文字描述可能你会很晕 晕是正常的 下面具体来演示）
还是上面那个例子：
首先我们实现了Hero接口 和 HeroA的接口实现 里面有attack（）方法。 这时候我们想创建一个代理类。 跟上面代码一模一样.
为了方便。 为了更好的理解代码 我们来从后往前倒着看。

JdkProxyFactory.getProxy(new HeroA()); 这个工厂类直接帮我们实现了HeroA()的代理类。我们不需再手动创建代理类了

被代理类作为一个参数传了进去。那么它是怎么实现的呢

public class ExecuteDemo {
    public static void main(String[] args) {
        //jdk动态代理
        Hero heroproxy = (Hero)JdkProxyFactory.getProxy(new HeroA());
        heroproxy.attack();
        
        //动态代理
       HeroProxy heroProxy =new HeroProxy(hero);
       heroProxy.attack();

    }
}

倒着看代码 发现 这个代理类 是被Proxy.newProxyInstance(）创建出来的。它的三个参数都与你传入的HeroA有关。

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new HeroInvocationHandler(target) // 代理对象对应的自定义 InvocationHandler
        );
    }
}

前两个都是反射获取类的信息 第三个参数是一个方法的返回值 这个方法内部是什么样的呢

public class HeroInvocationHandler implements  InvocationHandler{
    private final Object target;

    public HeroInvocationHandler(Object target){
        this.target=target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        System.out.println("before method " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("after method " + method.getName());
        return result;
}
}

这里的核心方法就是 public Object invoke。它重写了反射里面invoke方法。传入methood，参数，Object对象
在里面你就可以自定义很多事情了 在调用方法前后 加一些自己你想加的东西 这就实现了代理功能。
“动态“的精髓就体现在 参数上面 你可以传任意object 不需要手动的去创建代理类。

CGLIB 动态代理类

JDK 动态代理有一个最致命的问题是其只能代理实现了接口的类。
就是说上一个例子heroA如果没实现Hero，那么jdk动态代理就失效了。
为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。(一个接口 一个代理创建类 跟jdk动态代理有几分神似对吧)
你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;
}

obj :被代理的对象（需要增强的对象） heroA
method :被拦截的方法（需要增强的方法） attcak（）
args :方法入参
proxy :用于调用原始方法

Enhancer类和jdk动态里面的proxy类似 不过后者是工厂模式创建的

public class CglibProxyFactory {

    public static Object getProxy(Class<?> clazz) {
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

注意：CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

如果你理解了这两种机制，理解AOP 就是水到渠成了！