我们经常会在java代码里面看到&＃xff1a;“&＃64;Override”&＃xff0c;“&＃64;Target”等等样子的东西&＃xff0c;这些是什么&＃xff1f;
在java里面它们是“注解”。
下面是百度百科的解释&＃xff1a;java.lang.annotation.Retention可以在您定义Annotation型态时&＃xff0c;指示编译器如何对待您的自定义 Annotation&＃xff0c;
预设上编译器会将Annotation资讯留在class档案中&＃xff0c;但不被虚拟机器读取&＃xff0c;而仅用于编译器或工具程式运行时提供资讯。
也就是说&＃xff0c;注解是建立在class文件基础上的东西&＃xff0c;同C语言的宏有异曲同工的效果。
class文件里面根本看不到注解的痕迹。
注解的基础就是反射。所以注解可以理解为java特有的一种概念。
1.元注解
在java.lang.annotation包里面&＃xff0c;已经定义了4种annotation的“原语”。
1).&＃64;Target,用于明确被修饰的类型&＃xff1a;(方法&＃xff0c;字段&＃xff0c;类&＃xff0c;接口等等)
2).&＃64;Retention,描述anntation存在的为止&＃xff1a;
RetentionPolicy.RUNTIME 注解会在class字节码文件中存在&＃xff0c;在运行时可以通过反射获取到
RetentionPolicy.CLASS 默认的保留策略&＃xff0c;注解会在class字节码文件中存在&＃xff0c;但运行时无法获得
RetentionPolicy.SOURCE 注解仅存在于源码中&＃xff0c;在class字节码文件中不包含
3).&＃64;Documented,默认情况下&＃xff0c;注解不会在javadoc中记录&＃xff0c;但是可以通过这个注解来表明这个注解需要被记录。
4).&＃64;Inherited 元注解是一个标记注解&＃xff0c;&＃64;Inherited阐述了某个被标注的类型是被继承的。
如果一个使用了&＃64;Inherited修饰的annotation类型被用于一个class&＃xff0c;则这个annotation将被用于该class的子类。
2.自定义注解
package com.joyfulmath.jvmexample.annnotaion;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* &＃64;author deman.lu
* &＃64;version on 2016-05-23 13:36
*/
&＃64;Target(ElementType.FIELD)
&＃64;Retention(RetentionPolicy.RUNTIME)
public &＃64;interface FruitName {
String value() default "";
}
首先&＃xff0c;一个注解一般需要2个元注解修饰&＃xff1a;
&＃64;Target(ElementType.FIELD)
&＃64;Retention(RetentionPolicy.RUNTIME)
具体作用上面已解释。
所有的注解都会有一个类似于“func”的部分。这个可以理解为注解的参数。
package com.joyfulmath.jvmexample.annnotaion;
import com.joyfulmath.jvmexample.TraceLog;
/**
* &＃64;author deman.lu
* &＃64;version on 2016-05-23 13:37
*/
public class Apple {
&＃64;FruitName("Apple")
String appleName;
public void displayAppleName()
{
TraceLog.i(appleName);
}
}
这段代码的log&＃xff1a;
05-23 13:39:38.780 26792-26792/com.joyfulmath.jvmexample I/Apple: displayAppleName: null [at (Apple.java:16)]
没有赋值成功&＃xff0c;为什么&＃xff1f;应为注解的“Apple”到底怎么赋值该filed&＃xff0c;目前编译器还不知道则怎么做呢。
3.注解处理器
我们还需要一个处理器来解释 注解到底是怎样工作的&＃xff0c;不然就跟注释差不多了。
通过反射的方式&＃xff0c;可以获取注解的内容&＃xff1a;
package com.joyfulmath.jvmexample.annnotaion;
import com.joyfulmath.jvmexample.TraceLog;
import java.lang.reflect.Field;
/**
* &＃64;author deman.lu
* &＃64;version on 2016-05-23 14:08
*/
public class FruitInfoUtils {
public static void getFruitInfo(Class> clazz)
{
String fruitNameStr &＃61; "";
Field[] fields &＃61; clazz.getDeclaredFields();
for(Field field:fields)
{
if(field.isAnnotationPresent(FruitName.class))
{
FruitName fruitName &＃61; field.getAnnotation(FruitName.class);
fruitNameStr &＃61; fruitName.value();
TraceLog.i(fruitNameStr);
}
}
}
}
这是注解的一般用法。
android注解框架解析
从上面可以看到&＃xff0c;注解框架的使用&＃xff0c;本质上还是要用到反射。
但是我如果用反射的功能在使用注解框架&＃xff0c;那么&＃xff0c;我还不如直接使用它&＃xff0c;反而简单。
如果有一种机制&＃xff0c;可以避免写大量重复的相似代码&＃xff0c;尤其在android开发的时候&＃xff0c;大量的findviewbyid & onClick等事件相应。
代码的模式是一致的&＃xff0c;但是代码又各不相同&＃xff0c;这个时候&＃xff0c;使用注解框架可以大量节省开发时间&＃xff0c;当然相应的会增加其他的开销。
以下就是一个使用butterknife的例子&＃xff1a;
&＃64;BindString(R.string.login_error)
String loginErrorMessage;
看上去很简单&＃xff0c;就是把字符串赋一个string res对应的初值。这样写可以节省一些时间。当然这只是一个例子&＃xff0c;
如果大量使用其他的注解&＃xff0c;可以节省很大一部分的开发时间。
我们下面来看看怎么实现的&＃xff1a;
package butterknife;
import android.support.annotation.StringRes;import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.RetentionPolicy.CLASS;
/**
* Bind a field to the specified string resource ID.
*
* {&＃64;literal &＃64;}BindString(R.string.username_error) String usernameErrorText;
*
*/
&＃64;Retention(CLASS) &＃64;Target(FIELD)
public &＃64;interface BindString {
/** String resource ID to which the field will be bound. */
&＃64;StringRes int value();
}
BindString,只有一个参数&＃xff0c;value,也就是赋值为&＃64;StringRes.
同上&＃xff0c;上面是注解定义和使用的地方&＃xff0c;但是真正解释注解的地方如下&＃xff1a;ButterKnifeProcessor
private Map findAndParseTargets(RoundEnvironment env)
这个函数&＃xff0c;截取部分代码&＃xff1a;
// Process each &＃64;BindString element.
for (Element element : env.getElementsAnnotatedWith(BindString.class)) {
if (!SuperficialValidation.validateElement(element)) continue;
try {
parseResourceString(element, targetClassMap, erasedTargetNames);
} catch (Exception e) {
logParsingError(element, BindString.class, e);
}
}
找到所有BindString注解的元素&＃xff0c;然后开始分析&＃xff1a;
private void parseResourceString(Element element, Map targetClassMap,
Set erasedTargetNames) {
boolean hasError &＃61; false;
TypeElement enclosingElement &＃61; (TypeElement) element.getEnclosingElement();
// Verify that the target type is String.
if (!STRING_TYPE.equals(element.asType().toString())) {
error(element, "&＃64;%s field type must be &＃39;String&＃39;. (%s.%s)",
BindString.class.getSimpleName(), enclosingElement.getQualifiedName(),
element.getSimpleName());
hasError &＃61; true;
}
// Verify common generated code restrictions.
hasError |&＃61; isInaccessibleViaGeneratedCode(BindString.class, "fields", element);
hasError |&＃61; isBindingInWrongPackage(BindString.class, element);
if (hasError) {
return;
}
// Assemble information on the field.
String name &＃61; element.getSimpleName().toString();
int id &＃61; element.getAnnotation(BindString.class).value();
BindingClass bindingClass &＃61; getOrCreateTargetClass(targetClassMap, enclosingElement);
FieldResourceBinding binding &＃61; new FieldResourceBinding(id, name, "getString", false);
bindingClass.addResource(binding);
erasedTargetNames.add(enclosingElement);
}
首先验证element是不是string类型。
// Assemble information on the field.
String name &＃61; element.getSimpleName().toString();
int id &＃61; element.getAnnotation(BindString.class).value();
获取field的name&＃xff0c;以及 string id。
最终
Map targetClassMap
元素和注解描述&＃xff0c;已map的方式一一对应存放。
&＃64;Override public boolean process(Set extends TypeElement> elements, RoundEnvironment env) {
Map targetClassMap &＃61; findAndParseTargets(env);
for (Map.Entry entry : targetClassMap.entrySet()) {
TypeElement typeElement &＃61; entry.getKey();
BindingClass bindingClass &＃61; entry.getValue();
try {
bindingClass.brewJava().writeTo(filer);
} catch (IOException e) {
error(typeElement, "Unable to write view binder for type %s: %s", typeElement,
e.getMessage());
}
}
return true;
}
这就是注解框架启动的地方&＃xff0c;一个独立的进程。具体细节本文不研究&＃xff0c;只需清除&＃xff0c;这里是框架驱动的地方。
从上面的信息已经清除&＃xff0c;所有的注解信息都存放在targetClassMap 里面。
上面标红的代码&＃xff0c;应该是注解框架的核心之处。
自从Java SE5开始&＃xff0c;Java就引入了apt工具&＃xff0c;可以对注解进行预处理&＃xff0c;Java SE6&＃xff0c;更是支持扩展注解处理器&＃xff0c;
并在编译时多趟处理&＃xff0c;我们可以使用自定义注解处理器&＃xff0c;在Java编译时&＃xff0c;根据规则&＃xff0c;生成新的Java代码。
JavaFile brewJava() {
TypeSpec.Builder result &＃61; TypeSpec.classBuilder(generatedClassName)
.addModifiers(PUBLIC);
if (isFinal) {
result.addModifiers(Modifier.FINAL);
} else {
result.addTypeVariable(TypeVariableName.get("T", targetTypeName));
}
TypeName targetType &＃61; isFinal ? targetTypeName : TypeVariableName.get("T");
if (hasParentBinding()) {
result.superclass(ParameterizedTypeName.get(parentBinding.generatedClassName, targetType));
} else {
result.addSuperinterface(ParameterizedTypeName.get(VIEW_BINDER, targetType));
}
result.addMethod(createBindMethod(targetType));
if (isGeneratingUnbinder()) {
result.addType(createUnbinderClass(targetType));
} else if (!isFinal) {
result.addMethod(createBindToTargetMethod());
}
return JavaFile.builder(generatedClassName.packageName(), result.build())
.addFileComment("Generated code from Butter Knife. Do not modify!")
.build();
}
这段话的关键是会create一个新文件。
然后把相关内容写入。
参考&＃xff1a;
https://github.com/JakeWharton/butterknife
京公网安备 11010802041100号