代理模式

原文地址：https://www.jianshu.com/p/57dc69b9c418
qq群：614530228

定义：给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。

代理模式的理解

代理模式使用代理对象完成用户请求，屏蔽用户对真实对象的访问。现实世界的代理人被授权执行当事人的一些事宜，无需当事人出面，从第三方的角度看，似乎当事人并不存在，因为他只和代理人通信。而事实上代理人是要有当事人的授权，并且在核心问题上还需要请示当事人。

在软件设计中，使用代理模式的意图也很多，比如因为安全原因需要屏蔽客户端直接访问真实对象，或者在远程调用中需要使用代理类处理远程方法调用的技术细节，也可能为了提升系统性能，对真实对象进行封装，从而达到延迟加载的目的。

代理模式的参与者

代理模式的角色分四种：

角色.png

主题接口：Subject 是委托对象和代理对象都共同实现的接口，即代理类的所实现的行为接口。Request() 是委托对象和代理对象共同拥有的方法。
目标对象：RealSubject 是原对象，也就是被代理的对象。
代理对象：Proxy 是代理对象，用来封装真是主题类的代理类。
客户端：使用代理类和主题接口完成一些工作。

代理模式的分类

代理的实现分为：
静态代理：代理类是在编译时就实现好的。也就是说 Java 编译完成后代理类是一个实际的 class 文件。
动态代理：代理类是在运行时生成的。也就是说 Java 编译完之后并没有实际的class 文件，而是在运行时动态生成的类字节码，并加载到JVM中。

动态代理的实现思路

代理对象和目标对象均实现同一个行为接口。
代理类和目标类分别具体实现接口逻辑。
在代理类的构造函数中实例化一个目标对象。
在代理类中调用目标对象的行为接口。
客户端想要调用目标对象的行为接口，只能通过代理类来操作。

静态代理模式的简单实现

public class ProxyDemo {
    public static void main(String[] args) {
        SubjectProxy proxy = new SubjectProxy(new RealSubject());
        proxy.request();
    }
}

public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("...request...");
    }
}

public class SubjectProxy implements Subject {

    Subject subject;

    public SubjectProxy(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void request() {
        subject.request();
    }
}

目标对象（RealSubject ）以及代理对象（Proxy）都实现了主题接口（Subject）。在代理对象（Proxy）中，通过构造函数传入目标对象（RealSubject），然后重写主题接口（Subject）的request()方法，在该方法中调用目标对象(RealSubject )的request()方法，并可以添加一些额外的处理工作在目标对象（RealSubject）的request()方法的前后。

代理模式的好处：
假如有这样的需求，要在某些模块方法调用前后加上一些统一的前后处理操作，比如在添加购物车、修改订单等操作前后统一加上登陆验证与日志记录处理，该怎样实现？首先想到最简单的就是直接修改源码，在对应模块的对应方法前后添加操作。如果模块很多，你会发现，修改源码不仅非常麻烦、难以维护，而且会使代码显得十分臃肿。

这时候就轮到代理模式上场了，它可以在被调用方法前后加上自己的操作，而不需要更改被调用类的源码，大大地降低了模块之间的耦合性，体现了极大的优势。

静态代理比较简单，上面的简单实例就是静态代理的应用方式，下面介绍本篇文章的主题：动态代理。

动态代理

动态代理的思路和上述思路一致，下面主要讲解如何实现。

动态代理介绍
动态代理是指在运行时动态生成代理类。即，代理类的字节码将在运行时生成并载入当前代理的 ClassLoader。与静态处理类相比，动态类有诸多好处。

不需要为(RealSubject )写一个形式上完全一样的封装类，假如主题接口（Subject）中的方法很多，为每一个接口写一个代理方法也很麻烦。如果接口有变动，则目标对象和代理类都要修改，不利于系统维护；
使用一些动态代理的生成方法甚至可以在运行时制定代理类的执行逻辑，从而大大提升系统的灵活性。

动态代理涉及的主要类
主要涉及两个类，这两个类都是java.lang.reflect包下的类，内部主要通过反射来实现的。
java.lang.reflect.Proxy：这是生成代理类的主类，通过 Proxy 类生成的代理类都继承了 Proxy类。Proxy提供了用户创建动态代理类和代理对象的静态方法，它是所有动态代理类的父类。
java.lang.reflect.InvocationHandler：这里称他为"调用处理器"，它是一个接口。当调用动态代理类中的方法时，将会直接转接到执行自定义的InvocationHandler中的invoke()方法。即我们动态生成的代理类需要完成的具体内容需要自己定义一个类，而这个类必须实现 InvocationHandler接口，通过重写invoke()方法来执行具体内容。

Proxy提供了如下两个方法来创建动态代理类和动态代理实例。

static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) 返
回代理类的java.lang.Class对象。第一个参数是类加载器对象（即哪个类加载
器来加载这个代理类到 JVM 的方法区），第二个参数是接口（表明你这个代
理类需要实现哪些接口），第三个参数是调用处理器类实例（指定代理类中具
体要干什么），该代理类将实现interfaces所指定的所有接口，执行代理对象的
每个方法时都会被替换执行InvocationHandler对象的invoke方法。
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h) 返回代理类实例。参数与上述方法一致。

public interface UserService {

    String getUsername();

    int getAge();

}

public class UserServiceImpl implements UserService {
    @Override
    public String getUsername() {
        return "admin";
    }

    @Override
    public int getAge() {
        return 20;
    }
}

public class UserProxy implements InvocationHandler {

    private Object mProxy;

    public UserProxy(Object proxy) {
        this.mProxy = proxy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(mProxy, args);
    }
}

public class DynamicProxyDemo {

    public static void main(String[] args) {
        // 第一种方式
        UserService userService = new UserServiceImpl();
        UserProxy userProxy = new UserProxy(userService);
        UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), userProxy);
        System.out.println(proxy.getUsername() + "..." + proxy.getAge());

        // 第二种方式
         UserService proxy = (UserService) Proxy.newProxyInstance(UserServiceImpl.class.getClassLoader(), UserServiceImpl.class.getInterfaces(), new UserProxy(new UserServiceImpl()));
         System.out.println(proxy.getUsername() + "..." + proxy.getAge());
    }
}

The end--