设计模式——代理模式（一）

作者: 程序员修仙 | 来源:发表于2017-10-20 17:02 被阅读36次

1. 定义

为其他对象提供一种代理以控制对这个对象的访问。

2. 使用场景

当想对某个对象做功能增强拓展，但又不想改变原有对象代码时，为了达到这种良好的扩展性，可以使用一个代理对象间接访问原对象的方法，并进行功能真强和扩展。

3. 代理模式的范围

从广义上来讲，所有通过一个中间对象间接访问原对象的方式都可以称之为代理。但出于可扩展性考虑，严格意义上的代理模式是将需要间接访问的操作抽象成接口或抽象类，真实对象类实现接口和抽象类真实操作，代理对象类持有真实对象的引用完成接口的实现。

4. 代理模式设计

静态代理.jpg

public interface ISubject{
    public void doSomething();
}
public class RealSubject implements ISubject{
    @Override
    public void doSomething(){
        System.out.println(" real do something");
    }
}
public class ProxySubject implements ISubject{
    private ISubject target;
    public ProxySubject(ISubject target){
        this.target = target;
    }
    @Override
    public void doSomething(){
        //do something before
        doSomethingBefore();
        //target do something
        this.target.doSomething();
        //do something after
        doSomethingAfter();
    }
    public void doSomethingBefore(){....}
    public void doSomethingAfter(){....}
}

public class ProxyTest{
    public static void main(String[] args){
        ISubject proxy = new ProxySubject(new RealSubject());
        proxy.doSomething();
    }
}

代码说明：
ISubject：需要代理的对象主题抽象方法接口。
RealSubject：真实的对象实现抽象方法接口类。
ProxySubject: 代理的对象，持有真实对象引用target，并在调用target方法前做方法功能增强和扩展。
ProxyTest: 测试类。

5. 更灵活的动态代理

考虑这样一种场景，当需要代理的接口方法增多时，势必要在每一种方法进行代理，这样就会导致接口增加了一个方法，除了所有实现类都需要实现这个方法外，所有的代理类也需要实现此方法，这无疑增加了代码维护的复杂度。
Java中给我们提供了一种简单实现动态代理的方式，与上面的静态代理代理类字节码文件在运行前就编译生成不同，动态代理类的源码是在程序运行期间由JVM根据反射机制动态生成。

6. 动态代理设计

动态代理.jpg

public interface ISubject{
    public void doSomething();
}
public class RealSubject{
    @Override
    public void doSomething(){
        System.out.println("real do something");
    }
}
public class ProxyInvocationHandler implements InvocationHandler{
    private Object target;
    public ProxyInvocationHandler(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throw Throwable{
        //do something before
        doSomethingBefore();
        //target do something
        Object result = method.invoke(target,args);
        //do something after
        doSomethingAfter();
        return result;
    }
    public Object getProxy(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this)
    }
    public void doSomethingBefore(){....}
    public void doSomethingAfter(){....}
}
public class DynamicProxyTest(){
    public static void main(String[] args){
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler(new RealSubject());
        ISubject proxy = (ISubject)proxyInvocationHandler.getProxy();
        proxy.doSomething();
    }
}

代码说明：
ISubject：需要代理的对象主题抽象方法接口。
RealSubject：真实的对象实现抽象方法接口类。
InvocationHandler: java中用来实现动态代理的接口。
ProxyInvocationHandler: 实现动态接口类，是动态代理的核心处理类，
实现动态代理接口invoke方法。

invoke():该方法通过反射集中处理接口中声明的所有方法（不再需要根据接口方法的增加，拓展代理对象类的方法了）。
getProxy():该方法通过Java代理类Proxy动态生成代理类对象。

DynamicProxyTest:测试类

7. 动态代理的实现原理：

其实动态代理的核心就两点：如何动态的生成代理类对象和如何调用接口中声明的所有方法。

7.1 如何动态的生成代理类对象

