1.代理模式

定义：代理模式就是代替对象具备真实对象的功能，并代替真实对象完成相应的操作并且在不改变真实对象源代码的情况下扩展其功能，在某些情况下，⼀个对象不适合或者不能直接引⽤另⼀个对象，⽽代理对象可以在客户端和⽬标对象之间起到中介的作⽤

使用代理模式可以降低系统的耦合性，扩展性好，并且可以起到保护目标对象的作用
例如：我们平时租房的过程,租房中介就相当于代理类
代理模式分为静态代理和动态代理

2.静态代理

静态代理实现步骤:

1. 定义⼀个接⼝及其实现类（目标类）；
2. 创建⼀个代理类同样实现这个接⼝(继承同一个接口的原因就是，代理类需要拥有和目标类同样的方法这样才能代理)
3. 将⽬标对象注⼊进代理类，然后在代理类的对应⽅法调⽤⽬标类中的对应⽅法。

public interface IRentHouse {
    void rent();
}

public class RentHouse implements IRentHouse{
    @Override
    public void rent() {
        System.out.println("租户租房子");
    }
}

public class IntermediaryProxy implements IRentHouse{
    private IRentHouse iRentHouse;
    public IntermediaryProxy(IRentHouse iRentHouse) {
        this.iRentHouse = iRentHouse;
    }
    @Override
    public void rent() {
        System.out.println("交中介费");
        iRentHouse.rent();
        System.out.println("租房子后中介负责维护管理");

    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        // 定义租房
        IRentHouse iRentHouse = new RentHouse();
        // 定义中介
        IRentHouse proxy = new IntermediaryProxy(iRentHouse);
        // 租房
        proxy.rent();
    }
}

运行结果如下：

静态代理有很多缺点，实际应用场景非常少，几乎不用
对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口中一旦新增方法，目标对象和代理对象都要修改），且麻烦（需要对每个目标类都单独写一个代理类）

3.动态代理

相比于静态代理来说，动态代理更加灵活，不需要针对每个目标类都单独创建一个代理类，也不需要我们必须实现接口
动态代理允许使用一种方法的单个类（代理类），为具有任意数量方法的任意类（目标类）的多个方法提供服务，看到这句话，是不是联想到动态代理的实现与Java反射机制密不可分

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个属性和方法，这种动态获取的信息以及动态调用对象的方法的功能称之为Java语言的反射机制

从 JVM ⻆度来说，动态代理是在运⾏时动态⽣成类字节码，并加载到 JVM 中
的。说到动态代理，不得不提的是Spring AOP，它的实现依赖了动态代理

代理类的两个作用
1.添加增强方法，2.调用目标类

1.jdk动态代理（接口代理）

在 Java 动态代理机制中java.long.reflect包中的 InvocationHandler 接⼝和 Proxy 类是核⼼

实际上就是在内存中生产一个对象，该对象实现了指定的目标对象的所有接口，代理对象和目标对象是兄弟关系，
jdk自带动态代理技术，需要使用一个静态方法来创建代理对象，他需要目标对象必须实现接口，生产的代理对象和目标对象都实现同一个接口

JDK 动态代理类使⽤步骤:

1. 定义⼀个接⼝及其实现类；
2. ⾃定义 InvocationHandler 并重写invoke⽅法，在 invoke ⽅法中我们会调⽤ 原⽣⽅法（被代理类的⽅法）并⾃定义⼀些处理逻辑；
3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) ⽅法创建代理对象；

1.定义JDK动态代理类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

// JDK 动态代理类
public class JDKInvocationHandler implements InvocationHandler {

    //⽬标对象即就是被代理对象
    private Object target;

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

