代理模式（结构）

代理模式是什么?

如果用一句话来描述代理模式：

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

在开发以及生活中经常听到正向代理，反向代理这样的词，举例说明

正向代理

由于网络原因我们访问不了谷歌，这时候我们就需要找个梯子，替我们去访问谷歌，并且把我们需要的信息返回，这个梯子代理

反向代理

作为服务端为了安全，我们不想把实际服务器的信息暴露出去，已防止不法分子的攻击，这时候我们我需要一个代理统一接受用户的请求，并且帮助用户请求后端用户返回给用户

为什么要用代理模式？

中介隔离作用：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
开闭原则，增加功能：代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

一言以蔽之就是解耦合，创建一个没法访问对象的代理供我们使用，同时我们又可以在代理对象中加入一些补充的功能，这样完全不会破坏封装，满足开闭原则

有哪几种代理模式？

代理模式的实现有多种方式主要分为静态代理、动态代理。静态代理是由程序员创建或特定工具自动生成源代码，在对其编译。在程序员运行之前，代理类.class文件就已经被创建了。动态代理是在程序运行时通过反射机制动态创建的。

UML

动物有一个睡觉行为，大多数人都没法见到北极熊（RealSubject），我们只能通过动物世界节目组的摄影师（Proxy）去北极拍摄，从传回的画面中我们看到一只北极熊在洞里睡觉，并且画面上还加上了字幕“快看这里有只冬眠的北极熊！”

1、静态代理

Subject

public interface LifeService {
    String sleep();
}

RealSubject

public class WhiteBear implements LifeService {
    @Override
    public String sleep() {
        return "Zzzzzzz";
    }
}

Proxy

public class Proxy implements LifeService {
    // 被代理对象
    private LifeService target;
    
    public Proxy(LifeService target) {
        this.target = target;
    }
    
    @Override
    public String sleep() {
        // 拿到被代理对象行为的返回值，加上辅助功能，一起返回
        return "快看这里有只冬眠的北极熊！ \n" + this.target.sleep();
    }
}

Factory，也可以不用工厂客户端直接new

public class ProxyFactory {

    public static Proxy getLifeServiceProxy(Class clz) throws IllegalAccessException, InstantiationException {
        LifeService target = (LifeService) clz.newInstance();
        return new Proxy(target);
    }
}

Client

public class Test {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        Proxy proxy = ProxyFactory.getLifeServiceProxy(WhiteBear.class);
        System.out.println(proxy.sleep());
    }
    /**
     * 输出：
     * 快看这里有只冬眠的北极熊！
     * Zzzzzzz
     */
}

不足

代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度

2、动态代理 (JDK自带)

Subject

public interface LifeService {
    String sleep();
    String wake();
}

RealSubject

public class Person implements LifeService {
    @Override
    public String sleep() {
        return "晚安晚安";
    }

    @Override
    public String wake() {
        return "早鸭";
    }
}

Proxy

我们实现InvocationHandler这个接口，通过invoke方法去执行代理行为

public class InvocationProxy implements InvocationHandler {

    // 被监控的对象（此例中为Person类实例）
    private LifeService lifeService;
    // 监控启动拿到需要被监控的对象
    public InvocationProxy(LifeService lifeService) {
        this.lifeService = lifeService;
    }

