JDK动态代理

什么是代理，为什么需要代理？

代理是一种设计模式。因此本文主要讲的就是Java中代理设计模式的实现。
思想上简单的理解就是有两个类A和B, A是我们的被代理类，B是我们的代理类，我们要执行A的某个方法的时候我们不直接通过对象A调用，而是让 B 和 A实现同一个接口，当然A要执行的这个方法是从接口中重写过来的，因此B也有一个这样的方法，然后在B的这个方法中调用A的这个方法。
被代理的就是A和B的公共方法。这个方法就是在接口中的方法
大概的过程就是这样，代理最为我们熟知的应用场景就是Java的aop编程。

静态代理

静态代理就是跟上面的过程一样。
示例：

package ltd.itlover.tbl;

import java.lang.reflect.Proxy;

/**
 * 静态代理示例
 * 特点：代理类和被代理类在被编译的时候已经确定下来了
 * @author(作者) 路飞
 * @date(日期) 2022/1/11
 **/

//需要被代理的公共方法
interface ClothFactory{
    void produceCloth();
}

//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;

    public ProxyClothFactory(ClothFactory clothFactory){
        this.factory = clothFactory;
    }

    //代理方法
    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        factory.produceCloth();
        System.out.println("工作完成");
    }
}

class NikeClothFactory implements ClothFactory{
    
    //被代理方法
    @Override
    public void produceCloth() {
        System.out.println("生产Nike服饰");
    }
}

public class StaticProxyTest {

    public static void main(String[] args) {
        //被代理的对象
        NikeClothFactory nikeClothFactory = new NikeClothFactory();


        //代理对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);

        //执行代理

        proxyClothFactory.produceCloth();
    }
}

缺点： 这个缺点很明显，每当我们要代理一个类的方法的时候我们都需要写一个代理类。这样只能简单的体现代理模式的思想，去不能体现实用的意义。

JDK动态代理

Java中提供的原生代理方式其实是通过反射来实现的，从我们上面的例子可以知道我们要代理某个类的方法时。我们需要得到：

1. 被代理类的实例
2. 被代理类需要代理的方法

这里重点说一下第二点，获得需要被代理的方法其实就是获得被代理类实现的接口，因为在代理模式中，被代理类需要代理的方法是从接口中重写过来的。

动态代理就是我们要达到这样的要求：我们在使用的时候不管是代理任何类，我们都可以直接使用。
因此，很容易就可以想到反射。

实现

关键方法

Proxy.newInstance

这个方法的作用就是获得一个代理类的实例，需要传递三个参数

• 第一个就是被代理类的类加载器，这个通过反射技术获取
• 第二个是被代理类的实现的接口，因为需要知道这个接口来构造一个实现了该接口所有方法的类，代理类的重点就是要实现这些方法，因为这些方法就是代理类需要被代理的方法。
• 第三个就是一个实现了InvocationHandler接口的类，这个类需要我们自己来定义，代理方法的调用就是在这个接口的Invoke方法中进行。我们可以在代理的前后进行一些其他的操作。

示例：

package ltd.itlover.tbl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.logging.Handler;

/**
 * @author(作者) 唐宝亮
 * @date(日期) 2022/1/11
 **/
interface Human{
    String getBelief();
    void eat(String food);
}

class SuperMan implements Human{
    @Override
    public String getBelief() {
        return "I believe I can fly!!!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我吃了一个" + food);
    }

    /**
     * 要想实现动态代理
     * 需要解决的问题
     * 如何格局被加载到内存中的被代理类，动态的创建一个代理类以及其对象
     * 如何动态的去调用被代理类中的同名方法
     * 其实这里跟反射很像
     */
}

class ProxyFactory{
    public static Object getProxyInstance (Object obj) {
        MyInvocationHandler handler = new MyInvocationHandler();

        handler.bind(obj); 
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

class MyInvocationHandler implements InvocationHandler {

    private Object object;

    public void bind (Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始准备代理");
        Object o = method.invoke(object, args);
        System.out.println("代理工作完成");

        return o;
    }
}

public class DynamicProxy {

    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();

        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);

        proxyInstance.eat("麻辣烫");

        System.out.println(proxyInstance.getBelief());

    }



}