目录
问题:
今天刷面经，发现自己不懂注解的原理，特此记录。
作用：
注解的作用主要是给编译器看的，让它帮忙生成一些代码，或者是帮忙检查、判断和校验数据。
1.给编译器看：
- 帮助编译器进行语法检查（如 @Override、@Deprecated)。
- 通过注解处处理器生成代（如Lombok的@Getter,@Setter)。
2.给运行时框架看
- 通过反射机制动态读取注解信息，实现功能增强（如依赖注入、AOP、配置管理、数据验证）等。
原理：
注解的本质一个特殊的接口，继承了java.lang.annotation.Annotation 接口。当定义一个注解时，Java 编译器会将其转换为一个实现了 Annotation 接口的代理类。
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
String value() default "defaultValue";
int priority() default 1;
}
//伪代码
public interface MyAnnotation extends Annotation {
String value(); // 对应注解中的 value 属性
int priority(); // 对应注解中的 priority 属性
}
//验证
@Retention(RetentionPolicy.RUNTIME) 可以通过反射机制拿去值
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException, UnknownHostException {
//获取目标类
Class<Student> studentClass = Student.class;
//判断类有没有注解
if(studentClass.isAnnotationPresent(MyAnnotation.class)){
//拿到代理对象
MyAnnotation annotation = studentClass.getAnnotation(MyAnnotation.class);
System.out.println("value："+annotation.value());
System.out.println("priotity："+annotation.priority());
}
}注解的限制
虽然注解看起来像普通的接口，但它们有一些特殊的限制：
- 不能继承其他接口 ：注解不能继承其他接口（除了隐式的
Annotation接口）。public @interface MyAnnotation extends SomeOtherInterface {} // 错误！ - 不能包含方法体 ：注解中的方法只能声明，不能有实现。
public @interface MyAnnotation { String value() { return "defaultValue"; } // 错误！ } - 不支持泛型 ：注解中的方法不能使用泛型。
public @interface MyAnnotation { List<String> values(); // 正确 List<T> values(); // 错误！ }
拓展：
java.lang.annotation.Annotation 是所有注解的父接口。它定义了一些通用的方法，用于处理注解的元数据。
package java.lang.annotation;
/**
* The common interface extended by all annotation interfaces. Note that an
* interface that manually extends this one does <i>not</i> define
* an annotation interface. Also note that this interface does not itself
* define an annotation interface.
*
* More information about annotation interfaces can be found in section
* {@jls 9.6} of <cite>The Java Language Specification</cite>.
*
* The {@link java.lang.reflect.AnnotatedElement} interface discusses
* compatibility concerns when evolving an annotation interface from being
* non-repeatable to being repeatable.
*
* @author Josh Bloch
* @since 1.5
*/
/**
* 所有注解接口继承的公共接口。注意：手动扩展此接口的接口<i>不会</i>成为注解接口。
* 此接口自身也不作为注解接口。
*
* 更多注解接口的详细信息，请参阅《Java语言规范》第{@jls 9.6}节。
*
* 当注解接口从不可重复变为可重复时，{@link java.lang.reflect.AnnotatedElement}
* 接口讨论了相关的兼容性问题。
*
* 作者：Josh Bloch
* 自版本：1.5
*/
public interface Annotation {
public interface Annotation {
/**
* Returns true if the specified object represents an annotation
* that is logically equivalent to this one. In other words,
* returns true if the specified object is an instance of the same
* annotation interface as this instance, all of whose members are equal
* to the corresponding member of this annotation, as defined below:
* <ul>
* <li>Two corresponding primitive typed members whose values are
* {@code x} and {@code y} are considered equal if {@code x == y},
* unless their type is {@code float} or {@code double}.
*
* <li>Two corresponding {@code float} members whose values
* are {@code x} and {@code y} are considered equal if
* {@code Float.valueOf(x).equals(Float.valueOf(y))}.
* (Unlike the {@code ==} operator, NaN is considered equal
* to itself, and {@code 0.0f} unequal to {@code -0.0f}.)
*
* <li>Two corresponding {@code double} members whose values
* are {@code x} and {@code y} are considered equal if
* {@code Double.valueOf(x).equals(Double.valueOf(y))}.
* (Unlike the {@code ==} operator, NaN is considered equal
* to itself, and {@code 0.0} unequal to {@code -0.0}.)
*
* <li>Two corresponding {@code String}, {@code Class}, enum, or
* annotation typed members whose values are {@code x} and {@code y}
* are considered equal if {@code x.equals(y)}. (Note that this
* definition is recursive for annotation typed members.)
*
* <li>Two corresponding array typed members {@code x} and {@code y}
* are considered equal if {@code Arrays.equals(x, y)}, for the
* appropriate overloading of {@link java.util.Arrays#equals Arrays.equals}.
* </ul>
*
* @return true if the specified object represents an annotation
* that is logically equivalent to this one, otherwise false
*/
boolean equals(Object obj);
/**
* Returns the hash code of this annotation.
*
* <p>The hash code of an annotation is the sum of the hash codes
* of its members (including those with default values).
*
* The hash code of an annotation member is (127 times the hash code
* of the member-name as computed by {@link String#hashCode()}) XOR
* the hash code of the member-value.
* The hash code of a member-value depends on its type as defined below:
* <ul>
* <li>The hash code of a primitive value <i>{@code v}</i> is equal to
* <code><i>WrapperType</i>.valueOf(<i>v</i>).hashCode()</code>, where
* <i>{@code WrapperType}</i> is the wrapper type corresponding
* to the primitive type of <i>{@code v}</i> ({@link Byte},
* {@link Character}, {@link Double}, {@link Float}, {@link Integer},
* {@link Long}, {@link Short}, or {@link Boolean}).
*
* <li>The hash code of a string, enum, class, or annotation member-value
* <i>{@code v}</i> is computed as by calling
* <code><i>v</i>.hashCode()</code>. (In the case of annotation
* member values, this is a recursive definition.)
*
* <li>The hash code of an array member-value is computed by calling
* the appropriate overloading of
* {@link java.util.Arrays#hashCode(long[]) Arrays.hashCode}
* on the value. (There is one overloading for each primitive
* type, and one for object reference types.)
* </ul>
*
* @return the hash code of this annotation
*/
int hashCode();
/**
* Returns a string representation of this annotation. The details
* of the representation are implementation-dependent, but the following
* may be regarded as typical:
* <pre>
* @com.example.Name(first="Duke", middle="of", last="Java")
* </pre>
*
* @return a string representation of this annotation
*/
String toString();
/**
* Returns the annotation interface of this annotation.
*
* @apiNote Implementation-dependent classes are used to provide
* the implementations of annotations. Therefore, calling {@link
* Object#getClass getClass} on an annotation will return an
* implementation-dependent class. In contrast, this method will
* reliably return the annotation interface of the annotation.
*
* @return the annotation interface of this annotation
* @see Enum#getDeclaringClass
*/
Class<? extends Annotation> annotationType();
}