Java高级特性——Java注解介绍与底层实现原理(下)

/**

• @author Coder编程

• @Title: TestAnnotation

• @ProjectName simple-framework

• @Description: TODO

• @date 2021/4/22 14:20

*/

@MyAnnotationType

public class TestAnnotation {

@MyAnnotationField(type = 1)

private String field = “我是字段”;

@MyAnnotationMethod(“测试方法”)

public void methodTest(@MyAnnotationParameter(“测试参数”)String str){

System.out.println("我是测试方法,Str = " + str);

}

/**

• 获取类上的注解

• @throws ClassNotFoundException

*/

public static void parseTypeAnnotation() throws ClassNotFoundException {

//获取类上的注解

MyAnnotationType annotation = TestAnnotation.class.getAnnotation(MyAnnotationType.class);

System.out.println(“类上注解”+annotation);

//另外一种方法

Class clazz = Class.forName(“demo.annotation.TestAnnotation”);

/获取到类上的所有注解，只在类上，不包括成员，方法上的注解/

Annotation[] annotations = clazz.getAnnotations();

for (Annotation annotation1 : annotations) {

MyAnnotationType myAnnotationType = (MyAnnotationType)annotation1;

System.out.println(myAnnotationType.value());

}

}

/**

• 获取字段上的注解

• @throws ClassNotFoundException

*/

public static void parseFieldAnnotation() throws ClassNotFoundException {

Class clazz = Class.forName(“demo.annotation.TestAnnotation”);

Field[] declaredFields = clazz.getDeclaredFields();

for (Field declaredField : declaredFields) {

//判断成员变量中是否有指定注解类型的注解

boolean hasAnnotation = declaredField.isAnnotationPresent(MyAnnotationField.class);

if(hasAnnotation){

MyAnnotationField annotation = declaredField.getAnnotation(MyAnnotationField.class);

System.out.println(annotation.value());

}

}

}

/**

• 获取方法，参数上的注解

• @throws ClassNotFoundException

• @throws NoSuchMethodException

*/

public static void parseMethodAnnotation() throws ClassNotFoundException, NoSuchMethodException {

Class clazz = Class.forName(“demo.annotation.TestAnnotation”);

Method methodTest = clazz.getDeclaredMethod(“methodTest”, String.class);

MyAnnotationMethod annotation = methodTest.getAnnotation(MyAnnotationMethod.class);

System.out.println(annotation.value());

Annotation[][] parameterAnnotations = methodTest.getParameterAnnotations();

for (Annotation[] parameterAnnotation : parameterAnnotations) {

for (Annotation annotation1 : parameterAnnotation) {

if(annotation1 instanceof MyAnnotationParameter){

System.out.println(“方法参数上的注解：”+((MyAnnotationParameter) annotation1).value());

}

}

}

}

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {

//parseTypeAnnotation();

parseFieldAnnotation();

//parseMethodAnnotation();

}

}

大家可以将以上代码多多动手，实战敲一下，加深印象！上面有涉及到 Java的反射内容，我的文章中好像还没写过，下次补上。不太了解的同学也可以自行查询下。

注解实现原理

---

通过第一篇文章，我们知道了什么是注解，通过上面的自定义注解练习，我们又加深了对注解的印象。可是好像总是感觉少了点什么？注解的工作原理是什么？它是怎么获取到属性的值？注解的本质到底是什么？是接口呢？还是抽象类呢？

我们下来看下我们MyAnnotationType的类关系图。

可以发现MyAnnotationType底层是继承了Annotation接口。当然，我们除了用这种方法，还可以通过查看字节码的方式来查看MyAnnotationType 底层到底是啥。

这里我们的命令是：javap -v MyAnnotation.class 注：-v 是 -verbose 缩写

$ javap -v MyAnnotationType.class

Classfile /E:/Github/simple-framework/target/classes/demo/annotation/MyAnnotationType.class

Last modified 2021-4-23; size 530 bytes

MD5 checksum 142d541c8ff55e25c20881f705f9d876

