说道注解，竟然还有各种分类，得，这记不住，我们从注解的作用来反推其分类，帮助大家记忆，然后举例强化大家的记忆，话说注解的作用：

1、标记一些信息，这么说可能太抽象，那么我说，你见过@Override、@SuppressWarnings等，这类注解就是用于标识，可以用作一些检验

2、运行时动态处理，这个大家见得应该最多，在运行时拿到类的Class对象，然后遍历其方法、变量，判断有无注解声明，然后做一些事情。类似上述三篇博文中的做法。

3、编译时动态处理，这个呢？就是我们今天的主角了，一般这类注解会在编译的时候，根据注解标识，动态生成一些类或者生成一些xml都可以，在运行时期，这类注解是没有的~~会依靠动态生成的类做一些操作，因为没有反射，效率和直接调用方法没什么区别~~~

关于3，大家不明白，没事，下文会详谈，使用这类注解的项目有：ParcelableGenerator、butterknife 、androidannotaion等。

作用谈完了，那么如果你看到一个注解的声明你如何去判断他的作用呢？例如：

[java] view plaincopy

1. @Retention(RetentionPolicy.CLASS)

2. @Target ({ ElementType.FIELD, ElementType.TYPE })

3. public @interface  InjectView

4. {

5. int value();

6. }

1秒钟告诉我，它的作用是什么？哈，大家可能会郁闷，擦，我咋知道。其实可以看这个注解上面的@Retention后面的值，设置的为CLASS，说明就是编译时动态处理的。

这个值是一个枚举：有三个：SOURCE、RUNTIME、CLASS ， 到这里，是不是，搜噶，这三个11对应于上面三个作用。

好了，说完了注解的作用以及判断方式，那么大家可以看到除了@Retention还有个@Target，@Target的值呢是一个ElementType[]数组。什么意思呢？就是标明这个注解能标识哪些东西，比如类、变量、方法、甚至是注解本身（元注解）等。这个在：Android 进阶 教你打造 Android 中的 IOC 框架 【ViewInject】 （上）有详细说明。

好了，到此注解告一段落，大家只要记得注解的作用，以及如何去定义一个注解就好。

接下来进入我们的主题编译时注解。

对了，我创建了一个公众号，会推送一些开源项目、最新博客、视频等，关于博客涉及到的东西，也会提前给大家通知，可以关注一下，谢谢，左侧栏目，微信扫描即可。

3、编译时注解

那我们说一下编写过程。

1、创建一个类，继承AbstractProcessor

[java] view plaincopy

1. package com.zhy.util.ioc.processor;

2. import java.util.Set;

3. import javax.annotation.processing.AbstractProcessor;

4. import javax.annotation.processing.RoundEnvironment;

5. import javax.annotation.processing.SupportedAnnotationTypes;

6. import javax.annotation.processing.SupportedSourceVersion;

7. import javax.lang.model.SourceVersion;

8. import javax.lang.model.element.TypeElement;

9. @SupportedAnnotationTypes("com.zhy.util.ioc.annotation.InjectView")

10. @SupportedSourceVersion(SourceVersion.RELEASE_6)

11. public class ViewInjectProcessorBeta extends AbstractProcessor

12. {

13. @Override

14. public boolean process(Set<? extends TypeElement> annotations,

15. RoundEnvironment roundEnv)

16. {

17. // TODO Auto-generated method stub

18. return false;

19. }

20. }

这个类上可以添加注解：

@SupportedAnnotationTypes的值为当前类支持的注解的完整类路径，支持通配符。

@SupportedSourceVersion 标识该处理器支持的源码版本

除此以外还有一个@SupportedOptions，这个一般是命令行时候用的，设置一些选项，but，命令行我不熟，因此：略。

注：如果大家找不到AbstractProcessor，记得右键build-path add library把jdk加进来。

2、创建resources等文件。

这个对项目的一个结构有着固定的要求，下面我通过一张图来说：

可以看到，在我们的项目中呢，还需要创建一个resources这样的source folder ，右键 new sources folder即可。

然后在里面创建META-INF/services/javax.annotation.processing.Processor文件，这个文件中去写我们处理器的类完整路径。

经过上述两部，我们的编写环境就OK了。

4、完整例子

下面我们通过一个例子来给大家演示编译时动态生成数据，我们的效果是这样的，用户编写一堆bean，例如User类，我们通过注解提取属性动态生成一个json文件，以及一个代理类，注意是编译时生成。

