浅析代理模式

概述

在面向对象系统中，有些对象由于某些原因（比如对象的创建开销很大，或者某些操作需要安全控制），直接访问会给使用者或者系统结构带来很多麻烦，我们在访问此对象时加上一个对此对象的访问层，这种方式被我们称做代理模式或者委托模式；而根据程序运行前代理类是否已经存在，我们又将代理分为静态代理和动态代理。

角色划分
- Subject抽象主题角色：抽象主题类可以是抽象类也可以是接口，它负责定义对外暴露的接口信息。
- RealSubject具体主题角色：也叫做被委托角色或者被代理角色，不折不扣的anonymous。
- Proxy代理主题角色：也叫做委托类或者代理类，它持有真实角色的引用，把所有抽象主题类定义的方法委托给真实主题角色。

模式类图

静态代理

静态代理相对其他模式还是比较容易理解的，这里给出一个简单的demo帮助理解该模式概念。

抽象主题

public interface Subject {    void request();}

真实主题

class RealSubject implements Subject {    private final static String TAG = RealSubject.class.getSimpleName();    @Override    public void request() {        Log.d(TAG, "Real processing");    }}

主题代理

public class ProxySubject implements Subject {    private final static String TAG = ProxySubject.class.getSimpleName();    private Subject realSubject;    public ProxySubject() {        realSubject = new RealSubject();    }    @Override    public void request() {        Log.d(TAG, "other operation");        realSubject.request();        Log.d(TAG, "other operation");    }}

场景类

public class MainActivity extends AppCompatActivity {    Button requestBtn;    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        requestBtn = (Button) findViewById(R.id.request);        requestBtn.setOnClickListener(new View.OnClickListener() {            @Override            public void onClick(View v) {                request();            }        });    }    private void request(){        ProxySubject proxySubject = new ProxySubject();        proxySubject.request();    }}

细想一下，每个代理方法中都要重复真实主题代码，如果要想为多个类进行代理，则需要建立多个代理类，维护成本增加；倘若事先并不知道真实角色呢？这些问题可以通过动态代理解决。

动态代理

public class CCInvocationHandler implements InvocationHandler {    private Object target;    public CCInvocationHandler() {}    public CCInvocationHandler(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Log.d(TAG, "other operation");        Object obj = method.invoke(target, args);        Log.d(TAG, "other operation");        return obj;    }}

• target 委托类对象。
• InvocationHandler 该接口的实现负责连接代理类和委托类。
• proxy 代理类对象。
• method 代理对象被调用的函数。
• args 代理对象被调用的函数的参数。
• invoke函数中我们也可以通过对method做一些判断，从而对某些函数特殊处理。

public class MainActivity extends AppCompatActivity {    private final static String TAG = MainActivity.class.getSimpleName();    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        CCInvocationHandler ccInvocationHandler = new CCInvocationHandler(new RealSubject());        Subject operate = (Subject) (Proxy.newProxyInstance(Subject.class.getClassLoader(), new Class[]{Subject.class},                ccInvocationHandler));        operate.request();    }}

• loader 当前类的类加载器。
• interfaces 委托类所实现的接口。
• ccInvocationHandler InvocationHandler实现类对象，连接代理类和委托类的中间类对象。

我想你应该和我一样对此很好奇，动态代理机制是怎么运作的，那就一探究竟吧！

从Proxy.newProxyInstance()切入

    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,                                          InvocationHandler invocationHandler)            throws IllegalArgumentException {        if (invocationHandler == null) {            throw new NullPointerException("invocationHandler == null");        }        Exception cause;        try {            return getProxyClass(loader, interfaces)                    .getConstructor(InvocationHandler.class)                    .newInstance(invocationHandler);        } catch (NoSuchMethodException e) {            cause = e;        } catch (IllegalAccessException e) {            cause = e;        } catch (InstantiationException e) {            cause = e;        } catch (InvocationTargetException e) {            cause = e;        }        AssertionError error = new AssertionError();        error.initCause(cause);        throw error;    }