    /**
     *
     * @param proxy 代理对象
     * @param method 代理方法
     * @param args 参数
     *
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 1234就是一些增强方法
        //1.安全检查
        System.out.println("安全检查");
        //2.记录⽇志
        System.out.println("记录⽇志");
        //3.时间统计开始
        System.out.println("记录开始时间");
        //通过反射调⽤被代理类的⽅法
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        System.out.println("记录结束时间");
        return retVal;
    }
}

2.创建⼀个代理对象并使用

public class Main {
    public static void main(String[] args) {
        // 代理对象
        PayService target= new AliPayService();
        // 静态的是已经写好了的
        // 动态的创建⼀个代理类：通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
        PayService proxy = (PayService) Proxy.newProxyInstance(
                // 通过目标类的getClassLoader
                target.getClass().getClassLoader(),
                // 被代理类实现的一些接口
                new Class[]{PayService.class},
                // 实现了InvocationHandler接口的对象
                new JDKInvocationHandler(target)
        );
        proxy.pay();
    }

}

Proxy 类中使⽤频率最⾼的⽅法是：newProxyInstance() ，这个⽅法主要⽤来⽣成⼀个代理对象

public static Object newProxyInstance(ClassLoader loader,
									Class<?>[] interfaces,
 									InvocationHandler h)
 									throws IllegalArgumentException
 {
 ....
 }

这个⽅法⼀共有 3 个参数：

1. loader :类加载器，⽤于加载代理对象。
2. interfaces : 被代理类实现的⼀些接⼝；
3. h : 实现了 InvocationHandler 接⼝的对象；

运行main方法

JDK 动态代理有⼀个最致命的问题是其只能代理实现了接⼝的类，为了解决这个问题，我们可以⽤ CGLIB 动态代理机制来避免

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

在 CGLIB 动态代理机制中 MethodInterceptor 接⼝和 Enhancer 类是核⼼

2.CGLIB 动态代理类使⽤步骤

1. 定义⼀个类；
2. ⾃定义 MethodInterceptor 并重写 intercept ⽅法，intercept ⽤于拦截增强
   被代理类的⽅法，和 JDK 动态代理中的 invoke ⽅法类似；
3. 通过 Enhancer 类的 create()创建代理类

1.添加依赖

和JDK 动态代理不同, CGLIB(Code Generation Library) 实际是属于⼀个开源项⽬，如果你要使⽤它的话，需要⼿动添加相关依赖

<dependency>
 <groupId>cglib</groupId>
 <artifactId>cglib</artifactId>
 <version>3.3.0</version>
</dependency>

2.⾃定义 MethodInterceptor（⽅法拦截器）

public class CGLIBInterceptor implements MethodInterceptor {
 //被代理对象
 private Object target;
 public CGLIBInterceptor(Object target){
 this.target = target;
 }
 @Override
 public Object intercept(Object o, Method method, Object[] args, Method
Proxy methodProxy) throws Throwable {
 //1.安全检查
 System.out.println("安全检查");
 //2.记录⽇志
 System.out.println("记录⽇志");
 //3.时间统计开始
 System.out.println("记录开始时间");
 //通过cglib的代理⽅法调⽤
 Object retVal = methodProxy.invoke(target, args);
 //4.时间统计结束
 System.out.println("记录结束时间");
 return retVal;
 }
}

3.创建代理类, 并使⽤

public static void main(String[] args) {
 PayService target= new AliPayService();
 PayService proxy= (PayService) Enhancer.create(target.getClass(),ne
w CGLIBInterceptor(target));
 proxy.pay();
 }

你需要⾃定义 MethodInterceptor 并重写 intercept ⽅法，intercept ⽤于拦截增强被代理类的⽅法

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

• obj : 被代理的对象（需要增强的对象）
• method : 被拦截的⽅法（需要增强的⽅法）
• args : ⽅法⼊参
• proxy : ⽤于调⽤原始⽅法

3.JDK 动态代理和 CGLIB 动态代理对⽐：

• JDK 动态代理只能代理实现了接⼝的类或者直接代理接⼝，⽽ CGLIB 可以代理未实现任何接⼝的类
• CGLIB动态代理是通过⽣成⼀个被代理类的⼦类来拦截被代理类的⽅法调⽤，因此不能代理声明为 final

性能: ⼤部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显

Spring代理选择

1. proxyTargetClass 为false, ⽬标实现了接⼝, ⽤jdk代理
2. proxyTargetClass 为false, ⽬标未实现接⼝, ⽤cglib代理
3. proxyTargetClass 为true, ⽤cglib代理

下篇见~