设计模式---代理模式

1.0 概述

        代理模式是常见的设计模式之一，其中要分清楚代理类（房屋中介）和委托类（房东想要出租房子，委托给中介出租），两者存在关联关系，都实现相同接口，简单来说，我们租房子是通过中介去看房（通过代理对象访问），不直接接触房东，这种存在一种间接性，也是这种间接性可以附加多种功能（中介吹嘘，房屋干净，租房打折等在租房基础上的新功能）。

2.0 静态代理

        静态代理：由程序猿创建，也就是在编译时已经将接口，被代理类、代理类确定下来。程序运行之前，对应的class文件已经被生成。

        静态代理的例子：房东出租房屋，通过中介去出租出去，这里中介就是房东的代理。

1. 创建接口的具体行为

        这里创建一个Rent出租接口，它就是房东类 Landlord和中介类AgencyProxy的公共接口。

/**
 * 租房接口
 *
 */
public interface Rent {

    //出租房屋
    public void rentOut();
}

        2. 房东类（被代理类）

/**
 * 房东
 * 被代理的类
 */
public class Landlord implements Rent {
    Logger logger = LoggerFactory.getLogger(Landlord.class);
    private String LandlordName;

    public Landlord(String landlordName) {
        this.LandlordName = landlordName;
    }

    @Override
    public void rentOut() {
        try {
            //睡1秒钟
            Thread.sleep(1000);
            logger.info("房东-->{} 出租了房屋！！",LandlordName);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

        3. 中介类

/**
 * 代理类，相当于中介
 */
public class AgencyProxy implements Rent {

    private Landlord landlord;

    public AgencyProxy(Rent rent) {
        if(rent.getClass() == Landlord.class){
            this.landlord = (Landlord) rent;
        }

    }
    @Override
    public void rentOut() {
    landlord.rentOut();
    }
}

        通过中介去租房，可以添加一些额外的功能，如

/**
 * 代理类，相当于中介
 */
public class AgencyProxy implements Rent {

    private Landlord landlord;

    public AgencyProxy(Rent rent) {
        if(rent.getClass() == Landlord.class){
            this.landlord = (Landlord) rent;
        }

    }
    @Override
    public void rentOut() {
    System.out.println("额外功能！！！！统一的那种不
    需要每个房东都自己修改自己的，可以通过代理类统一实现")
    landlord.rentOut();
    }
}

        spring的aop就是通过切面实现，通过代理模式。

3.0 动态代理

        代理类在程序运行时创建的代理方式被成为动态代理。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

        动态代理的实现，通过java反射包提供的Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

        这里的Rent公共接口和房东类（被代理）不进行改变和静态代理一致。

        这里需要InvocationHandler和被代理类进行关联，invoke方法中执行的都是被代理类对应的方法。之后通过生成代理类执行方法，都会替换为InvocationHandler中的invoke方法的内容。

        下面来进行实现

@Slf4j
public class LandlordInvocationHandler<T> implements InvocationHandler {


    // invocationHandler 所持有的代理对象，这里指房东对象
    T target;

    public LandlordInvocationHandler(T target) {
        this.target = target;
    }

    /**
     * proxy:代表动态代理对象
     * method：代表正在执行的方法
     * args：代表调用目标方法时传入的实参
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("代理执行的方法名称为--->{}",method.getName());
        MonitorUtil.start();
        Object result = method.invoke(target, args);
        MonitorUtil.end(method.getName());
        return result;
    }
}

        客户端进行执行

        Rent zhangsan = new Landlord("张三");
        Rent lisi = new Landlord("李四");
        //创建一个代理对象关联的对象
        LandlordInvocationHandler<Rent> rentHandler = new LandlordInvocationHandler<>(zhangsan);

        /**
         * 参数1 类加载器
         * 参数2 被代理类所实现的接口
         * 参数3 被增强或者被执行代理对象的方法（invoke）
         */
        //创建一个代理对象代理张三，代理对象执行的方法都被代替为invoke方法
        Rent rentProxy = (Rent) Proxy.newProxyInstance(Rent.class.getClassLoader(),
                     new Class<?>[]{Rent.class}, rentHandler);

        rentProxy.rentOut();

 发现执行方法为invoke（）

 所以可以在invoke方法中进行功能增强，如日志，数据处理等待。

我们可以对InvocationHandler看做一个中介类，中介类持有一个被代理对象，在invoke方法中调用了被代理对象的相应方法。通过聚合方式持有被代理对象的引用，把外部对invoke的调用最终都转为对被代理对象的调用。

代理类调用自己方法时，通过自身持有的中介类对象来调用中介类对象的invoke方法，从而达到代理执行被代理对象的方法。也就是说，动态代理通过中介类实现了具体的代理功能。

4.0 jdk和cglib区别

• JDK动态代理只能对实现了接口的类生成代理，而不能针对类 ，使用的是 Java反射技术实现，生成类的过程比较高效。
• CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法 ，使用asm字节码框架实现，相关执行的过程比较高效，生成类的过程可以利用缓存弥补，因为是继承，所以该类或方法最好不要声明成final 
• JDK代理是不需要第三方库支持，只需要JDK环境就可以进行代理，使用条件:实现InvocationHandler + 使用Proxy.newProxyInstance产生代理对象 + 被代理的对象必须要实现接口
• CGLib必须依赖于CGLib的类库，但是它需要类来实现任何接口代理的是指定的类生成一个子类，覆盖其中的方法，是一种继承但是针对接口编程的环境下推荐使用JDK的代理；