java-动态代理模式

代理模式，属于设计模式中的一种。
定义：给目标对象提供一个代理对象，并由代理对象控制目标对象的引用。
目的：1、通过引入代理对象的方式间接访问目标对象，防止直接访问目标对象给系统带来的不必要的复杂性；
2、通过代理对象对原有的业务增强；
总结一下，思想就是创建一个中间人来做中转，可以实现多对多的效果。
从代码层面说，一个类需要调用另一个接口的方法，没有代理，就需要new对象，调用方法。当需要其他接口方法的时候，就需要new其他接口的实体类，调用方法，这样耦合性太强了。如果使用代理，用代理来匹配需要的接口方法，动态创建一个匿名内部类，做到方法实现。

静态代理

先看一下代理的逻辑图。

从上图可以看出，经常会有一种情况，就是你调用的方法，其实是一个接口里面的方法，你创建一个实现类，实现这个接口，也可以实现多个接口，你创建的这个类就是代理类，你代理了好几个接口，把这些接口的方法实现了。然后你就创建了这个接口的实现类，调用的是实现类里面的方法，这种情况就算是静态代理了，其实挺简单的。
但是静态代理有个麻烦的地方，如果需要扩展，你这个类就要多实现一个接口，然后写实现方法，这点就相当不方便了，这样就有了动态代理。

静态代理写法

假设，有个代购公司，可以做海外代购的服务，还能做包装服务。首先创建两个功能类，就是两个接口。

public interface IAgent {
    /**
     * 代理方法
     */
    void buyForAbroad(String country,String goods);
}
public interface IPacking {
    void packing(String type);
}

然后创建一个代理公司，

/**
 * 代购公司
 */
public class CompanyAgent implements IAgent,IPacking {
    private final String TAG = "CompanyAgent";
    @Override
    public void buyForAbroad(String country,String goods) {
        Log.v(TAG,"从"+country+"国家代购，物品："+goods);
        airTransport();
    }
    private void airTransport(){
        Log.v(TAG,"走空运方式运送货物");
    }
    private void seaTransport(){
        Log.v(TAG,"走海路方式运送货物");
    }


    @Override
    public void packing(String type) {
        rengongdabao();
        Log.v(TAG,"采用"+type+"材料包装");
    }
    private void jiqidabao(){
        Log.v(TAG,"采用机器打包");
    }
    private void rengongdabao(){
        Log.v(TAG,"采用人工打包");
    }
}

最后写一个main函数，调用公司的方法

public class AgentTest {
    public static void main(String[] args) {
        CompanyAgent companyAgent = new CompanyAgent();
        companyAgent.buyForAbroad("美国","iphone");
        companyAgent.packing("塑料袋");
    }
}

上面就是静态代理，如果这个公司要扩展业务，就要多实现一些接口，写起来就很麻烦。

动态代理

还是先看看动态代理的图。

动态代理，就是使用Proxy这个类的方法，帮助我们动态创建那个接口的实现类，根据实际对象和方法动态创建一个实现类，提高了扩展性，打到了解耦效果。

动态代理写法

现在看看动态代理怎么写。主要是用java的API中的Proxy这个类的方法。
自己想一个需求，butterknife不是有一个注解吗，在click方法上写个注解，然后就实现了点击事件。现在我们就用动态代理写一个既可以做点击又可以做长按事件的方法。写的时候需要用到注解和反射，这些都挺简单的。
点击事件需要一个注解，长按事件需要一个注解，然后还需要一个区别点击和长按的区别注解，做一个标记。
三个注解分别是如下写法。

//注解上的注解，就是元注解，这个是为了区别长按还是点击的
@Target(ElementType.ANNOTATION_TYPE)
@Retention(RententionPolicy.RUNTIME)
public @interface EventType{
	Class listenerType();
	String listenerSetter();
}
//点击注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@EventType(listenerType = View.OnClickListener.class, listenerSetter = "setOnClickListener")
public @interface OnClick {
//@IdRes 这个注解是系统提供的元注解，意思就是这里面传入的必须是控件的Id(R.id.tv)这种
    @IdRes int[] value();
}
//长按注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@EventType(listenerType = View.OnLongClickListener.class, listenerSetter = "setOnLongClickListener")
public @interface OnLongClick {
    @IdRes int[] value();
}

准备工作做好之后，就开始写一下如何实现

