手写一个ButterKnife
想要写一个ButterKnife 需要了解两个方面的姿势：
- 注解
- 反射
先简单的了解下这俩玩意，就可以开始飙车撸码了，话说注解其实在日常代码中随处可见，比如Activity中onCreate头顶的那个 @Override
ok，就拿它开刀吧，点进去一看：
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
这是个什么鬼 @interface 是接口吗，nonono， @Target和@Retention又是什么鬼？
其实这个Override 只是一个注解类，它指定了你要重写的一个父类的方法
@Target指定的是你要注解的元素，而这个Target 本身也是一个注解类
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
ElementType[] value();
}
ElementType 元素类型，点进去一看,是一个枚举类，里面是各种类型
public enum ElementType {
/** Class, interface (including annotation type), or enum declaration */
//类，接口 包括注解类型，或者枚举
TYPE,
/** Field declaration (includes enum constants) */
//字段或者枚举常量
FIELD,
/** Method declaration */
//方法
METHOD,
/** Formal parameter declaration */
//参数
PARAMETER,
/** Constructor declaration */
//构造函数
CONSTRUCTOR,
/** Local variable declaration */
//局部变量
LOCAL_VARIABLE,
/** Annotation type declaration */
//注解
ANNOTATION_TYPE,
/** Package declaration */
//包
PACKAGE,
/**
* Type parameter declaration
*
* @since 1.8
* @hide 1.8
*/
//类型参数
TYPE_PARAMETER,
/**
* Use of a type
*
* @since 1.8
* @hide 1.8
*/
//使用的类型
TYPE_USE
}
@Retention 点进去之后发现又是一个注解：
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
RetentionPolicy value();
}
RetentionPolicy 顾名思义，保留政策：
public enum RetentionPolicy {
/**
* 注解会在编译的时候被抛弃
*/
SOURCE,
/**
* 注解会在class状态，即编辑状态被保留，但是在运行时可能会被抛弃 这里需要注意的是 注解和class文件在使用上是被分离的
*/
CLASS,
/**
*注解会在编译时和运行时都被保留在vm，这样可以通过反射来获取它的信息。
*
*/
RUNTIME
}
你会发现Retention 和 Target本身作为一个注解，却又注解了其他的注解，原来是有四大元注解的（meta-annotation）：
- @Documented
- @Retention
- @Target
- @Inherited
补充下@Documented 和 @Inherited：
@Documented 指定了这个注解会被javaDoc记录
@Inherited 指定了这个注解的类型会自动的继承，具体意思是子类会自动的继承使用了这个注解的父类的注解，因此，对方法和属性无效。
现在这几个注解的大概意思已经差不多清楚了，但是注解的原理是什么呢，为什么通过这几行简单的代码就可以实现如此神奇的效果？其实这种编程思想就是IOC，控制反转，其原则为不需要new，帮助我们注入所有的控件、布局等。
现在我们可以将这些注解看做是一种标记，这种标记指定了它的类型以及保留政策，在javac编译，开发工具或者其他程序可以通过反射来了解你的标记元素，去做相应的事情。
知道了这些，我们还需要知道，这简单的几行代码的写法，即注解体的语法。
@interface是用来声明一个注解，这个注解是自动继承了Annotation接口的，这样编译程序才能知道你这个是注解。返回值类型就是参数的类型（class ,String,enum） 可以通过default来指定参数的默认值。
注解参数的可支持数据类型：
1.所有基本数据类型
2.String类型
3.Class类型
4.enum类型
5.Annotation类型
6.以上所有类型的数组
只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；
参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;
如果只有一个参数成员,最好把参数名称设为"value",后加小括号。
ok现在就可以开始创造一个简易版的ButterKnife了
首先创建一个注解布局的注解类SuperBindContentView
@Target(ElementType.TYPE) //元素类型
@Retention(RetentionPolicy.RUNTIME) //保留到class
public @interface SuperBindContentView {
int value(); //返回布局id
}
这个类很简单 需要注意的是元素的类型和保留政策
标记加上了 我们需要在程序执行的时候进行解析。
public class SuperBind {
// 方法名
private static final String METHOD_FIND_VIEW_BY_ID = "findViewById";
private static final String METHOD_SET_CONTENT_VIEW = "setContentView";
private static final String METHOD_ON_CLICK = "onClick";
/**
* setContentView
*
* @param activity
*/
public static void bindContentView(Activity activity) {
//获取activity 的class
Class<? extends Activity> clazz = activity.getClass();
//方法的注解从class中获取
SuperBindContentView superBindContentView = clazz.getAnnotation(SuperBindContentView.class);
if (superBindContentView != null) {
int value = superBindContentView.value();
if (value != -1) {
try {
Method scvMethod = clazz.getMethod(METHOD_SET_CONTENT_VIEW, int.class);
scvMethod.setAccessible(true);//激活
try {
scvMethod.invoke(activity, value);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
}
}
代码中的注释相对比较详细，相信看一遍就懂了，主要就是注解和反射的配合，通过注解拿到值，通过反射拿到方法，然后请求执行。
findViewById的注解就更加简单了：
@Target(ElementType.FIELD) //指定元素类型为成员变量
@Retention(RetentionPolicy.CLASS) //保留到字节码
public @interface SuperBindView {
int value(); //返回参数为int值 因为需要指定的就是资源id
}
解析方法：
public static void bindView(Activity activity) {
//获取activity 的class
Class<? extends Activity> clazz = activity.getClass();
//所有属性
Field[] fields = clazz.getDeclaredFields();
//遍历
for (Field f : fields) {
//拿到SuperBind 从而获取想要的id
SuperBindView bind = f.getAnnotation(SuperBindView.class);
if (bind != null) {
int id = bind.value();
if (id != -1) {
try {
Method fvbMethod = clazz.getMethod(METHOD_FIND_VIEW_BY_ID, int.class);
try {
Object mView = fvbMethod.invoke(activity, id);
f.setAccessible(true);
f.set(activity, mView);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
}
}
现在有个稍显复杂一点的注解，事件的注解，比如OnClick方法，按照流程，首先创建一个注解类SuperBindOnClick
**
* Created by JackYang on 2017/6/29.
* 事件注解
* 点击事件的注解略显麻烦，我们需要声明其方法名字，事件名字，方法类型，等 所以需要写一个自定义的注解 BaseOnClick
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@BaseOnClick(methodName = "onClick", listener = "setOnClickListener", listenerType = View.OnClickListener.class)
public @interface SuperBindOnClick {
int[] value();
}
在这里我需要一个自定义的注解来声明后文需要的这些参数，创建一个新的注解BaseOnClick，它起到桥梁的作用
@Target(ElementType.ANNOTATION_TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface BaseOnClick {
String methodName();
String listener();
Class listenerType();
}
注解创建完成之后，就开始解析了。
/**
* 解析事件的注解
*
* @param activity
*/
public static void bindOnClick(Activity activity) {
//获取注解类
Class<? extends Activity> clazz = activity.getClass();
//获取所有的方法
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
//得到被OnClick 注解的方法
if (method.isAnnotationPresent(SuperBindOnClick.class)) {
SuperBindOnClick superBindOnClick = method.getAnnotation(SuperBindOnClick.class);
//注解的值
int[] ids = superBindOnClick.value();
//获取baseOnClick 注解 根据注解获取注解
BaseOnClick baseOnClick = superBindOnClick.annotationType().getAnnotation(BaseOnClick.class);
//获取baseOnClick注解的值
Class<?> listenerType = baseOnClick.listenerType();
String listener = baseOnClick.listener();
String methodName = baseOnClick.methodName();
//这里需要用到动态代理 关于动态代理 下文详细介绍
ProxyHandler proxyHandler = new ProxyHandler(activity);
//指定代理什么
Object proxyListener = Proxy.newProxyInstance(listenerType.getClassLoader(), new Class[]{listenerType}, proxyHandler);
//把方法添加进去
proxyHandler.addMethod(methodName, method);
//View 的点击事件
for (int i :
ids) {
try {
//获取findViewById方法
Method findViewByIdMethod = clazz.getMethod(METHOD_FIND_VIEW_BY_ID, int.class);
findViewByIdMethod.setAccessible(true);
try {
//获取view
View view = (View) findViewByIdMethod.invoke(activity, i);
//获取点击事件
Method onClickListener = view.getClass().getMethod(listener, listenerType);
//对这个点击事件进行操作
onClickListener.setAccessible(true);
//对象和方法
onClickListener.invoke(view, proxyListener);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
}
}
}
}
这里用到了动态代理的概念，之所以要用到动态代理，是因为我们需要替换view的点击事件的方法，所以通过ProxyHandler这个类来进行替换Mehtod方法，这个方法需要指定class和方法名。
/**
* 动态代理
*/
static class ProxyHandler implements InvocationHandler {
//存放方法的map
private final HashMap<String, Method> methodMAP = new HashMap<>();
//使用弱引用
private WeakReference<Object> weakRef;
//把Activity传进弱引用 以防内存泄漏
public ProxyHandler(Object obj) {
this.weakRef = new WeakReference<Object>(obj);
}
/**
* 添加方法
*
* @param name
* @param method
*/
public void addMethod(String name, Method method) {
methodMAP.put(name, method);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//获取activity
Object o = weakRef.get();
if (o != null) {
//方法名
String methodName = method.getName();
//从map中获取该方法名对应的方法 此处对method进行了替换
method = methodMAP.get(methodName);
if (method != null) {
//执行
method.invoke(o, args);
}
}
return null;
}
}
至此，点击事件的注解已经完成了，神奇的地方在于注解和反射的互相配合，在合适的时机绑定给view或者替换方法，更深层次的原理则是需要明白这个时机发生的时间，本文暂不做更深的讲解。
