代理模式Proxy（静态代理和动态代理）

代理设计就是为其他对象提供一种代理以控制对这个对象的访问

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原
始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原
始对象上

应用场景：

• 安全代理：屏蔽对真实角色的直接访问。

• 远程代理：通过代理类处理远程方法调用（RMI）

• 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象

比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开

静态代理

package JavaFour;

/**
 * @ClassName : StaticProxyTest  //类名
 * @Description : 静态代理测试  //描述
 * @Author : Gao //作者
 * @Date: 2022/3/19  19:04
 */
interface ClothFactory {
    public void produceCloth();
}

//被代理类
class NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth() {
        System.out.println("Nike正在生产");
    }
}

//代理类
class ProxyClothFactory implements ClothFactory {
    private ClothFactory clothFactory;

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

    @Override
    public void produceCloth() {
        System.out.println("代理类进行预处理————————————————————————————");
        clothFactory.produceCloth();
        System.out.println("代理类进行后续处理————————————————————————————");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(new NikeClothFactory());
        proxyClothFactory.produceCloth();
    }
}

静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。故需要动态代理

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

动态代理相比于静态代理的优点：
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法

Java动态代理相关API：

• Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象：

1. 参数1：获取类加载器。
2. 参数2：获取被代理类实现的所有接口。
3. 参数3：得InvocationHandler接 口的实现类实例

实现InvocationHandler的类必须实现方法public Object invoke(Object theProxy, Method method, Object[] params)

1. theProxy：代理对象
2. method:要调用的方法
3. params:方法调用时所需要的参数

package JavaFour;

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

/**
 * @ClassName : ProxyTest  //类名
 * @Description : 动态代理的测试  //描述
 * @Author : Gao //作者
 * @Date: 2022/3/19  19:55
 */
//接口
interface Human {
    public void getBelief();

    public void getEat();

}

//被代理类
class SuperMan implements Human {

    @Override
    public void getBelief() {
        System.out.println("I believe I can fly!");
    }

    @Override
    public void getEat() {
        System.out.println("超人爱吃饭");
    }
}

//动态代理的工厂
class ProxyFactory {

    public static Object getProxy(Object obj) {//obj即是被代理对象
        //创建实现InvocationHandler的接口的类
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        //将被被代理类传入，用于方法调用时指定调用被代理类的方法
        myInvocationHandler.setObj(obj);
        //用于创建代理对象
        //参数分别是：类加载器、获取被代理类实现的接口、实现InvocationHandler的接口的类（该类主要实现方法invoke（））
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), myInvocationHandler);
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object obj;//为被代理对象

    public void setObj(Object obj) {
        this.obj = obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object invoke = method.invoke(obj, args);
        return invoke;
    }
}


public class ProxyTest {
    public static void main(String[] args) {
        //创建被代理对象
        SuperMan superMan = new SuperMan();
        //获取代理类并把被代理类传入
        Human proxy = (Human) ProxyFactory.getProxy(superMan);
        //代理类调用的方法实际上调用被代理的方法
        proxy.getBelief();
        proxy.getEat();

//        NikeClothFactory nikeClothFactory = new NikeClothFactory();
//        ClothFactory proxy1 = (ClothFactory) ProxyFactory.getProxy(nikeClothFactory);
//        proxy1.produceCloth();

    }

}