目录
1、Java注解
1.1、介绍
1.2、注解的元注解
1.3、高级特性
1.4、框架中的典型应用
1.5、自定义注解
2、注解原理
2.1、注解如何存储
2.2、JVM 加载阶段
2.3、反射读取原理
2.4、default的实现机制
3、生命周期阶段
3.1、生命周期
3.2、保留策略
4、注意事项
前沿
注解（Annotation）的未来：
一、历史回溯：注解的三次进化浪潮
1.1 第一代：编译期辅助（2004–2010）
代表：@Override,@SuppressWarnings
特点：仅作用于编译器，无运行时语义
局限：无法参与程序逻辑
1.2 第二代：运行时反射驱动（2010–2020）
代表：Spring @Component,JPA @Entity
核心：@Retention(RUNTIME) + 反射
问题：
启动慢（大量反射解析）
内存占用高（代理对象）
无法用于 GraalVM Native Image
1.3 第三代：编译时代码生成（2020–至今）
代表：Lombok, MapStruct, Micronaut
突破：@Retention(SOURCE) +注解处理器（Annotation Processor）
优势：
零运行时开销
兼容 AOT 编译
类型安全
趋势：“运行时注解 → 编译时注解” 是云原生时代的必然选择。
1、Java注解
1.1、介绍
元数据的载体，它本身不执行任何操作，但可以被工具、编译器、框架读取并触发相应行为。
注解 = 不改变程序逻辑的“标记”
示例：常见注解
@Override // 编译期检查：是否重写了父类方法 @Deprecated // 标记过时方法 @SuppressWarnings("unchecked") // 抑制编译警告 @RestController // Spring：标识这是一个 REST 控制器编译器生成的特殊接口
- 注解在编译后是一个继承自java.lang.annotation.Annotation的接口
- 所有注解成员方法 = 接口中的抽象方法
- 使用注解的地方 = 生成一个匿名内部类实现该接口
1.2、注解的元注解
元注解（Meta-Annotations） =用来注解其他注解的注解。
Java 提供了 5 个：
| 元注解 | 作用 |
|---|---|
| @Retention | 指定注解生命周期（SOURCE/CLASS/RUNTIME） |
| @Target | 指定注解可用的位置（类、方法、字段等） |
| @Documented | 是否包含在 JavaDoc 中 |
| @Inherited | 是否可被子类继承（仅对类有效） |
| @Repeatable | 允许同一位置重复使用注解（Java 8+） |
示例：@Target 可选值
@Target({ ElementType.TYPE, // 类、接口、枚举 ElementType.METHOD, // 方法 ElementType.FIELD, // 字段 ElementType.PARAMETER, // 参数 ElementType.CONSTRUCTOR, // 构造函数 ElementType.LOCAL_VARIABLE, // 局部变量 ElementType.ANNOTATION_TYPE // 注解类型 })1.3、高级特性
1.@Inherited —— 注解继承
限制：仅对类上的注解有效，且只继承一级
@Inherited @Retention(RetentionPolicy.RUNTIME) @interface ParentAnno {} @ParentAnno class Parent {} class Child extends Parent {} // Child 自动拥有 @ParentAnno⚠️ 注意：只对类继承有效，接口/方法/字段不继承
2. @Repeatable —— 重复注解（Java 8+）
@Retention(RetentionPolicy.RUNTIME) @Repeatable(Authors.class) public @interface Author { String name(); } @Retention(RetentionPolicy.RUNTIME) public @interface Authors { Author[] value(); } // 使用 @Author(name = "Alice") @Author(name = "Bob") public class Book {}实际字节码：
@Authors({ @Author(name = "Alice"), @Author(name = "Bob") }) class Book {}JVM 如何知道要“展开”？
@Author 注解上标记了 @Repeatable
(Authors.class)反射 API 特殊处理：
// getAnnotationsByType(Author.class) 会自动展开 Author[] authors = Book.class.getAnnotationsByAssistant(Author.class);3. 注解成员类型限制
注解的成员只能是以下类型：
- 基本类型（int,boolean 等）
- String
- Class
- 枚举
- 其他注解
- 以上类型的数组
不能是：Object, List, 自定义对象等
1.4、框架中的典型应用
| 框架 | 注解示例 | 保留策略 | 作用 |
|---|---|---|---|
| Spring | @Component,@Autowired | RUNTIME | 依赖注入、Bean 管理 |
| JPA | @Entity,@Column | RUNTIME | ORM 映射 |
| JUnit | @Test,@BeforeEach | RUNTIME | 单元测试 |
| Lombok | @Data,@Builder | SOURCE | 编译时生成代码 |
| Swagger | @ApiOperation | RUNTIME | API 文档生成 |
1.5、自定义注解
自定义注解接口：
// 源码 @Retention(RetentionPolicy.RUNTIME) public @interface MyAnno { String value() default "hello"; int count() default 0; }编译后（等价 Java 代码）
// MyAnno.class 反编译后 public interface MyAnno extends Annotation { String value(); // 注意：没有 default！ int count(); }为什么没有 default？默认值由注解使用处的字节码或反射 API在运行时提供，不在接口中。
步骤 1：定义注解（使用 @interface）
import java.lang.annotation.*; @Retention(RetentionPolicy.RUNTIME) @Target({ElementType.METHOD, ElementType.TYPE}) // 可用在类和方法上 @Documented // 注解会包含在 JavaDoc 中 public @interface ApiVersion { String value() default "1.0"; // 成员变量（带默认值） boolean deprecated() default false; }步骤 2：使用注解
@ApiVersion(value = "2.0", deprecated = true) public class UserService { @ApiVersion("3.0") public void createUser() { ... } }步骤 3：通过反射读取（运行时）
// 读取类上的注解 ApiVersion classAnno = UserService.class.getAnnotation(ApiVersion.class); System.out.println(classAnno.value()); // 输出: 2.0 // 读取方法上的注解 Method method = UserService.class.getMethod("createUser"); ApiVersion methodAnno = method.getAnnotation(ApiVersion.class); System.out.println(methodAnno.value()); // 输出: 3.02、注解原理
2.1、注解如何存储
Java 编译器（javac）会将注解信息写入 .class 文件的属性表（Attributes）中。
1. 类/方法/字段上的注解
存在对应结构的 RuntimeVisibleAnnotations 属性中
示例：带注解的类
@MyAnno(value = "test", count = 5) public class Demo {}字节码结构（简化）
ClassFile { ... attributes_count: 2 attributes[0]: SourceFile attributes[1]: RuntimeVisibleAnnotations { ← 关键！ num_annotations: 1 annotation { type_index: #MyAnno // 指向常量池 num_element_value_pairs: 2 element_value_pairs[0]: { name="value", value="test" } element_value_pairs[1]: { name="count", value=5 } } } }2. 保留策略决定是否写入字节码
| @Retention | 是否写入.class | 属性名 |
|---|---|---|
| SOURCE | 不写入 | — |
| CLASS | 写入 | RuntimeInvisibleAnnotations |
| RUNTIME | 写入 | RuntimeVisibleAnnotations |
JVM 规范规定：
- RuntimeVisibleAnnotations → 运行时可通过反射访问
- RuntimeInvisibleAnnotations → 仅工具可读（如 ASM）
2.2、JVM 加载阶段
注解如何进入内存？当 JVM 加载 .class 文件时：
步骤 1：解析常量池
将 MyAnno 的全限定名存入运行时常量池
步骤 2：创建 java.lang.Class对象
如果注解是 RUNTIME 策略，JVM 会：
解析 RuntimeVisibleAnnotations 属性
不立即创建注解实例，而是保存原始数据（name-value pairs）
将这些数据关联到 Class/Method/Field 对象的内部字段
关键源码（OpenJDK）：
// java.lang.Class private volatile AnnotationData annotationData; // 注解数据懒加载 private AnnotationData getAnnotationData() { if (annotationData == null) { // 从 JVMTI 或字节码解析注解 annotationData = createAnnotationData(); } return annotationData; }💡注解是懒加载的：只有第一次调用 getAnnotation() 时才解析！
2.3、反射读取原理
当你调用：
MyAnno anno = clazz.getAnnotation(MyAnno.class);JVM 并不会返回一个真实的MyAnno实例，而是返回一个动态代理对象！
内部实现（简化版）
// sun.reflect.annotation.AnnotationParser static <A extends Annotation> A annotationForMap( final Class<A> type, final Map<String, Object> memberValues ) { return (A) Proxy.newProxyInstance( type.getClassLoader(), new Class<?>[] { type }, new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) { // 1. 如果是 annotationType()，返回 type if (method.getName().equals("annotationType")) return type; // 2. 否则从 memberValues 中取值 String member = method.getName(); Object value = memberValues.get(member); // 3. 处理默认值（如果 value 为 null） if (value == null) { value = method.getDefaultValue(); // ← 关键！ } return value; } } ); }为什么用代理？
节省内存：不需要为每个注解创建真实对象
支持默认值：通过method.getDefaultValue() 动态填充
类型安全：代理实现了目标注解接口
2.4、default的实现机制
问题：默认值存在哪里？
不在注解接口中
不在使用处的字节码中
而是在注解定义的.class文件的
AnnotationDefault属性中
示例：
public @interface MyAnno { String value() default "hello"; // 默认值 "hello" }字节码中的 AnnotationDefault
Method: value() attributes[0]: AnnotationDefault { default_value: "hello" }反射读取时如何获取默认值？
// 当 memberValues 中没有 "value" 键时 Object defaultValue = method.getDefaultValue(); // ← 从 AnnotationDefault 读取这就是为什么 method.getDefaultValue() 能返回默认值！
3、生命周期阶段
3.1、生命周期
Java 注解的生命周期分为三个阶段，通过 @Retention
(RetentionPolicy.XXX)指定。
如下所示：
| 保留策略（RetentionPolicy） | 生命周期 | 能否被反射读取？ | 典型用途 |
|---|---|---|---|
| SOURCE | 仅存在于源码中，编译后丢弃 | 否 | @Override, @SuppressWarnings |
| CLASS | 存在于 .class文件中，JVM 加载时不加载到内存 | 否（默认值） | 字节码分析工具（如 Lombok） |
| RUNTIME | 存在于.class 中，JVM 运行时可通过反射读取 | 是 | Spring, MyBatis, JUnit 等框架 |
关键点：只有@Retention(RUNTIME)的注解才能在运行时通过getAnnotation()获取！
3.2、保留策略
1. RetentionPolicy.SOURCE
- 作用：仅给编译器看，编译完就扔
- 例子：
@Override public String toString() { ... }- 编译器检查你是否真的重写了父类方法
- 生成的 .class 文件中没有@Override
2. RetentionPolicy.CLASS（默认）
作用：保留在字节码中，但 JVM 不加载到运行时
用途：供字节码处理工具使用（如 ASM、Lombok）
例子：Lombok 的 @Data
@Data // 编译时生成 getter/setter，运行时看不到这个注解 public class User { private String name; }3. RetentionPolicy.RUNTIME
作用：全程保留，运行时可通过反射获取
这是框架最常用的策略！
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface LogExecutionTime {} // 使用 @LogExecutionTime public void process() { ... } // 反射读取 Method method = obj.getClass().getMethod("process"); if (method.isAnnotationPresent(LogExecutionTime.class)) { // 执行 AOP 逻辑 }4、注意事项
1.推荐做法
优先使用RUNTIME：除非明确不需要运行时访问
提供默认值：减少使用者负担
String value() default "";用@Documented：让注解出现在 API 文档中
命名清晰：如 @EnableCaching 比@CacheOn 更直观
2.避免陷阱
不要滥用注解：过度使用会让代码难以理解
注意性能：反射读取注解有开销（可缓存）
线程安全：注解对象是不可变的，天然线程安全
参考文章：
1、一篇文章彻底明白重要概念——注解
