java 代理、静态代理、动态代理

代理

在某些情况下，客户不想或者不能直接引用另一个对象，这时候代理对象可以在客户端和目标对象之间起到中介的作用。

代理对象提供一种代理以控制对委托对象的访问控制，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

通常情况下代理类和委托类实现相同的接口或继承相同的父类，代理类中通过聚合方式持有委托类的对象，代理类对象本身并不真正实现服务，而是通过调用委托类对象的相关方法来提供相关服务，并做一些额外操作。

代理的优点：
一、可以隐藏委托类的实现，实现客户与委托类之间的解耦；
二、在不修改委托类代码的情况下能够做一些额外的处理；

按照代理类的创建时间，代理分为静态代理和动态代理。

静态代理

代理类在代码编译之前已经存在叫做静态代理，一般由程序员创建。

静态代理类通常只代理一个委托类。

/**
 * 静态代理类和委托类需要共同实现的接口
 * */
public interface Subject {

    void sell();

    void print(String msg);

}

/**
 * 委托类，实现了接口
 * */
public class RealSubject implements Subject {

    @Override
    public void sell() {
        System.out.println("in sell method");
    }

    @Override
    public void print(String msg) {
        System.out.println("in print method, msg " + msg);
    }

}

/**
 * 静态代理类
 * 也实现了接口，但接口方法和实现是调用了委托类的实现
 * 静态代理类在方法中对委托类的实现进行了增强，甚至过滤
 * */
public class ProxySubject implements Subject {

    private Subject subject;  // 代理类通过聚合持有委托类实现对象的引用

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

    @Override
    public void sell() {
        System.out.println("before");
        subject.sell();    // 代理类中调用委托类的实现
        System.out.println("after");
    }

    @Override
    public void print(String msg) {
        System.out.println("before");
        subject.print(msg);    // 代理类中调用委托类的实现
        System.out.println("after");
    }

}

public class Client {

    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();  // 事先已存在的委托类对象

        ProxySubject proxySubject = new ProxySubject(realSubject);  // 创建代理类，传入已存在的委托类对象
        proxySubject.sell();  // 调用代理类方法，代理类中调用委托类对象相关方法实现服务
        proxySubject.print("this is message");
    }

}

动态代理

代理类在程序运行时创建的代理方式叫做动态代理。

首先通过newProxyInstance方法创建代理类并获取代理类实例，而后我们便可以通过这个代理类实例调用代理类的方法，对代理类的方法的调用实际上都会调用中介类(调用处理器)的invoke方法，在invoke方法中我们调用委托类的相应方法，并且可以添加自己的处理逻辑。

动态代理的接口和委托类与静态代理相同。

/**
 * 中介类
 * */
public class DynamicProxy implements InvocationHandler {

    // 中介类通过聚合方式持有委托类对象，subject为委托类对象
    // 外部对代理类对象的调用转化为对invoke的调用，invoke内再调委托类对象
    // 中介类与委托类构成了静态代理关系，在这里，中介类就是代理类，委托类就是委托类
    private Object subject;

    public DynamicProxy(Object obj) {
        this.subject = obj;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before");
        Object result = method.invoke(subject, args);
        System.out.println("after");
        return result;    // 可以返回 null
    }

}

public class Main {

    public static void main(String[] args) {
        // 创建被委托类对象
        RealSubject vendor = new RealSubject();
        // 创建中介类实例
        DynamicProxy inter = new DynamicProxy(vendor);
        // 加上这句将会产生一个$Proxy0.class文件，这个文件即为动态生成的代理类文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");

        // 获取代理类实例sell
        // 动态生成代理类，代理类的方法由接口指定，代理类方法的调用由handler处理，handler中方法的处理由委托类处理
        Subject proxySubject = (Subject) Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[] {Subject.class}, inter);

        // 通过代理类对象调用代理类方法，实际上会转到invoke方法调用
        proxySubject.sell();
        proxySubject.print("this is message");
    }

}

首先，通过Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[] {Subject.class}, handler);在程序运行时生成动态代理类。参数1是生成动态代理类的类加载器；参数2是生成的代理类要实现的接口；参数3是调用代理类方法后实际处理方法调用的handler。

当调用代理类对象的方法时，这个“调用”会转送到handler的invoke(Object proxy, Method method, Object[] args)方法中，代理类对象作为proxy参数传入，参数method标识了我们具体调用的是代理类的哪个方法，args为这个方法的参数。这样一来，我们对代理类中的所有方法的调用都会变为对invoke的调用，这样我们可以在invoke方法中添加统一的处理逻辑(也可以根据method参数对不同的代理类方法做不同的处理)。

中介类通过聚合方式持有一个委托类对象引用，在invoke方法中调用了委托类对象的相应方法，把外部对invoke的调用最终都转为对委托类对象的调用。这就像上面的静态代理的实现方式，实际上，中介类与委托类构成了静态代理关系，在这个关系中，中介类是代理类，委托类就是委托类;代理类与中介类也构成一个静态代理关系，在这个关系中，中介类是委托类，代理类是代理类。也就是说，动态代理关系由两组静态代理关系组成，这就是动态代理的原理。

动态代理与静态代理区别

一、动态代理类代理接口下的所有类，而静态代理通常只代理一个类；
二、动态代理只能代理接口，而静态代理还可以代理普通共同父类；
三、动态代理事先不知道要代理的是什么，只有在运行的时候才能确定。而静态代理在代码编写时就知道；

动态代理的优势

相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数。