Java代理模式及使用

一、简单代理模式

简单代理模式就是为一个实现类找一个代理人类，由这个代理人持有这个实现类并对外提供服务。

假设我有一个RealSubject类，实现了Subject接口：

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

Subject接口很简单，就定义了request方法：

public interface Subject {
    void request();
}

那么写一个代理人类来代理RealSubject：

public class SubjectProxy implements Subject{

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

使用的时候，只需要将RealSubject的实例对象交给代理类，再由代理类来对外提供服务：

public static void main(String[] args) {
    Subject subject = new SubjectProxy(new RealSubject());
    subject.request();
}

二、动态代理模式

代理模式的本质，就是在实际调用代码前后，先做一些处理。但是为了实现这个功能，简单代理模式(或者说静态代理模式)，需要为不同接口实现不同的代理类。比如说上文的Subject接口，实现代理模式需要一个SubjectProxy来实现这个接口。

假设我们需要代理很多接口，这些接口的代理者行为相近(比如房产中介都是代理雇主卖房子)，那么我却需要为每一个接口实现一个代理类。

其实不需要这样。使用动态代理可以解决这个问题。

Java中可以通过实现InvocationHandler接口来创建一个代处理类(有点拗口)。好比说刚刚的例子，可以把SubjectProxy改写为:

public class MyInvocation implements InvocationHandler {

    private Object obj;

    public MyInvocation(Object o){
        this.obj = o;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before calling " + method);
        method.invoke(obj, args);
        System.out.println("after calling " + method);
        return null;
    }
}

好了，我们有了一个代处理类MyInvocation，如何用它来代理我们的RealSubject？答案在下面:

public static void main(String[] args) throws Throwable {
    Subject rs = new RealSubject();
    InvocationHandler ds = new MyInvocation(rs);
    Class cls = rs.getClass();
    Subject subject=(Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);
    
    subject.request();
}

上面的代码中，我们首先实例化了一个需要被代理的类RealSubject，然后将其交给我们的MyInvocation持有。（简单代理模式到这一步就完成了代理，但是也因此使得代理类和具体接口绑定在一起）接下来，我们把MyInvocation、被代理类的一些信息传给Proxy类，由Proxy生成一个Subject对象。

此时调用新生成对象的方法，会发现已经完成了对RealSubject的代理。

三、动态代理的原理

通过debug上文的代码可以看到动态代理是如何实现的。

生成的代理对象实际类型是$Proxy0。$Proxy0继承自Proxy类，但并不是一个真实存在的类。而是在运行时动态生成的一个对象。

subject对象实际的类型

关于Java如何动态生成字节码可以参考这篇文章:Java动态代理机制详解。

通过下面的代码将$Proxy0对象导出为class文件:

        String path = "/$Proxy0.class";
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", RealSubject.class.getInterfaces());
        FileOutputStream out = null;

        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
            }
        }

导出的$Proxy0.class如下所示：

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m3;
    private static Method m0;
    private static Method m2;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void request() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m3 = Class.forName("com.mogujie.qiankun.proxy.Subject").getMethod("request", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

通过上面的代码可以知道，我们调用代理类的request方法时，实际执行的是：

    public final void request() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }