Java基础----反射（二）代理模式、静态代理和动态代理

1. 设计模式之代理模式

代理模式是给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。代理模式有三种角色：

抽象主题角色(Subject)： 可以是抽象类，也可以是接口。抽象主题是一个普通的业务类型，无特殊要求。
具体主题角色(RealSubject)： 也叫做被委托角色或被代理角色，是业务逻辑的具体执行者。
代理主题角色(Proxy)： 也叫做委托类或代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在具体主题角色处理完毕前后做预处理和善后处理工作。

2. 静态代理和动态代理

静态代理： 使用静态代理时,被代理对象与代理对象需要一起实现相同的接口或者是继承相同父类，因此要定义一个接口或抽象类。
优点：静态代理可以做到在不修改目标对象的功能前提下,对目标功能扩展。
缺点：静态代理的代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。

静态代理实例:

/**
 * @author ysh
 * @create 2020-05-31-14:44
 * @Description
 *
 * 静态代理模式
 *
 * 特点：代理类和被代理类在编译期间，就确定下来了。
 */
public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类对象
        NikeClothFactory nike = new NikeClothFactory();

        //创建代理类对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();
    }
}

interface ClothFactory{
    void produceCloth();
}

//代理类
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("代理工厂做收尾工作");
    }
}

//被代理类
class NikeClothFactory implements ClothFactory{


    @Override
    public void produceCloth() {
        System.out.println("nike工厂生产衣服");
    }
}

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理利用Java的反射技术(Java Reflection)生成字节码，在运行时创建一个实现某些给定接口的新类（也称"动态代理类"）及其实例。

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

注意： 这里代理的是接口，不是类和抽象类。
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能使用动态代理，因此这也算是这种方式的缺陷。

为什么一定要实现接口呢？
因为生成的代理类本身已经继承了Proxy类，java是不允许多继承。

动态代理实现

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

提供用于创建动态代理类和动态代理对象的静态方法：
static Class<?> getProxyClass(ClassLoader loader, Class<?>… interfaces) ：创建一个动态代理类所对应的Class对象

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

注意 Proxy.newProxyInstance()方法接受三个参数：

ClassLoader loader:指定当前目标对象使用的类加载器,获取加载器的方法是固定的
Class<?>[] interfaces:指定目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler:指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法

动态代理实现步骤：

1. 创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。

class MyInvocationHandler implements InvocationHandler{
    private Object obj; 需要使用被代理类的对象进行赋值
    public void bind(Object obj){
        this.obj = obj;
    }

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

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

        //上述方法的返回值就作为当前类中的invoke()的返回值。
        return  returnValue;
    }
}

2. 创建被代理的类以及接口

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);
    }
}

3. 通过Proxy的静态方法
   newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个代理类。

class ProxyFactory{
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj){//obj: 被代理类的对象
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
        myInvocationHandler.bind(obj);  //实例化

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

4. 通过代理调用方法。

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

        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        String belief = proxyInstance.getBelief();
        System.out.println(belief);

        proxyInstance.eat("麻辣烫");
    }
}

除此之外还有一种代理，CGLIB代理：
JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要CGLib了。CGLib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。但因为采用的是继承，所以不能对final修饰的类进行代理。JDK动态代理与CGLib动态代理均是实现Spring AOP的基础。

CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。