    /**
     * 监控的行为发生时，JVM会拦截到行为执行invoke
     * @param proxy  监控对象：监控行为是否发生
     * @param method 被监控的行为方法
     * @param args   被监控行为方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 因为我们拦截了行为，并且加了一些辅助行为，完成之后我们要替被拦截行为把值返回
        Object result = null;
        String methodName = method.getName();
        if ("sleep".equals(methodName)) {
            result = getTime();
            result += (String) method.invoke(this.lifeService, args);
            retrun result;
        } else if ("wake".equals(methodName)) {
            result = getTime();
            result += (String) method.invoke(this.lifeService, args);
            retrun result; 
        }
        result = method.invoke(this.lifeService, args);
        return result;
    }
    // 辅助方法
    private String getTime() {
        return Clock.systemDefaultZone().instant().toString() + "\n";
    }

}

Factory，也可以不用工厂客户端直接new

public class ProxyFactory {

    public static LifeService getLifeServiceProxyInstance(Class clz) throws IllegalAccessException, InstantiationException {
        // 创建被代理对象
        LifeService target = (LifeService) clz.newInstance();
        // 绑定到代理执行器中
        InvocationHandler handler = new InvocationProxy(target);
        // JVM层面对被代理对象进行监控，行为发生就动态创建代理对象处理
        LifeService $proxy = (LifeService) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                handler);
        return $proxy;
    }
}

Client

public class Test {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, InterruptedException {
        LifeService zhang = ProxyFactory.getLifeServiceProxyInstance(Person.class);
        System.out.println(zhang.sleep());
        System.out.println(zhang.wake());
    }
    /**
     * 输出：
     * 2019-11-10T05:24:16.932Z
     * 晚安晚安
     * 2019-11-10T05:24:16.942Z
     * 早鸭
     */
}

用了动态代理我们把所有代理需要实现的行为集中到了invoke这一个方法去执行，不要再写大量模板代码了，并且我们实际上可以在一个InvocationHandler代理多个接口

不足

如果InvocationHandler中代理了两个接口，两个接口中有完全一模一样的两个方法，就没法去区分了
代理必须基于接口，没有实现接口的类没法被代理

3、三方库Cglib

Cglib 基于 ASM 框架操作字节码帮我们生成需要的代理对象，并且不要求实现接口

加入依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

RealSubject

public class Person {

    public String sleep() {
        return "晚安晚安";
    }

    public String wake() {
        return "早鸭";
    }
}

Proxy

我们的逻辑和JDK自带的动态代理是一样的

public class InvocationProxy implements InvocationHandler {

    // 被监控的对象（此例中为Person类实例）
    private LifeService lifeService;
    // 监控启动拿到需要被监控的对象
    public InvocationProxy(LifeService lifeService) {
        this.lifeService = lifeService;
    }

    /**
     * 监控的行为发生时，JVM会拦截到行为执行invoke
     * @param proxy  监控对象：监控行为是否发生
     * @param method 被监控的行为方法
     * @param args   被监控行为方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 因为我们拦截了行为，并且加了一些辅助行为，完成之后我们要替被拦截行为把值返回
        Object result = null;
        String methodName = method.getName();
        if ("sleep".equals(methodName)) {
            result = getTime();
            result += (String) method.invoke(this.lifeService, args);
            retrun result;
        } else if ("wake".equals(methodName)) {
            result = getTime();
            result += (String) method.invoke(this.lifeService, args);
            retrun result; 
        }
        result = method.invoke(this.lifeService, args);
        return result;
    }
    // 辅助方法
    private String getTime() {
        return Clock.systemDefaultZone().instant().toString() + "\n";
    }

}

Factory，也可以不用工厂客户端直接new

public class ProxyFactory {

    public static Object getCglibProxyInstance(Class clz) throws IllegalAccessException, InstantiationException {
        // Enhancer类是CGLib中的一个字节码增强器
        Enhancer enhancer=new Enhancer();
        // 设置被代理类的字节码文件，这里我们关注的不再是接口
        enhancer.setSuperclass(clz);
        // 创建被代理对象
        Object target = clz.newInstance();
        // 绑定到代理执行器中
        CglibProxy proxy = new CglibProxy(target);
        // 设置回调这个代理对象
        enhancer.setCallback(proxy);
        // 生成返回代理对象
        return enhancer.create();
    }
}

Client

public class Test {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Person zhang = (Person) ProxyFactory.getCglibProxyInstance(Person.class);
        System.out.println(zhang.sleep());
        System.out.println(zhang.wake());
    }
    /**
     * 输出：
     * 2019-11-10T06:01:13.105Z
     * 晚安晚安
     * 2019-11-10T06:01:13.115Z
     * 早鸭
     */
}

不足：

依赖三方库
对于final的类和方法不能代理，因为Cglib 生成的代理类需要重写代理类中所有的方法

JDK动态代理和Cglib动态代理的区别？

JDK动态代理只能对实现了接口的类生成代理，而不能针对类
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法因为是继承，所以该类或方法最好不要声明成fina