Compiled from “MyAnnotationType.java”

public interface demo.annotation.MyAnnotationType extends java.lang.annotation.Annotation

minor version: 0

major version: 52

flags: ACC_PUBLIC, ACC_INTERFACE, ACC_ABSTRACT, ACC_ANNOTATION

Constant pool:

#1 = Class #17 // demo/annotation/MyAnnotationType

#2 = Class #18 // java/lang/Object

#3 = Class #19 // java/lang/annotation/Annotation

#4 = Utf8 value

#5 = Utf8 ()Ljava/lang/String;

#6 = Utf8 AnnotationDefault

#7 = Utf8 我是定义在类接口枚举类上的注解元素value的默认值

#8 = Utf8 SourceFile

#9 = Utf8 MyAnnotationType.java

#10 = Utf8 RuntimeVisibleAnnotations

#11 = Utf8 Ljava/lang/annotation/Target;

#12 = Utf8 Ljava/lang/annotation/ElementType;

#13 = Utf8 TYPE

#14 = Utf8 Ljava/lang/annotation/Retention;

#15 = Utf8 Ljava/lang/annotation/RetentionPolicy;

#16 = Utf8 RUNTIME

#17 = Utf8 demo/annotation/MyAnnotationType

#18 = Utf8 java/lang/Object

#19 = Utf8 java/lang/annotation/Annotation

