带你入门Java注解
本文将从以下几点为你介绍java注解以及如何自定义
- 引言
- 注解定义
- 注解意义
- 注解分类
- 自定义
- 结束语
引言
Java注解在日常开发中经常遇到，但通常我们只是用它，难道你不会好奇注解是怎么实现的吗？为什么@Data的注解可以生成getter和setter呢？为什么@BindView可以做到不需要findViewById呢？为什么retrofit2只要写个接口就可以做网络请求呢？本文将为你一一解答其中的奥妙。另外注解依赖于反射，我相信绝大多数的Java开发者都写过反射，也都知道反射是咋回事，所以如果你还不理解反射，请先花几分钟熟悉后再阅读本文。
注解定义
Annotation也叫元数据，是代码层面的说明。它在JDK1.5以后被引入，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。我们可以简单的理解注解只是一种语法标注，它是一种约束、标记。
注解意义
Java引入注解是想把某些元数据做到与代码强耦合。因为在JDK1.5以前，描述元数据都是使用xml的，但是xml总是表现出松耦合，导致文件过多时难以维护。比如Spring早期的注入xml，如今2.0大多转为注解注入。 虽然注解做到了强耦合，但是一些常量参数使用xml会显结构更加清晰，所以在日常使用时，总是会把xml和Annotation结合起来使用以达到最优使用。
注解分类
通常我们会按照注解的运行机制将其分类，但是在按照注解的运行机制分类之前，我们先按基本分类来看一遍注解。
基本分类
-
内置注解（基本注解）
内置注解只有三个，位于java.lang包下，他们分别是
- @Override - 检查该方法是否是重载方法，如果发现其父类，或者是引用的接口中并没有该方法时，会报编译错误。
- @Deprecated - 标记过时方法，如果使用该方法，会报编译警告。
- @SuppressWarnings - 指示编译器去忽略注解中声明的警告。
-
元注解
元注解只有四个，位于java.lang.annotation包中
- @Retention - 标识这个注解怎么保存，是只在代码中，还是编入class文件中，或者是在运行时可以通过反射访问
- @Documented - 标记这些注解是否包含在用户文档中
-
@Target - 标记这个注解应该是哪种 Java 成员
- ElementType.CONSTRUCTOR 构造方法声明
- ElementType.FIELD 字段声明
- ElementType.LOCAL_VARIABLE 局部变量声明
- ElementType.METHOD 方法声明
- ElementType.PACKAGE 包声明
- ElementType.PARAMETER 参数声明
- ElementType.TYPE 类、接口方法
- @Inherited - 标记注解可继承
- 自定义注解 可以通过元注解来自定义
运行机制分类
主要是按照元注解中的@Retention参数将其分为三类
- 源码注解(@Retention(RetentionPolicy.SOURCE)) 注解只在源码中存在，编译时丢弃，编译成.class文件就不存在了
- 编译时注解(@Retention(RetentionPolicy.CLASS)) 编译时会记录到.class中，运行时忽略
- 运行时注解(@Retention(RetentionPolicy.RUNTIME)) 运行时存在起作用，影响运行逻辑，可以通过反射读取
我们可以简单的把Java程序从源文件创建到程序运行的过程看作为两大步骤
- 源文件由编译器编译成字节码
- 字节码由java虚拟机解释运行
那么被标记为RetentionPolicy.SOURCE的注解只能保留在源码级别，即最多只能在源码中对其操作，被标记为RetentionPolicy.CLASS的被保留到字节码，所以最多只到字节码级别操作，那么对应的RetentionPolicy.RUNTIME可以在运行时操作。
自定义
前面的都是司空见惯的知识点，可能大家都知道或有有了解过，但是一说到自定义，估计够呛，那么下面就按运行机制的分类，每一类都自定义一个注解看下注解到底是怎么回事。
RetentionPolicy.RUNTIME
运行时注解通常需要先通过类的实例反射拿到类的属性、方法等，然后再遍历属性、方法获取位于其上方的注解，然后就可以做相应的操作了。 比如现在有一个Person的接口以及其实现类Student。
public interface Person {
@PrintContent("来自注解 PrintContent 唱歌")
void sing(String value);
@PrintContent("来自注解 PrintContent 跑步")
void run(String value);
@PrintContent("来自注解 PrintContent 吃饭")
void eat(String value);
@PrintContent("来自注解 PrintContent 工作")
void work(String value);
}
复制代码
实现类
public class Student implements Person {
@Override
public void sing(String value) {
System.out.println(value == null ? "这是音乐课，我们在唱歌" : value);
}
@Override
public void run(String value) {
System.out.println(value == null ? "这是体育课，我们在跑步" : value);
}
@Override
public void eat(String value) {
System.out.println(value == null ? "中午我们在食堂吃饭" : value);
}
@Override
public void work(String value) {
System.out.println(value == null ? "我们的工作是学习" : value);
}
}
复制代码
执行逻辑
@Autowired
private Person person;
public void student() {
person.eat(null);
person.run(null);
person.sing(null);
person.work(null);
}
复制代码
我们需要实现的点
- 自定义属性注解@Autowired表示自动注入Student对象给person。
- 提供方法注解@PrintContent表示当value为null时打印的默认值，并在调用的方法前后插入自己想做的操作。
因为这是一个运行时的注解，所以我们需要反射先拿到这个注解，然后再对其进行操作。 Autowired的实现，可以看到非常简单，仅仅是先拿到类的所有属性，然后对其遍历，发现属性使用了Autowired注解并且是Person类型，那么就new一个Student为其赋值，这样就做到了自动注入的效果。
private static void inject(Object obj) {
Field[] declaredFields = obj.getClass().getDeclaredFields();
for (Field field : declaredFields) {
if (field.getType() == Person.class) {
if (field.isAnnotationPresent(Autowired.class)) {
field.setAccessible(true);
try {
Person student = new Student();
field.set(obj, student);
} catch (IllegalAccessException e) {
e.printStackTrace();
}}}
}}
复制代码
如果是想当value为null时打印的注解的默认值，并在调用的方法前后插入自己想做的操作。这种对接口方法进行拦截并操作的称为动态代理，java提供Proxy.newProxyInstance支持。
private static void inject(Object obj) {
Field[] declaredFields = obj.getClass().getDeclaredFields();
for (Field field : declaredFields) {
if (field.getType() == Person.class) {
if (field.isAnnotationPresent(Autowired.class)) {
field.setAccessible(true);
try {
Person student = new Student();
Class<?> cls = student.getClass();
Person person = (Person) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), new DynamicSubject(student));
field.set(obj, person);
} catch (IllegalAccessException e) {
e.printStackTrace();
}}}
}}
复制代码
其中需要自定义DynamicSubject，即对方法的真实拦截操作。这样就会把@PrintContent注解的值作为参数打印处理。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.isAnnotationPresent(PrintContent.class)) {
PrintContent printContent = method.getAnnotation(PrintContent.class);
System.out.println(String.format("----- 调用 %s 之前 -----", method.getName()));
method.invoke(object, printContent.value());
System.out.println(String.format("----- 调用 %s 之后 -----/n", method.getName()));
return proxy;
}
return null;
}
复制代码
最后附上两个自定义的注解
@Target({ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
}
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface PrintContent {
String value();
}
复制代码
以上可以帮助你对retorfit2的理解，因为动态代理就是它的核心之一。如果你想学习更多，可以参考 仿retorfit2设计实现的Activity参数注入
RetentionPolicy.SOURCE
大家或许对@BindView生成代码有所怀疑，对@Data如何生成代码有所好奇，那么我们就自定义个@Data来看看怎么注解是怎么生成代码的。本文依赖于idea工具，并非google提供的@AutoService实现。 bean是开发中经常被使用的，getter、setter方法是被我们所厌弃写的，idea帮我们做了一键生成的插件工具，但是如果这一步都都不想操作呢？我只想用一个注解生成，比如下面的User类。
@Data
public class User {
private Integer age;
private Boolean sex;
private String address;
private String name;
}
复制代码
通过@Data就可以生成这样的类，是不是很神奇？
public class User{
private Integer age;
private Boolean sex;
private String address;
private String name;
public User() {
}
public Integer getAge() {
return this.age;
}
public void setAge(Integer age) {
this.age = age;
}
public Boolean hasSex() {
return this.sex;
}
public void isSex(Boolean sex) {
this.sex = sex;
}
public String getAddress() {
return this.address;
}
public void setAddress(String address) {
this.address = address;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
复制代码
要实现这样的神奇操作，大概的思路是先自定义某个RetentionPolicy.SOURCE级别的注解，然后实现一个注解处理器并设置SupportedAnnotationTypes为当前的注解，最后在META-INF注册该注解处理器。所以首先我们定义Data注解。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
@Documented
public @interface Data {
}
复制代码
然后需要自定义注解处理器来处理Data注解
@SupportedAnnotationTypes("com.data.Data")
public class DataProcessor extends AbstractProcessor {
}
复制代码
然后在resources/META-INF文件夹下新建services文件夹，如果没有META-INF也新建。然后在services文件夹里新建javax.annotation.processing.Processor文件，注意名字是固定的，打开文件后写上前面定义的注解处理器全称，比如com.data.DataProcessor，这样就表示该注解处理器被注册了。 待程序要执行的时候，编译器会先读取这里的文件然后扫描整个工程，如果工程中有使用已注册的注解处理器中的SupportedAnnotationTypes里的注解，那么就会执行对应的注解处理中的process方法。下面重点处理注解处理器AbstractProcessor，把大部分的解释都写在注解里。
@SupportedAnnotationTypes("com.data.Data")
public class DataProcessor extends AbstractProcessor {
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "-----开始自动生成源代码");
try {
// 返回被注释的节点
Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Data.class);
for (Element e : elements) {
// 如果注释在类上
if (e.getKind() == ElementKind.CLASS && e instanceof TypeElement) {
TypeElement element = (TypeElement) e;
// 类的全限定名
String classAllName = element.getQualifiedName().toString() + "New";
// 返回类内的所有节点
List<? extends Element> enclosedElements = element.getEnclosedElements();
// 保存字段的集合
Map<Name, TypeMirror> fieldMap = new HashMap<>();
for (Element ele : enclosedElements) {
if (ele.getKind() == ElementKind.FIELD) {
//字段的类型
TypeMirror typeMirror = ele.asType();
//字段的名称
Name simpleName = ele.getSimpleName();
fieldMap.put(simpleName, typeMirror);
}
}
// 生成一个Java源文件
String targetClassName = classAllName;
if (classAllName.contains(".")) {
targetClassName = classAllName.substring(classAllName.lastIndexOf(".") + 1);
}
JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(targetClassName);
// 写入代码
createSourceFile(classAllName, fieldMap, sourceFile.openWriter());
} else {
return false;
}
}
} catch (IOException e) {
processingEnv.getMessager().printMessage(Diagnostic.Kind.ERROR, e.getMessage());
}
processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "-----完成自动生成源代码");
return true;
}
/**
* 属性首字母大写
*/
private String humpString(String name) {
String result = name;
if (name.length() == 1) {
result = name.toUpperCase();
}
if (name.length() > 1) {
result = name.substring(0, 1).toUpperCase() + name.substring(1);
}
return result;
}
private void createSourceFile(String className, Map<Name, TypeMirror> fieldMap, Writer writer) throws IOException {
// 检查属性是否以 "get", "set", "is", "has" 这样的关键字开头，如果有这样的 属性就报错
String[] errorPrefixes = {"get", "set", "is", "has"};
for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
String name = map.getKey().toString();
for (String prefix : errorPrefixes) {
if (name.startsWith(prefix)) {
throw new RuntimeException("Properties do not begin with 'get'、'set'、'is'、'has' in " + name);
}
}
}
String packageName;
String targetClassName = className;
if (className.contains(".")) {
packageName = className.substring(0, className.lastIndexOf("."));
targetClassName = className.substring(className.lastIndexOf(".") + 1);
} else {
packageName = "";
}
// 生成源代码
JavaWriter jw = new JavaWriter(writer);
jw.emitPackage(packageName);
jw.beginType(targetClassName, "class", EnumSet.of(Modifier.PUBLIC));
jw.emitEmptyLine();
for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
String name = map.getKey().toString();
String type = map.getValue().toString();
//字段
jw.emitField(type, name, EnumSet.of(Modifier.PRIVATE));
jw.emitEmptyLine();
}
for (Map.Entry<Name, TypeMirror> map : fieldMap.entrySet()) {
String name = map.getKey().toString();
String type = map.getValue().toString();
String prefixGet = "get";
String prefixSet = "set";
if (type.equals("java.lang.Boolean")) {
prefixGet = "has";
prefixSet = "is";
}
//getter
jw.beginMethod(type, prefixGet + humpString(name), EnumSet.of(Modifier.PUBLIC))
.emitStatement("return " + name)
.endMethod();
jw.emitEmptyLine();
//setter
jw.beginMethod("void", prefixSet + humpString(name), EnumSet.of(Modifier.PUBLIC), type, name)
.emitStatement("this." + name + " = " + name)
.endMethod();
jw.emitEmptyLine();
}
jw.endType().close();
}
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latestSupported();
}
}
复制代码
至此整个Data的注解生成器就写完了，由于我们的idea没有对应的插件帮助我们做一些操作，所以生成的类编译生成字节码时会报已存在异常，所以如果你想更进一步，可以考虑写个插件，本文仅限注解，未提供这样的插件。 以上完成后，只要在data class头添加@Data注解，在编译程序之前，就可以看到target/classes中存在了我们生成的代码。至此你应该了解@BindView或者@Data的原理，或许你也可以尝试自定义一个ButterKnife框架。
RetentionPolicy.CLASS
字节码级别的实际上对应用程序员来说没多大作用，因为此类注解一般是在字节码文件上进行操作，我们一般理解整个过程是在.java编译为.class后在将要被加载到虚拟机之前。那么很显然RetentionPolicy.CLASS类别的注解是直接修改字节码文件的。所以一般用此注解需要底层开发人员的配合，或者当你需要造轮子了可以考虑用一下，不过需要ASM的配合来使用的，如果仅仅是开发应用基本用不到。 不过这里还是介绍下它的使用，先造场景：现在有个People类，其中有个size属性等于9，观察到上方的类注解是@Prinln(12)，现在想在字节码层面把size的9替换为12。
@Prinln(12)
public class People {
int size = 9;
double phone = 12.0;
Boolean sex;
String name;
}
复制代码
由于我们并不知道字节码文件是怎么写的，所以需要先通过Show Bytecode的插件来查看类的字节码是啥样子的
// class version 52.0 (52)
// access flags 0x21
public class com/People {
// compiled from: People.java
@Lcom/ann/Prinln;(value=12) // invisible
// access flags 0x0
I size
// access flags 0x2
private D phone
// access flags 0x2
private Ljava/lang/Boolean; sex
// access flags 0x2
private Ljava/lang/String; name
// access flags 0x1
public <init>()V
L0
LINENUMBER 12 L0
ALOAD 0
INVOKESPECIAL java/lang/Object.<init> ()V
L1
LINENUMBER 14 L1
ALOAD 0
BIPUSH 9
PUTFIELD com/People.size : I
L2
LINENUMBER 16 L2
ALOAD 0
LDC 12.0
PUTFIELD com/People.phone : D
RETURN
L3
LOCALVARIABLE this Lcom/People; L0 L3 0
MAXSTACK = 3
MAXLOCALS = 1
}
复制代码
虽然知道了是这样的，但还是看不懂啊，咋整呢？没关系，我们看ASMified。ASM 是一个 Java 字节码操控框架。它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件，也可以在类被加载入 Java 虚拟机之前动态改变类行为。而且ASMified我们是可以看得懂的，虽然没学过，但是很好理解。比如上面的People的ASMified就是这样的。
public class PeopleDump implements Opcodes {
public static byte[] dump() throws Exception {
ClassWriter cw = new ClassWriter(0);
FieldVisitor fv;
MethodVisitor mv;
AnnotationVisitor av0;
cw.visit(52, ACC_PUBLIC + ACC_SUPER, "com/People", null, "java/lang/Object", null);
cw.visitSource("People.java", null);
{
av0 = cw.visitAnnotation("Lcom/ann/Prinln;", false);
av0.visit("value", new Integer(12));
av0.visitEnd();
}
{
fv = cw.visitField(0, "size", "I", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(ACC_PRIVATE, "phone", "D", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(ACC_PRIVATE, "sex", "Ljava/lang/Boolean;", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(ACC_PRIVATE, "name", "Ljava/lang/String;", null, null);
fv.visitEnd();
}
{
mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(12, l0);
mv.visitVarInsn(ALOAD, 0);
mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(14, l1);
mv.visitVarInsn(ALOAD, 0);
mv.visitIntInsn(BIPUSH, 9);
mv.visitFieldInsn(PUTFIELD, "com/People", "size", "I");
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLineNumber(16, l2);
mv.visitVarInsn(ALOAD, 0);
mv.visitLdcInsn(new Double("12.0"));
mv.visitFieldInsn(PUTFIELD, "com/People", "phone", "D");
mv.visitInsn(RETURN);
Label l3 = new Label();
mv.visitLabel(l3);
mv.visitLocalVariable("this", "Lcom/People;", null, l0, l3, 0);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
}
复制代码
这样的话，我们大概可以知道如果要改size=12，就只要把mv.visitIntInsn(BIPUSH, 9);这句话的9改为12就好了。不过ASM在原有的字节码文件中插入或删除或更改，本文未仔细研究。本文是简单粗暴的用新的字节码替换原字节码文件。
public void asm() {
try {
ClassReader classReader = new ClassReader(new FileInputStream("target/classes/com/People.class"));
ClassNode classNode = new ClassNode();
classReader.accept(classNode, ClassReader.SKIP_DEBUG);
System.out.println("Class Name: " + classNode.name);
AnnotationNode anNode = null;
if (classNode.invisibleAnnotations.size() == 1) {
anNode = classNode.invisibleAnnotations.get(0);
System.out.println("Annotation Descriptor : " + anNode.desc);
System.out.println("Annotation attribute pairs : " + anNode.values);
}
File file = new File("target/classes/com/People.class");
FileOutputStream outputStream = new FileOutputStream(file);
outputStream.write(copyFromBytecode(anNode == null ? 0 : (int) anNode.values.get(1)));
} catch (IOException e) {
e.printStackTrace();
}
People people = new People();
System.out.println("people : " + people.size);
}
private byte[] copyFromBytecode(int value) {
ClassWriter cw = new ClassWriter(0);
FieldVisitor fv;
MethodVisitor mv;
AnnotationVisitor av0;
cw.visit(52, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "com/People", null, "java/lang/Object", null);
cw.visitSource("People.java", null);
{
av0 = cw.visitAnnotation("Lcom.ann.Prinln;", false);
av0.visit("value", new Integer(12));
av0.visitEnd();
}
{
fv = cw.visitField(0, "size", "I", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(0, "phone", "D", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(0, "sex", "Ljava/lang/Boolean;", null, null);
fv.visitEnd();
}
{
fv = cw.visitField(0, "name", "Ljava/lang/String;", null, null);
fv.visitEnd();
}
{
mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
mv.visitCode();
Label l0 = new Label();
mv.visitLabel(l0);
mv.visitLineNumber(10, l0);
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
Label l1 = new Label();
mv.visitLabel(l1);
mv.visitLineNumber(12, l1);
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitIntInsn(Opcodes.BIPUSH, value);
mv.visitFieldInsn(Opcodes.PUTFIELD, "com/People", "size", "I");
Label l2 = new Label();
mv.visitLabel(l2);
mv.visitLineNumber(14, l2);
mv.visitVarInsn(Opcodes.ALOAD, 0);
mv.visitLdcInsn(new Double("12.0"));
mv.visitFieldInsn(Opcodes.PUTFIELD, "com/People", "phone", "D");
mv.visitInsn(Opcodes.RETURN);
Label l3 = new Label();
mv.visitLabel(l3);
mv.visitLocalVariable("this", "Lcom/People;", null, l0, l3, 0);
mv.visitMaxs(3, 1);
mv.visitEnd();
}
cw.visitEnd();
return cw.toByteArray();
}
复制代码
实际上RetentionPolicy.CLASS的使用，ASM的配合很重要，所以当你在自己的框架中需要使用这种类型的注解的时候，建议还是学好ASM再尝试写此类注解，而不是像我这样全部替换。
结束语
本文注解虽然讲解的多，但是如果你能看完到这里，相信通过了几个例子的描述，你已经知道了几类注解的基本操作过程，已经让你对各种类型的注解有基本的认识，或许看了本文你真的理解了retrofit2、ButterKnife，甚至可以自己写个简单的retrofit2或ButterKnife的框架，那就再好不过了。 最后附上 源码 ，感谢阅读。
正文到此结束
- 本文标签： struct 开发者 CTO list 处理器 bug stream ip map CEO value message id Proxy node apr 注释 key ACE IO newProxyInstance 源码 cat 代码 XML 删除 java注解 Statement 编译 find Google 实例 http 自动生成 构造方法 ssl tar FIT Document 开发 ORM 字节码 java IDE 遍历 参数 bean equals tk spring https 数据 程序员 插件 Service HashMap tag
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
近期评论
-
666
-
文章和留言都翻到11页了 没有OOM
-
-
朋友，翻页到11页，及以后，会出现OOM，无法访问
-
-
-
-
版本号是多少，你可以下载哪个代码仓库，jdk选1.8 直接跑就行
-
-
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