代理类对象的生成主要是调用Proxy类中的该方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
    ....
    // Look up or generate the designated proxy class
    Class<?> cl = getProxyClass0(loader,interfaces);
    ....
    // Invoke its constructor with the designated invocation handler
    final Constructor<?> cons = cl.getConstructor(construcotrParams);
    return cons.newInstance(new Object[]{h});
}

getProxyClass0(loader,interfaces): 通过指定的类加载器loader和接口interface创建动态代理类对象cl。
cl.getConstructor(new Class[]{InvocationHandler.class})：通过反射获取动态代理类的构造函数。
cons.newInstance(new Object[]{h}):通过构造函数创建代理类实例。

7.2 如何调用接口中声明的所有方法

想知道动态代理对象如何调用接口中声明的所有方法可以从动态生成的代理类.class文件中看出。
可以采用一下方法生成代理类文件：

public void createProxyClassFile(){
    String name = "ProxyClass";
    byte[] data = ProxyGenerator.generateProxyClass(name,RealSubject.class.getInterfaces());
    try {
        FileOutputStream outputStream = new FileOutputStream(name+".class");
        outputStream.write(date);
        outputStream.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

生成的代理类.class文件如下：

public final class ProxyClass extends Proxy implements ISubject {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public ProxyClass(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 doSomething() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } 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);
        }
    }

    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);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("DynamicProxy.JavaDynamic$ISubject").getMethod("doSomething");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

从生成的代理类文件中可以看出，代理类继承Proxy类并实现了抽象接口ISubject的方法。代理类的构造函数参数是传入进来的InvocationHanlde实例，并且每个方法都调用了super.h.invoke(this,m3,(Object[]null));而h就是Proxy中我们传入的ProxyInvocationHandler对象，invoke方法就是我们实现InvocationHandler接口里面的方法。这样，最终动态代理生成的代理对象的每个方法都是集中在ProxyInvocationHandler中invoke方法中执行，在invoke中用反射的方式调用了真实对象的方法。

7.3 创建动态代理的过程

通过上面的分析和生成的代理对象类.class文件，动态代理的创建流程如下：

通过实现InvocationHandler接口创建自己的核心处理类: InvocationHandler handler = new ProxyInvocationHandler(...)。
通过Proxy类指定类加载器对象和接口创建动态代理类: Class<?> cl =Proxy.getProxyClass0(classLoader,new Class[]{...})。
通过反射获取动态代理类的构造函数，其参数为InvocationHandler.class。
Constructor<?> cons = cl.getConstructor(new Class[]{InvocationHandler.class};
通过构造函数生成代理对象实例，将传进来的invocationHandler实例作为参数。
Object Proxy = cons.newInstance(new Object[]{h});
生成的代理对象类继承Proxy类并实现了ISubject接口，实现的ISubject方法实际调用的是构造函数传进去的invocationHandler实例的invoke方法。

8. 静态代理和动态代理的比较

8.1 静态代理的优缺点

静态代理代码实现逻辑简单，易于理解。
当需要拓展抽象接口时，所有的实现类需要实现这个方法，所有的代理类也需要实现这个方法，且要为每一种方法都进行代理，导致代码维护难度加大。

8.2 动态代理的优缺点

动态代理代码实现逻辑比静态代理复杂。
接口的所有方法都集中于InvocationHandler的invoke执行，方便在接口增加方法时代码的维护难度
动态代理只支持interface代理，比静态代理局限性大。（动态代理之所以仅支持interface代理，是由于整个java的单继承机制决定的，通过动态代理生成的每个代理类都继承了Proxy基类，导致其只能通过interface代理形式实现）

9. 代理模式的种类

根据代理模式的适用范围，可以分为远程代理、虚拟代理、保护代理等，本文就不在赘述了。

10. 总结

最后，一句话总结代理模式：“ 使用间接对象来控制真实对象访问的一种策略 ”！