public class InjectClick{
	public static void bindClick(Activity activity){
		//首先拿到Activity的字节码文件
		Class<? extends Activity> activityClass = activity.getClass();
		//通过反射方法获取这个Activity所有的方法
		Method[] declaredMethods = activityClass.getDeclaredMethods();
		//遍历所有方法
		for (Method method : declaredMethods) {
    			//获得方法上所有注解
    			Annotation[] annotations = method.getAnnotations();
    			//便利所有注解，找到包含EventType注解的方法
    			for (Annotation annotation : annotations) {
        			//注解类型
        			Class<? extends Annotation> annotationType = annotation.annotationType();
        			if (annotationType.isAnnotationPresent(EventType.class)) {
            			EventType eventType = annotationType.getAnnotation(EventType.class);
            			// OnClickListener.class，eventType的listenerType的这个属性，已经定义了是点击的接口还是长按的接口
            			Class listenerType = eventType.listenerType();
            			//setOnClickListener，eventType的listenerType这个属性已经定义了是设置点击事件还是设置长按事件
            			String listenerSetter = eventType.listenerSetter();
            			try {
                			// 不需要关心到底是OnClick 还是 OnLongClick
                			Method valueMethod = annotationType.getDeclaredMethod("value");
                			//取出注解中所有的viewId
                			int[] viewIds = (int[]) valueMethod.invoke(annotation);
						//这个方法是添加了注解的方法，setAccessible是设置可以执行私有属性
                			method.setAccessible(true);
                			ListenerInvocationHandler<Activity> handler = new ListenerInvocationHandler(activity, method);
                			//这个listenerProxy对象，其实是View.OnClickListener或者View.OnClickListener接口的实现类
                			//下面这个代码，jvm其实是会帮助我们实现一个匿名内部类
                			//这个匿名内部类实现了OnClickListener或者OnClickListener接口
                			Object listenerProxy = Proxy.newProxyInstance(listenerType.getClassLoader(),
                        			new Class[]{listenerType}, handler);
                			// 遍历注解的值
                			for (int viewId : viewIds) {
                    			// 获得当前activity的view（赋值）
                    			View view = activity.findViewById(viewId);
                    			// 获取指定的方法(不需要判断是Click还是LongClick)
                    			// 如获得：setOnClickLisnter方法，参数为OnClickListener
                    			// 获得 setOnLongClickLisnter，则参数为OnLongClickLisnter
                    			Method setter = view.getClass().getMethod(listenerSetter, listenerType);
                    			// 执行方法   正常写法是view.setter(listenerProxy)，
                    			//如果看不明白，最常见的写法view.setOnClickLisnter(new View.OnClickListener{...}),这种写法就知道了吧
                    			setter.invoke(view, listenerProxy); //执行setOnclickListener里面的回调 onclick方法
                			}
            			} catch (Exception e) {
                			e.printStackTrace();
            			}
        			}
    			}

		}
	}
	/**
 	* 还可能在自定义view注入，所以是泛型： T = Activity/View
 	*
 	* @param <T>
 	*/
	static class ListenerInvocationHandler<T> implements InvocationHandler {

    		private Method method;
    		private T target;

    		public ListenerInvocationHandler(T target, Method method) {
        		this.target = target;
        		this.method = method;
    		}

    		@Override
    		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        		return this.method.invoke(target, args);
    		}
	}
}

使用就非常简单了

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //先绑定Activity
        InjectClick.bindClick(this);
    }

    @OnClick({R.id.btn1, R.id.btn2})
    public void click(View view) {
        switch (view.getId()) {
            case R.id.btn1:
                Log.i(TAG, "click: 按钮1");
                break;
            case R.id.btn2:
                Log.i(TAG, "click: 按钮2");
                break;
        }
    }


    @OnLongClick({R.id.btn1, R.id.btn2})
    public boolean longClick(View view) {
        switch (view.getId()) {
            case R.id.btn1:
                Log.i(TAG, "longClick: 按钮1");
                break;
            case R.id.btn2:
                Log.i(TAG, "longClick: 按钮2");
                break;
        }
        return false;
    }
}

上面的代码，就用到了泛型，注解，注解中的元注解做标记，还有@IdRes这种做代码检测的元注解，反射，动态代理（Proxy）。平时开发可能用不到这些，但是很多开源框架内部实现会用到，最起码看源码的时候能看懂，知道框架是如何实现的。