注：以下为一个教学示例，无任何使用价值。

那么我们依然分为步骤来做：

1、创建编写环境

javax.annotation.processing.Processor里面写的是：com.zhy.annotationprocess.processor.BeanProcessor

我们还创建了一个注解：

[java] view plaincopy

1. package com.zhy.annotationprocess.annotation;

2. import java.lang.annotation.ElementType;

3. import java.lang.annotation.Retention;

4. import java.lang.annotation.RetentionPolicy;

5. import java.lang.annotation.Target;

6. @Target({ ElementType.FIELD, ElementType.TYPE })

7. @Retention(RetentionPolicy.CLASS)

8. public @interface Seriable

9. {

10. }

哈，一秒钟告诉我，哪一类作用的注解。

2、动态生成数据

1、首先明确一下我们的目标：

我们有很多bean类，例如：

[java] view plaincopy

1. public class User

2. {

3. @Seriable

4. private String username;

5. @Seriable

6. private String password;

7. private String three;

8. private String four;

9. }

[java] view plaincopy

1. @Seriable

2. public class Article

3. {

4. private String title ;

5. private String content ;

6. }

看到有两个普通的bean，上面声明了我们的注解，如果类上声明注解我们就将其所有的变量都生成一个json描述文件；如果仅仅是成员变量呢？那我们只提取声明的成员变量来动态生成。

类似如下的描述文件：

[html] view plaincopy

1. {class:"com.zhy.Article",

2. fields:

3. {

4. content:"java.lang.String",

5. title:"java.lang.String"

6. }

7. }

是不是觉得没撒用处，其实用处大大滴，以后我们会验证。

2、编写BeanProcessor

[java] view plaincopy

1. package com.zhy.annotationprocess.processor;

2. import java.io.File;

3. import java.io.FileWriter;

4. import java.io.IOException;

5. import java.util.ArrayList;

6. import java.util.HashMap;

7. import java.util.List;

8. import java.util.Map;

9. import java.util.Set;

10. import javax.annotation.processing.AbstractProcessor;

11. import javax.annotation.processing.ProcessingEnvironment;

12. import javax.annotation.processing.RoundEnvironment;

13. import javax.annotation.processing.SupportedAnnotationTypes;

14. import javax.annotation.processing.SupportedSourceVersion;

15. import javax.lang.model.SourceVersion;

16. import javax.lang.model.element.Element;

17. import javax.lang.model.element.ElementKind;

18. import javax.lang.model.element.TypeElement;

19. import javax.lang.model.element.VariableElement;

20. import javax.lang.model.util.ElementFilter;

21. import javax.lang.model.util.Elements;

22. import com.zhy.annotationprocess.annotation.Seriable;

23. @SupportedAnnotationTypes("com.zhy.annotationprocess.annotation.Seriable")

24. @SupportedSourceVersion(SourceVersion.RELEASE_6)

25. public class BeanProcessor extends AbstractProcessor

