Design pattern--代理模式

Design pattern–代理模式

代理模式是常用的设计模式之一，在retrofit2源码分析过程中，看到了动态代理的使用，非常精妙，有必要深入理解下。代理模式有两种，静态代理和动态代理。

静态代理

代理(Proxy)是一种设计模式,即通过代理对象访问目标对象，好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.看一个例子

// Subject.java
public interface Subject {
  void operation();
}

// RealSubject.java
public class RealSubject implements Subject{
  @Override public void operation() {
    System.out.println("operation by RealSubject");
  }
}

// ProxySub.java
public class ProxySub implements Subject{
  Subject subject;
  public ProxySub(Subject subject) {
    this.subject = subject;
  }
  @Override public void operation() {
    System.out.println("do other things");
    subject.operation();
  }
}

// MainActivity.java
public class MainActivity extends AppCompatActivity {

  @Override protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    ProxySub sub = new ProxySub(new RealSubject());
    sub.operation();
  }
}

ProxySub是一个代理类，目标对象是RealSubject，最终调用的是RealSubject#operation方法，但是调用RealSubject#operation前后可以做些额外的操作。

静态代理总结:

1.可以做到在不修改目标对象的功能前提下,对目标功能扩展.

2.缺点:
因为代理对象需要与目标对象实现一样的接口,所以会有很多代理类. 同时,一旦接口增加方法,目标对象与代理对象都要维护.

如何解决静态代理中的缺点呢?答案是使用动态代理

---

动态代理

通过InvocationHandler来完成动态代理

// ProxySubject.java
public class ProxySubject implements InvocationHandler{
  Subject subject;
  public ProxySubject(Subject subject) {
    this.subject = subject;
  }

  @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("method->" + method.getName());
    return method.invoke(subject, args);
  }
}

// MainActivity.java
final Subject subject = new RealSubject();
ProxySubject proxy = new ProxySubject(subject);
Subject sub = (Subject) Proxy.newProxyInstance(subject.getClass().getClassLoader(),
    subject.getClass().getInterfaces(), proxy);
sub.operation();

运行一下：

06-03 16:05:31.683 2173-2173/com.rico.proxy I/System.out: method->operation
06-03 16:05:31.683 2173-2173/com.rico.proxy I/System.out: operation by RealSubject

调用过程大致是：newProxyInstance得到一个动态生成的代理类 $Proxy0,这个类继承了Proxy并且实现了Subject接口，所以调用$Proxy0#operation方法，实际上调用的是super.h.invoke(this, , )，也就是父类Proxy的h的invoke方法，也就是ProxySubject的invoke方法，然后通过反射method.invoke(subject, args);调用RealSubject#operation接口，有点绕，但是基本上说清楚了

查看源码发现$Proxy0正式调用getProxyClass0构建出来的，通过反射得到所有的构造方法，然后调用newInstance(cons, h);动态构建$Proxy0，传入的h正式我们ProxySubject实例

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, interfaces);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            return newInstance(cons, h);
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString());
        }
    }

下面看下$Proxy0的源码

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Manager {

private static Method m1;
private static Method m0;
private static Method m3;
private static Method m2;

static {
   try {
    m1 = Class.forName("java.lang.Object").getMethod("equals",
      new Class[] { Class.forName("java.lang.Object") });
    m0 = Class.forName("java.lang.Object").getMethod("hashCode",
      new Class[0]);
    m3 = Class.forName("com.ml.test.Manager").getMethod("modify",
      new Class[0]);
    m2 = Class.forName("java.lang.Object").getMethod("toString",
      new Class[0]);
   } catch (NoSuchMethodException nosuchmethodexception) {
    throw new NoSuchMethodError(nosuchmethodexception.getMessage());
   } catch (ClassNotFoundException classnotfoundexception) {
    throw new NoClassDefFoundError(classnotfoundexception.getMessage());
   }
}

public $Proxy0(InvocationHandler invocationhandler) {
   super(invocationhandler);
}

@Override
public final boolean equals(Object obj) {
   try {
    return ((Boolean) super.h.invoke(this, m1, new Object[] { obj }))
      .booleanValue();
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

@Override
public final int hashCode() {
   try {
    return ((Integer) super.h.invoke(this, m0, null)).intValue();
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

public final void operation() {
   try {
    super.h.invoke(this, m3, null);
    return;
   } catch (Error e) {
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}

@Override
public final String toString() {
   try {
    return (String) super.h.invoke(this, m2, null);
   } catch (Throwable throwable) {
    throw new UndeclaredThrowableException(throwable);
   }
}
}

代理模式就分析这么多了，以上！