一.前言
通过上一篇文章的学习，相信我们对于动态代理有了相对深刻的认识，今天我们会通过使用动态代理完成Xutils中的注入。
二.代理对象的功能
通过代理对象我们可以实现的两种功能，一种是功能增强，另一种是方法的拦截，其实功能增强也是通过拦截方法来实现的。因为代理对象和被代理对象实现了相同的接口，所有他们的类型是完全相同的，运用这一点我们可以在需要的时候偷换对象，来完成一些特殊的功能
三.项目分析
我们要完成三个工作，布局注入，视图注入和事件的注入，其中前两个非常简单，重点是第三个工作。我们需要让我们的Activity实现BaseActivity，重写onCreate方法在这个方法中调用 ViewInjectUtil.inject(this);方法，在这个方法中完成所有的注入，在Activity被创建的时候回调用父类的方法，所以回提前完成所有的注入。
看ViewInjectUtil的代码。
public class ViewInjectUtil {
public static void inject(Activity activity){
ViewLayoutInject.getInstance().inject(activity);
ViewInstanceInject.getInstance().inject(activity);
ViewEventInject.getInstance().inject(activity);
}
}在这个方法中分别调用ViewLayoutInject、ViewInstanceInject和ViewEventInject的注入方法，他们分别代表布局注入，视图注入和事件注入，他们继承自BaseInject抽象类中，类中只有一个方法inject(Activity t)方法是抽取出来的通用方法。
(1).布局注入
public void inject(Activity t) {
// TODO Auto-generated method stub
Class calzz=t.getClass();
Annotation annotation = calzz.getAnnotation(LayoutInject.class);
if (annotation==null) {
return;
}
LayoutInject layoutInject=(LayoutInject) annotation;
int layoutVlaue=layoutInject.layout();
Method method=null;
try {
method=calzz.getDeclaredMethod(METHOD_NAME, new Class[]{int.class});
method.invoke(t, layoutVlaue);
}catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}布局注入的代码，来看布局注入的注解类
@Retention(value =RetentionPolicy.RUNTIME)
@Target(value = {ElementType.TYPE })
public @interface LayoutInject {
int layout();
}这两段代码都非常简单，首先从Activity的实例中反向获取字节码对象，从字节码对象中获取对应的作用在类上的LayoutInject注解，然后从注解中获取值，这便是我们要注入的布局id。然后从字节码中获取setContentView方法的Method对象，调用invoke方法，传入作用对象和布局参数即可。
(2).视图注入
public void inject(Activity activity) {
// TODO Auto-generated method stub
Class<Activity> clazz=(Class<Activity>) activity.getClass();
Field[] fields=clazz.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
Field field=fields[i];
Annotation annotation=field.getAnnotation(ViewInject.class);
if (annotation!=null) {
ViewInject viewInjectAnnotation=(ViewInject) annotation;
int viewId=viewInjectAnnotation.value();
try {
Method findMethod=clazz.getMethod(METHOD_NAME, int.class);
Object view=findMethod.invoke(activity, viewId);
field.setAccessible(true);
field.set(activity, view);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}视图注解类
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ViewInject {
int value();
}视图注入的思路和布局注入基本相似，通过Activity实例反向获取对应的字节码对象，然后拿到所有的Field对象，然后获得作用到Field对象上的注解，如果该注解是ViewInject类型的则获取注解中的值，这便是我们要注入的控件的id，之后获取findViewById方法的Method对象，调用invoke方法获取返回的对象，这就是我们要查找的view对象。最后，调用fieid对象的set方法设置对应的值。
(3).事件的注入
控件的事件类型有setOnClickListener,setOnLoneClickListener类型，对应的接口是OnClickListener和OnLongClickListener,对应的回调方法是onClick和onLongClick方法。通过观察我们可以发现，注入事件的三要素为setXXX方法、接口、onXXX方法，当我们确定了这三个要素便确定了一个点击事件，所以我们可以提取这三个要素作为一个注解。
@Target(ElementType.ANNOTATION_TYPE)
@Retention(value =RetentionPolicy.RUNTIME)
public @interface BaseEvent {
//onClick,onLongClick
String callBackName();
//setOnClickListener setOnLongClickListener
String viewMethodName();
//OnClickListener.class
Class eventInterface();
}上面是我们定义的BaseEvent注解，分别包含了事件的三个要素，对于一种事件我们需要定义一个对应的注解，并且我们需要把基本注解信息作用在对应的注解上，这里我们使用注解的注解。@Target(value = { ElementType.METHOD})
@Retention(value =RetentionPolicy.RUNTIME)
@BaseEvent(eventInterface =OnClickListener.class,
callBackName = "onClick", viewMethodName = "setOnClickListener")
public @interface ClickEvent {
int value();
}这是我们定义的onClick注解，在这个注解上我们使用BaseEvent指定事件的三要素，这样非常方便扩展，当我们需要定义OnLongClick注解时，只需要改变相应的参数即可，而没必要把这些参数全部放到Activity中去指定，那样会导致大量的重复。@ClickEvent(value =R.id.button)
public void method1(View view){
Log.d("ViewEventInject", "事件注入成功");
}事件注入的目的是对于在方法上作用ClickEvent注解，当点击button时，将调用method1方法，我们首先来看看通常的方法是如何做的。
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
}
});当我们点击按钮时，会首先调用我们设置的实现OnClickListener接口的对象是否为null，如果不为null，则会调用对应的OnClick方法，并传递View对象作为参数。在这里我们只要能监听到onClick方法被调用然后通过Activity的字节码对象获取method1方法的Method对象，然后调用invoke方法传入View对象即可。
第一种方式我们可以自己维护一个OnClickListener接口的实现类，然后获取到注入方法上的注解，获取对应的View对象，获取view对象的字节码对象，获取setOnClickListener方法的Method对象，调用该方法传入我们维护的OnClickListener接口的实现类，然后在把id和对应的注入的Method对象放入到一个Map中，在onClick方法中我们便可以调用Method方法，从而完成了方法的注入。
第二种方式，第一种方式虽然可行但是如果事件类型比较多，会产生大量的接口实现类，这和我们上篇文章中的案例相似，所以我们可以使用动态代理来实现。 如果使用动态代理那么被代理类又是谁呢，需要为每一个事件类型创建一个对应的被代理类吗。其实是不需要的，经过上篇文章的分析可以知道，使用JDK动态代理机制创建代理类是不依赖于被代理类，它依赖的是被代理类所实现的接口，甚至在调用被代理类的方法时所使用的Method对象也是接口中的Method对象。其次由于代理类实现类同样的接口，所以代理类可以作为setOnClickListener方法的参数。在这里并不需要被代理类，我们只需要监听到onClick方法被调用即可。
首先来看EventInvocationHandler的代码public class EventInvocationHandler implements InvocationHandler {
//要切入的方法,在Activity中,所以对象是Activity
private Method method;
private Object receiver;
public EventInvocationHandler(Method method,Object receiver) {
// TODO Auto-generated constructor stub
this.method=method;
this.receiver=receiver;
}
//当调用代理监听对象的OnClick方法时,会调用到这个方法,做方法拦截
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
//插入方法
this.method.invoke(receiver, args);
return proxy;
}
}这里的代码非常简单，invoke方法中只有一行代码，this.method.invoke(receiver, args)这行代码其实调用的是Activity中的method1方法，当事件触发，我们传入的代理类的onClick方法会被调用，由我们上篇中的伪代码可以知道，此时会封装参数调用incoke方法，当我们拦截到对应的方法的时候，就可以替换成自己定义的方法了。
来看ViewEventInject方法的实现public void inject(Activity activity) {
// TODO Auto-generated method stub
Class<Activity> clazz=(Class<Activity>) activity.getClass();
Method[] methods = clazz.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method method=methods[i];
Annotation[] annotations = method.getAnnotations();
for (int j = 0; j < annotations.length; j++) {
Annotation annotation=annotations[j];
Class annotationClazz=annotation.annotationType();
//判断该方法上时候作用了ClickEvent注解
if (!method.isAnnotationPresent(ClickEvent.class)) {
//不是ClickEvent 或者OnClickEvent 不处理
continue;
}
ClickEvent clickEvent=(ClickEvent) annotation;
int viewId=clickEvent.value();
BaseEvent baseEvent=(BaseEvent) annotationClazz.getAnnotation(BaseEvent.class);
//取出事件的三要素
Class eventClazz=baseEvent.eventInterface();
String eventMethodName=baseEvent.callBackName();
String viewMethodName = baseEvent.viewMethodName();
View view=activity.findViewById(viewId);
//生成代理对象,事件监听对象的代理对象
EventInvocationHandler eventInvocationHandler=new EventInvocationHandler(method,activity);
Object proxy=Proxy.newProxyInstance(eventClazz.getClassLoader(), new Class[]{eventClazz}, eventInvocationHandler);
Method setMethod;
try {
setMethod = view.getClass().getMethod(viewMethodName,eventClazz);
setMethod.invoke(view, proxy);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}代码思路，拿到Activity的字节码，获取所有的方法，获得方法上有ClickEvent注解作用的方法，获取ClickEvent注解中的值，这是我们要注入事件的控件的id，获取注解上的注解即事件三要素。通过id获取View对象，调用Proxy.newProxyInstance(eventClazz.getClassLoader(), new Class[]{eventClazz}, eventInvocationHandler);方法。类加载器是三要素中的接口字节码的类加载器，接口字节码也是注解三要素中取出的，然后是EventInvocationHandler对象。接下来是绑定监听的方法，从view的字节码中获取对应的setXXX方法，这个方法名称也是三要素中的，然后获取Method对象，调用invoke方法传入view对象作为目标对象，参数是我们生成的代理对象，到这里所有的注入工作就已经完成了。
四.总结
经过这几篇文章的学习，使我们对Java中的反射、泛型和注解以及动态d代理模式有了相对深刻的理解，有需要今天代码的同学可以下载我们的代码来学习，有说错的地方也可以指出共同学习。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