26. { // 元素操作的辅助类

27. Elements elementUtils;

28. @Override

29. public synchronized void init(ProcessingEnvironment processingEnv)

30. {

31. super.init(processingEnv);

32. // 元素操作的辅助类

33. elementUtils = processingEnv.getElementUtils();

34. }

35. @Override

36. public boolean process(Set<? extends TypeElement> annotations,

37. RoundEnvironment roundEnv)

38. {

39. // 获得被该注解声明的元素

40. Set<? extends Element> elememts = roundEnv

41. .getElementsAnnotatedWith(Seriable.class);

42. TypeElement classElement = null;// 声明类元素

43. List<VariableElement> fields = null;// 声明一个存放成员变量的列表

44. // 存放二者

45. Map<String, List<VariableElement>> maps = new HashMap<String, List<VariableElement>>();

46. // 遍历

47. for (Element ele : elememts)

48. {

49. // 判断该元素是否为类

50. if (ele.getKind() == ElementKind.CLASS)

51. {

52. classElement = (TypeElement) ele;

53. maps.put(classElement.getQualifiedName().toString(),

54. fields = new ArrayList<VariableElement>());

55. } else if (ele.getKind() == ElementKind.FIELD) // 判断该元素是否为成员变量

56. {

57. VariableElement varELe = (VariableElement) ele;

58. // 获取该元素封装类型

59. TypeElement enclosingElement = (TypeElement) varELe

60. .getEnclosingElement();

61. // 拿到key

62. String key = enclosingElement.getQualifiedName().toString();

63. fields = maps.get(key);

64. if (fields == null)

65. {

66. maps.put(key, fields = new ArrayList<VariableElement>());

67. }

68. fields.add(varELe);

69. }

70. }

71. for (String key : maps.keySet())

72. {

73. if (maps.get(key).size() == 0)

74. {

75. TypeElement typeElement = elementUtils.getTypeElement(key);

76. List<? extends Element> allMembers = elementUtils

77. .getAllMembers(typeElement);

78. if (allMembers.size() > 0)

79. {

80. maps.get(key).addAll(ElementFilter.fieldsIn(allMembers));

81. }

82. }

83. }

84. generateCodes(maps);

85. return true;

86. }

87. private void generateCodes(Map<String, List<VariableElement>> maps)

88. {

89. File dir = new File("f://apt_test");

90. if (!dir.exists())

91. dir.mkdirs();

92. // 遍历map

93. for (String key : maps.keySet())

94. {

95. // 创建文件

96. File file = new File(dir, key.replaceAll("\\.", "_") + ".txt");

97. try

98. {

99. /**

100. * 编写json文件内容

101. */

102. FileWriter fw = new FileWriter(file);

103. fw.append("{").append("class:").append("\"" + key + "\"")

104. .append(",\n ");

105. fw.append("fields:\n {\n");

106. List<VariableElement> fields = maps.get(key);

107. for (int i = 0; i < fields.size(); i++)

108. {

109. VariableElement field = fields.get(i);

110. fw.append("  ").append(field.getSimpleName()).append(":")

111. .append("\"" + field.asType().toString() + "\"");

112. if (i < fields.size() - 1)

113. {

114. fw.append(",");

115. fw.append("\n");

116. }

117. }

118. fw.append("\n }\n");

119. fw.append("}");

120. fw.flush();

121. fw.close();

122. } catch (IOException e)

123. {

124. e.printStackTrace();

125. }

126. }

127. }

128. }

代码略长，但是注释很清除，我来解释一下，基本分为两个过程：1、找出标识注解的类或成员变量，封装到maps中；2、遍历maps为每个类创建json文件。我们把文件输出到了f://apt_test文件夹中，如果你没有f盘神马的，自行修改目录。

3、使用

到此，我们写完了~~那么如何用呢？

1、导出jar

为了更好的演示，以及省篇幅，我录成gif

注意我选择的一些复选框，和一些默认复选框的选中状态，我将其放在桌面上~~

2、新建一个android或java项目

将jar拷贝到libs下，如果是java项目，需要自己创建lib文件夹，自己手动引用。

然后就开始编写bean吧：我这里就写了两个类，一个User，一个Article，上面贴过代码了。

3、启用annotation processor

这里我是eclipse，大家如果是maven项目或者是别的什么IDE，自行进行网络搜索，这里有个Android Studio下的使用，自己点击哈，其实命令行也可以。

下面我们eclipse依然是个gif，不然得截一堆图片：

假设我们的jar已经拷贝到项目中了，进行如下操作

操作完成以后，那么就可以去f://apt_test中

打开即可看到：

[java] view plaincopy

1. {class:"com.zhy.User",

2. fields:

3. {

4. username:"java.lang.String",

5. password:"java.lang.String"

6. }

7. }

[java] view plaincopy

1. {class:"com.zhy.Article",

2. fields:

3. {

4. content:"java.lang.String",

5. title:"java.lang.String"

6. }

7. }

ok，这样的话，我们一个简单的annotation processor的教程就搞定了~~如果想学，一定要去试，各种试，不要怕麻烦，要是简单谁都会，那还有什么意义~~

这是一个非常简单的例子，那么具体到我们的项目中如何使用呢？鉴于篇幅，可能只能在下一篇给大家继续了。不过库的雏形已经形成：

5、HyViewInject

ok，这就是基于上述的一个库，主要用于Android的控件的注入，类似butterknife，尚在完善中，欢迎大家使用，fork or star ,我们一起完善。

sample的效果图：

第一个Activity中一个TextView和ListView，第二个Activity一个TextView和Fragment，主要测试了Activity、Fragment、Adapter中注入控件。