{

public abstract java.lang.String value();

descriptor: ()Ljava/lang/String;

flags: ACC_PUBLIC, ACC_ABSTRACT

AnnotationDefault:

default_value: s#7}

SourceFile: “MyAnnotationType.java”

RuntimeVisibleAnnotations:

0: #11(#4=[e#12.#13])

1: #14(#4=e#15.#16)

很明显，中间写了public interface demo.annotation.MyAnnotationType extends java.lang.annotation.Annotation 因此，可以看出注解的本质是 继承Annotation接口。

接下来我们继续探索。

我们用IDEA断点来调试下我们 parseTypeAnnotation()方法

为了能更清晰的看到代码中间运行的过程。我们需要在IDEA 启动的时候加入一些参数：

-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true//记录JDK动态代理生成器，将生成代理类的文件保留下来

在 VM ptions中写入

运行完程序后，我们会得到一些文件

我们直接通过IDEA打开 $proxy1 文件。

//

// Source code recreated from a .class file by IntelliJ IDEA

// (powered by FernFlower decompiler)

//

package com.sun.proxy;

import demo.annotation.MyAnnotationType;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy1 extends Proxy implements MyAnnotationType {

private static Method m1;

private static Method m2;

private static Method m4;

private static Method m0;

private static Method m3;

public $Proxy1(InvocationHandler var1) throws {

super(var1);

}

public final boolean equals(Object var1) throws {

try {

return (Boolean)super.h.invoke(this, m1, new Object[]{var1});

} catch (RuntimeException | Error var3) {

throw var3;

} catch (Throwable var4) {

throw new UndeclaredThrowableException(var4);

}

}

public final String toString() throws {

try {

return (String)super.h.invoke(this, m2, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

public final Class annotationType() throws {

try {

return (Class)super.h.invoke(this, m4, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

public final int hashCode() throws {

try {

return (Integer)super.h.invoke(this, m0, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

public final String value() throws {

try {

return (String)super.h.invoke(this, m3, (Object[])null);

} catch (RuntimeException | Error var2) {

throw var2;

} catch (Throwable var3) {

throw new UndeclaredThrowableException(var3);

}

}

static {

try {

m1 = Class.forName(“java.lang.Object”).getMethod(“equals”, Class.forName(“java.lang.Object”));

m2 = Class.forName(“java.lang.Object”).getMethod(“toString”);

m4 = Class.forName(“demo.annotation.MyAnnotationType”).getMethod(“annotationType”);

m0 = Class.forName(“java.lang.Object”).getMethod(“hashCode”);

m3 = Class.forName(“demo.annotation.MyAnnotationType”).getMethod(“value”);

} catch (NoSuchMethodException var2) {

throw new NoSuchMethodError(var2.getMessage());

} catch (ClassNotFoundException var3) {

throw new NoClassDefFoundError(var3.getMessage());

}

}

}

小结

走到这里，我们做一次小结：我们通过 IDEA 工具图和字节码看出我们的MyAnnotationType注解（接口）其实是继承了Annotation接口的，我们通过断点的方式和设置jdk启动参数查看到了MyAnnotationType注解的中间过程，它其实 是Java运行时生成的动态代理对象$Proxy1，该类就MyAnnotationType注解（接口）的具体实现类。

动态代理类$Proxy1是如何处理annotation.value()方法的调用？

这里我们需要去补充一下Java中动态代理的知识。这里暂时不过多介绍，下次补上。需要知道的是：动态代理方法的调用最终会传递给绑定的InvocationHandler实例的invoke方法处理。

我们继续看源码

$Proxy1

我们的value()方法法最终会执行(String)super.h.invoke(this, m3, (Object[])null);，而这其中的h对象类型就是InvocationHandler接口的某个实现类

Proxy

我们通过Proxy源码进行断点调试的时候发现是AnnotationInbocationHandler。

我们通过使用IDEA 搜索到这个AnnotationInbocationHandler 这个类。找到 invoke这个方法。

class AnnotationInvocationHandler implements InvocationHandler, Serializable {

private static final long serialVersionUID = 6182022883658399397L;

private final Class<? extends Annotation> type;

private final Map<String, Object> memberValues;

private transient volatile Method[] memberMethods;

AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {

Class<?>[] superInterfaces = type.getInterfaces();

if (type.isAnnotation() && superInterfaces.length == 1 && superInterfaces[0] == Annotation.class) {

this.type = type;

this.memberValues = memberValues;

} else {

throw new AnnotationFormatError(“Attempt to create proxy for a non-annotation type.”);

}

}

public Object invoke(Object proxy, Method method, Object[] args) {

String member = method.getName();

int parameterCount = method.getParameterCount();

if (parameterCount == 1 && member == “equals” && method.getParameterTypes()[0] == Object.class) {

return this.equalsImpl(proxy, args[0]);

} else if (parameterCount != 0) {

throw new AssertionError(“Too many parameters for an annotation method”);

} else if (member == “toString”) {

return this.toStringImpl();

} else if (member == “hashCode”) {

return this.hashCodeImpl();

} else if (member == “annotationType”) {

return this.type;

} else {

Object result = this.memberValues.get(member);

if (result == null) {

throw new IncompleteAnnotationException(this.type, member);

} else if (result instanceof ExceptionProxy) {

throw ((ExceptionProxy)result).generateException();

} else {

if (result.getClass().isArray() && Array.getLength(result) != 0) {

result = this.cloneArray(result);

}

return result;

}

}

}

---

我们源码中打上断点，再来改下我们的type值。

@MyAnnotationType(“我是注解类”)

public class TestAnnotation {

…

}

通过main函数中调用 parseTypeAnnotation()方法：

/**

• 获取类上的注解

• @throws ClassNotFoundException

*/

public static void parseTypeAnnotation() throws ClassNotFoundException {

//获取类上的注解

MyAnnotationType annotation = TestAnnotation.class.getAnnotation(MyAnnotationType.class);

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

我们源码中打上断点，再来改下我们的type值。

@MyAnnotationType(“我是注解类”)

public class TestAnnotation {

…

}

通过main函数中调用 parseTypeAnnotation()方法：

/**

• 获取类上的注解

• @throws ClassNotFoundException

*/

public static void parseTypeAnnotation() throws ClassNotFoundException {

//获取类上的注解

MyAnnotationType annotation = TestAnnotation.class.getAnnotation(MyAnnotationType.class);

最后

按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。

学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。

“道路是曲折的，前途是光明的！”

[外链图片转存中…(img-CwPvMb2Q-1714404574806)]

[外链图片转存中…(img-fVhW0xPv-1714404574806)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录