newProxyInstance代码段还是比较直观的，首先对invocationHandler做非空判断，之后把loader和interfaces传入getProxyClass()后获得代理类，然后拿到代理类的构造函数，最后将invocationHandler作为newInstance参数传入生成代理类对象。关于如何得到代理类的呢？继续跟进getProxyClass()。

    public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)            throws IllegalArgumentException {        if (loader == null) {            loader = ClassLoader.getSystemClassLoader();        }        if (interfaces == null) {            throw new NullPointerException("interfaces == null");        }        // Make a copy of the list early on because we're using the list as a        // cache key and we don't want it changing under us.        final List<Class<?>> interfaceList = new ArrayList<Class<?>>(interfaces.length);        Collections.addAll(interfaceList, interfaces);        // We use a HashSet *only* for detecting duplicates and null entries. We        // can't use it as our cache key because we need to preserve the order in        // which these interfaces were specified. (Different orders should define        // different proxies.)        final Set<Class<?>> interfaceSet = new HashSet<Class<?>>(interfaceList);        if (interfaceSet.contains(null)) {            throw new NullPointerException("interface list contains null: " + interfaceList);        }        if (interfaceSet.size() != interfaces.length) {            throw new IllegalArgumentException("duplicate interface in list: " + interfaceList);        }        synchronized (loader.proxyCache) {            Class<?> proxy = loader.proxyCache.get(interfaceList);            if (proxy != null) {                return proxy;            }        }        String commonPackageName = null;        for (Class<?> c : interfaces) {            if (!c.isInterface()) {                throw new IllegalArgumentException(c + " is not an interface");            }            if (!isVisibleToClassLoader(loader, c)) {                throw new IllegalArgumentException(c + " is not visible from class loader");            }            if (!Modifier.isPublic(c.getModifiers())) {                String packageName = c.getPackageName$();                if (packageName == null) {                    packageName = "";                }                if (commonPackageName != null && !commonPackageName.equals(packageName)) {                    throw new IllegalArgumentException(                            "non-public interfaces must be in the same package");                }                commonPackageName = packageName;            }        }        List<Method> methods = getMethods(interfaces);        Collections.sort(methods, ORDER_BY_SIGNATURE_AND_SUBTYPE);        validateReturnTypes(methods);        List<Class<?>[]> exceptions = deduplicateAndGetExceptions(methods);        Method[] methodsArray = methods.toArray(new Method[methods.size()]);        Class<?>[][] exceptionsArray = exceptions.toArray(new Class<?>[exceptions.size()][]);        String baseName = commonPackageName != null && !commonPackageName.isEmpty()                ? commonPackageName + ".$Proxy"                : "$Proxy";        Class<?> result;        synchronized (loader.proxyCache) {            result = loader.proxyCache.get(interfaceList);            if (result == null) {                String name = baseName + nextClassNameIndex++;                result = generateProxy(name, interfaces, loader, methodsArray, exceptionsArray);                loader.proxyCache.put(interfaceList, result);            }        }        return result;    }

代码段稍微有些长，那就一点点分析吧……

    if (loader == null) {        loader = ClassLoader.getSystemClassLoader();    }

如果传入的加载抽象主题的类加载器对象为null，就获取系统类加载器，关于类加载，我建议同学们有必要去了解一下，比如类的双亲委派机制,这些概念有助于理解动态加载apk文件。

      synchronized (loader.proxyCache) {            Class<?> proxy = loader.proxyCache.get(interfaceList);            if (proxy != null) {                return proxy;            }      }

尝试从缓存中去代理类Class对象，如果存在需要的代理类Class对象则直接返回，否则继续执行。继续往下分析…

        String commonPackageName = null;        for (Class<?> c : interfaces) {            if (!c.isInterface()) {                throw new IllegalArgumentException(c + " is not an interface");            }            if (!isVisibleToClassLoader(loader, c)) {                throw new IllegalArgumentException(c + " is not visible from class loader");            }            if (!Modifier.isPublic(c.getModifiers())) {                String packageName = c.getPackageName$();                if (packageName == null) {                    packageName = "";                }                if (commonPackageName != null && !commonPackageName.equals(packageName)) {                    throw new IllegalArgumentException(                            "non-public interfaces must be in the same package");                }                commonPackageName = packageName;            }        }

如果interfaces中存在非public的接口，则所有非public接口必须在同一包下面，后续生成的代理类也会在该包下面。

  String baseName = commonPackageName != null && !commonPackageName.isEmpty()                ? commonPackageName + ".$Proxy"                : "$Proxy";

得到代理类的类名

     Class<?> result;     synchronized (loader.proxyCache) {     result = loader.proxyCache.get(interfaceList);     if (result == null) {        String name = baseName + nextClassNameIndex++;        result = generateProxy(name, interfaces, loader, methodsArray, exceptionsArray);        loader.proxyCache.put(interfaceList, result);     }   }

generateProxy() native层实现，是JVM加载代理类并返回其Class对象，得到Class对象之后存入缓存。

• 获取RealSubject上的所有接口列表。
• 确定要生成的代理类的类名，默认为：com.sun.proxy.$ProxyXXXX。
• 根据需要实现的接口信息，动态创建该Proxy class文件。
• 将字节码信息转换为对应的class对象。
• 创建InvocationHandler实例handler，用来处理Proxy所有方法调用。
• Proxy的class对象以创建的handler对象为参数，实例化一个proxy对象。

结语

• 静态代理模式的使用场景比较常见，比如android appcompat体系或者说context体系。
• 动态代理可以对代理类的函数做统一或特殊处理，比如所有函数执行前添加验证判断、对某个特殊函数进行特殊操作。

---

朋友的新书《Android源码设计模式解析与实战》已经出版，购买链接