Java注解的原理

目录

问题:

作用：

原理：

注解的限制

拓展：

---

问题:

今天刷面经，发现自己不懂注解的原理，特此记录。

作用：

注解的作用主要是给编译器看的，让它帮忙生成一些代码，或者是帮忙检查、判断和校验数据。

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());}}

注解的限制

虽然注解看起来像普通的接口，但它们有一些特殊的限制：

1. 不能继承其他接口 ：注解不能继承其他接口（除了隐式的 Annotation 接口）。
   public @interface MyAnnotation extends SomeOtherInterface {} // 错误！

   
2. 不能包含方法体 ：注解中的方法只能声明，不能有实现。
   public @interface MyAnnotation {
   String value() { return "defaultValue"; } // 错误！
   }

   
3. 不支持泛型 ：注解中的方法不能使用泛型。
   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>*   &#064;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();
}