动态代理（aop底层原理）

动态代理（AOP底层原理）

代理：当你想要调用一个类的某一个方法的时候，你通过另外一个类来调用他的这个方法，调用方法的这个类，叫做代理类，另外一个类就叫做被代理类

简单的说，就是，想要调用某一个类的某一个方法，不是通过这个类的这个对象来调用的，而是通过另一个类来帮它调用的，这就是代理模式

静态代理的通常实现方法：首先有一个接口，这个接口下边有两个实现类，有一个是代理类，有一个是被代理类，被代理类的方法由代理类来执行

静态代理的缺点：假设有很多个接口，那么就需要每一个接口下边都有两个实现类，即代理类和被代理类，这样做的话，就会导致有很多的代理类出现

然而，我们可以利用反射的特点，直接实现一个通用的代理类，这个代理类可以通过被代理类动态的实现对应的代理类

以下代码：Human为那个接口，superMan为被代理类，ProxyFactory为通用的代理类

package ProxyDemo01;

public interface Human {
    public void eat();
    public String myBlief();
}

package ProxyDemo01;

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

/**
 * @ClassName : SuperMan
 * @Author : YuYun
 * @Date : 2022-04-30 17:54:13
 * @Description ：被代理类
 */

public class SuperMan implements Human{
    @Override
    public void eat() {
        System.out.println("i like eating potato");
    }

    @Override
    public String myBlief() {
        return "i belive i can fly";
    }
}

/**
 * @Description : 实现动态代理的两个问题：1，如何根据被代理类动态的创建代理类 2，如何在代理类中调用被代理类中的同名的方法
 * @Author : YuYun
 * @Date : 2022/4/30
 */
class ProxyFactory{
    /**
     * @Description :通过这个方法返回代理类的对象, obj就是被代理类
     * @Author : YuYun
     * @Date : 2022/4/30
     */
    public static Object getProxyInstance(Object obj){ // obj就是那个代理类的对象（superMan）
        MyInvokeHandler handler = new MyInvokeHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

/**
 * @Description : 在Proxy.newProxyInstance()中，要传入一个InvocationHandler的实现类的对象，以下就是那个实现类
 * @Author : YuYun
 * @Date : 2022/4/30
 */
class MyInvokeHandler implements InvocationHandler{

    private Object obj;
    public void bind(Object obj){// obj就是那个代理类的对象（superMan）
        this.obj = obj;
    }
    /**
     * @Description : 通过代理类的对象调用被代理类的某个方法时，就会调用这个方法，简单的说，就是可以通过这个方法调用被代理类中同名的方法
     * @Author : YuYun
     * @Date : 2022/4/30
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(obj, args);// 调用的这个method，就是调用被代理类的方法
    }
}

class ProxyTest{
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        // 获取代理类
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        proxyInstance.eat();
        String s = proxyInstance.myBlief();
        System.out.println(s);
    }
}

运行结果：就是Superman里边的两个方法

i like eating potato
i belive i can fly