JDK 动态代理（Spring AOP 的原理）（面试重点）

代理模式

        也叫委托模式.定义：为其他对象提供⼀种代理以控制对这个对象的访问.它的作⽤就是通过提供⼀个代理类,让我们 在调⽤⽬标⽅法的时候,不再是直接对⽬标⽅法进⾏调⽤,⽽是通过代理类间接调⽤，在某些情况下,⼀个对象不适合或者不能直接引⽤另⼀个对象,⽽代理对象可以在客⼾端和⽬标对象之间起到中介的作⽤.

        使⽤代理前:

使⽤代理后:

        由于静态代理基本不用，所以直接介绍动态代理

        其中静态代理表示在创建代理对象时就已经知道了目标对象是谁，以及要代理执行的操作是什么

        而动态代理就表示在程序运行时根据需要代理的内容来动态的创建代理对象

JDK 动态代理类实现步骤 

        1. 定义⼀个接口（目标对象要进行的操作）及其实现类（目标对象）(静态代理中的 HouseSubject 和 Landlord )

        2. 实现 InvocationHandler 接口并重写 invoke ⽅法，在 invoke ⽅法中我们会调⽤⽬标⽅法(被代理类的⽅法)并⾃定义⼀些处理逻辑（定义代理对象的逻辑）

        3. 通过 Proxy.newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h) ⽅法创建代理对象

1.首先定义接口 HouseSubject 声明 目标对象需要被代理的操作

//声明房东（目标对象）要执行的相关操作
public interface HouseSubject {
    void rentHouse();   //出租房子
    void saleHouse();   //卖房子
}

2.定义 Landlord 类（目标类）实现  HouseSubject 接口

//房东（目标对象）
public class Landlord implements HouseSubject{
    @Override
    public void rentHouse() {
        System.out.println("房东出租房子");
    }

    @Override
    public void saleHouse() {
        System.out.println("房东卖房子");
    }
}

3.定义 DynamicProxy 类（声明了动态代理的逻辑）实现 InvocationHandler 接口并重写 invoke ⽅法

// JDK 动态代理(通过 JDK 提供的 api 实现动态代理)
public class DynamicProxy implements InvocationHandler {
    private Object target;  //目标对象

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

    //重写 InvocationHandler 接口中的 invoke 方法，执行目标对象需要被代理的方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("中介接手，开始代理");
        //执行目标对象中的方法 target 是目标对象，第二个参数固定传入 args
        Object result=method.invoke(target,args);
        System.out.println("中介离手，结束代理");
        return result;
    }
}

4.定义 DynamicMain 类来创建代理对象并使用

//创建代理对象并使用
public class DynamicMain {
    public static void main(String[] args) {
        //实例化实现了 HouseSubject 接口的对象
        //因为 JDK 动态代理只能代理实现了接⼝的⼀些类
        HouseSubject target=new Landlord();

        //创建代理对象
        HouseSubject proxy=(HouseSubject) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                new Class[]{HouseSubject.class},
                new DynamicProxy(target)
        );

        proxy.rentHouse();
        proxy.saleHouse();
    }
}

        其中创建代理对象用到了 JDK 内置的 Proxy 类调用静态方法 newProxyInstance（）创建代理对象

        代理对象的类型是接口  HouseSubject ，直接调用其中的方法，代理对象就能代理目标对象执行相应的操作

        Proxy 类的 newProxyInstance() 方法介绍

public static Object newProxyInstance(
    ClassLoader loader,
    Class[] interfaces,
    InvocationHandler h) throws IllegalArgumentException{
 //...代码省略  
}

        其中 loader ：类加载器,⽤于加载代理对象（目标对象的类加载器，注意创建目标对象时要用接口 HouseSubject 引用）

                interfaces：被代理类实现的⼀些接⼝（目标类实现的接口）(这个参数的定义,也决定了JDK动态代理只能代理实现了接⼝的 ⼀些类)

                h:实现了 InvocationHandler 接⼝的对象（声明了动态代理逻辑的对象 -> DynamicProxy 的对象）