设计模式-代理模式-结构型

定义：

为其他对象提供一种代理，以控制该对象的访问

类型：

结构型

理解：

当你想在访问某个对象前做一些校验的时候，比如权限判断、登录校验等，或者访问某个对象比较困难时，或者要兼容不同Android版本，这个时候就可以考虑使用代理模式，代理模式的核心点在于后面那半句“控制对象的访问”
例如我们手机里的短信app，在发送短信之前会有一些校验，比如说检查手机号和内容是否为空，如果为空则不让发送短信：

interface SmsFunction{
	void sendSms(String phoneNumber,String content);
}
class SmsApp implements SmsFunction{
	public void sendSms(String phoneNumber,String content){
		System.out.println("发送短信成功！联系人："+phoneNumber+";内容："+content);
	}
}
class SmsSendProxy implements SmsFunction{
	private SmsFunction mSmsSender;
	SmsSendProxy(SmsFunction smsSender){
		this.mSmsSender = smsSender;
	}
	public void sendSms(String phoneNumber,String content){
		//校验要发送短信的信息，控制mSmsSender对象的访问
		if(TextUtils.isEmpty(phoneNumber) || TextUtils.isEmpty(content)){
			System.out.println("联系人和短信内容都不能为空！")
			return;
		}
		mSmsSender.sendSms(phoneNumber, content);
	}
}
class Client{
	public static void main(String[] args){
		SmsApp smsApp = new SmsApp();//短信app
		SmsSendProxy smsProxy = SmsSendProxy(smsApp);//短信代理发送工具
		smsProxy..sendSms("110", "短信报警求助");
	}
}

类结构图如下：

可以看到，代理类对象和被代理的对象都实现了同一个接口，在请求被对象方法之前，代理对象检查传入的参数是否规范，从而控制了该对象的访问

动态代理

上面通过自己写代理类实现代理功能的方式称为静态代理，但是如果有个需求要求所有的类访问了某个方法都要记录到日志里，手动一个个添加代理类效率实在太低了，所以就有了动态代理，动态代理指的是使用java api提供的InvocationHandler以及Proxy类在程序运行时动态的创建代理类，还是以上面发送短信为例：

• 创建一个打印日志的Handler，继承自InvocationHandler

public class PrintHandler implements InvocationHandler{
   private Object mProxyObject;//代理对象
   LogHandler(Object proxyObject){
      this.mProxyObject= proxyObject;
   }
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      Object result = method.invoke(mProxyObject,args);
      System.out.println("调用了方法："+method.getName());
      return result;
   }
}

• 然后调用Proxy的newProxyInstance创建代理类：

class Client{
	public static void main(String[] args){
		SmsApp smsApp = new SmsApp();//短信app
		SmsFunction smsProxy= (SmsFunction)Proxy.newProxyInstance(SmsFunction.class.getClassLoader(), new Class[]{SmsFunction.class}, new PrintHandler(smsApp));//短信代理发送工具
		smsProxy.sendSms("110", "短信报警求助");
	}
}

Android中的代理模式：

Binder

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: E:\\zhujie\\project\\DesignPattern\\app\\src\\main\\aidl\\com\\example\\designpattern\\IBookManager.aidl
 */
package com.example.designpattern;
// Declare any non-default types here with import statements

public interface IBookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.example.designpattern.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.example.designpattern.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.example.designpattern.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.example.designpattern.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.example.designpattern.IBookManager))) {
                return ((com.example.designpattern.IBookManager) iin);
            }
            return new com.example.designpattern.IBookManager.Stub.Proxy(obj);
        }

        @Override
        public android.os.IBinder asBinder() {
            return this;
        }

        @Override
        public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
            java.lang.String descriptor = DESCRIPTOR;
            switch (code) {
                case INTERFACE_TRANSACTION: {
                    reply.writeString(descriptor);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(descriptor);
                    java.lang.String _arg0;
                    _arg0 = data.readString();
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
                default: {
                    return super.onTransact(code, data, reply, flags);
                }
            }
        }

        private static class Proxy implements com.example.designpattern.IBookManager {
            private android.os.IBinder mRemote;

            Proxy(android.os.IBinder remote) {
                mRemote = remote;
            }

            @Override
            public android.os.IBinder asBinder() {
                return mRemote;
            }

            public java.lang.String getInterfaceDescriptor() {
                return DESCRIPTOR;
            }

            @Override
            public void addBook(java.lang.String aString) throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    _data.writeString(aString);
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    }

    public void addBook(java.lang.String aString) throws android.os.RemoteException;
}

类关系图：

从代码上可以看出，Proxy是代理类，代理了Stub对象，这里与上面的示例有一些区别，虽然Proxy和Stub都实现了IBookManager接口，但是在代理类的addBook方法里，并没有直接调用Stub的addBook方法，而是先调用了Stub的transact方法，通过Binder跨进程调用，最后回调Stub的onTransact的方法，在这个方法里最终调用了Stub的addBook方法，也就是Binder使用代理模式，是因为跨进程调用Stub的addBook方法比较困难，通过代理使用Binder来协助完成对象的访问

优点：

能够控制或者协助对象的访问

缺点：

• 静态代理：如果要代理的对象多的话，会生成很多代理类
• 动态代理：必须实现InvocationHandler接口，使用反射代理方法，比较消耗系统资源