Java注解的实现原理

以你之姓@ 2022-06-06 09:52 198阅读 0赞

注解是Java里特殊的定义形式，我们用@interface定义一个注解，然后定义其属性，之后此注解可以被标识在属性，方法，类，注解等目标上。我们再使用注解是，通过目标对象的getDeclaredAnnotataion(..)等方法获取注解实例对象。但是这个实例对象是什么对象，是我们定义的注解对象吗？如果是，那么我们定义的注解是如何生成实例对象的？如果不是，那么我们获取到的是什么对象？这个就是本篇博客要讲的问题

注解很多时候被叫做Annotation,Annotation是一个接口，但是我们定义的注解和这个接口看起来没有什么直接的联系，为什么叫Annotation ? 在泛型或者反射获取一个Class对象时，我们确定获取的Class是一个注解类型，因此可以定义Class<\\? extends Annotation>，此字面上理解是注解类型继承自Annotation,是Annotation的一个拓展，我们定义的注解是如何和Annotation扯上关系的？这也是本篇博客讲的问题。

先看自定义的一个注解:

@Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.METHOD,ElementType.TYPE,ElementType.FIELD})
    public @interface After { 
    
    
        String value();
    
        String argNames() default "";
    
    }

我们定义了一个注解After，定义了两个方法，其中一个方法有默认实现返回空字符串。  
@interface，一个@符号+一个接口。可以将注解近视的看做是一个interface，里面定义了方法。当方法没有默认值时，则需要在使用注解时显式的赋值。接口的方法其实也是可以有默认实现的，比如:

public interface Inter{ 
        default boolean exists() {
            return false;
        }
    }

当一个类实现了此接口时，有默认实现的方法可以不重写。  
使用一个注解近视的看做是定义一个接口的实现类，重写那些没有默认值的方法，相当于定义注解的属性值。

那么我们通过反射获取到的注解对象是我们定义的注解@After吗？如果是，它是以什么样的形式生成的？如果不是，那又是什么？

其实我们通过反射获取到的对象是一个jdk Proxy动态代理生成的对象，整个对象继承自Proxy，实现了After接口。因此定义的@After实际就看做是一个接口，这个接口继承了Annotation接口。java在解析一个注解时，将注解视为一个interface，继承自Annotation，用jdk proxy为注解接口动态的生成代理对象。所以说所有的@interface 均 extends Annotation，我们想要获取获取注解的值时，可以像类一样使用反射获取其方法，然后调用方法获取定义的值。

Annotation接口里有一个Class

package com.bob.test.concrete.annotation;
    
    import java.lang.annotation.Annotation;
    import java.lang.reflect.Method;
    
    import org.junit.Before;
    import org.junit.Test;
    import org.springframework.util.ReflectionUtils;
    
    /** * @since 2017年8月4日 上午9:09:27 */
    public class AnnotationTest { 
    
        private Method targetMethod;
        private After after; // 明确知道是哪个注解
        private Annotation ann; // 确定是注解，但是不确定类型
    
        @After(value = "lanboal")
        public void testAnn() {
    
        }
    
        @Before
        public void init() {
            targetMethod = ReflectionUtils.findMethod(AnnotationTest.class, "testAnn");
            after = targetMethod.getDeclaredAnnotation(After.class);
            ann = targetMethod.getDeclaredAnnotation(After.class);
        }
    
        @Test
        public void testEquals() throws NoSuchMethodException, SecurityException {
            System.out.println("after:" + after.toString() + ",\t ann:" + ann.toString());
            // After和Annotation这两个变量引用的是同一个对象
            System.out.println(after == ann ? "after == ann" : "after != ann"); 
            System.out.println("After.annotationType:" + after.annotationType() + ",\t ann.annotationType:" + ann.annotationType());
            System.out.println("After.Class:" + after.getClass() + ",\t ann.Class:" + ann.getClass());
        }
    
        @Test
        public void testGetClass() {
            // 父类是Proxy
            System.out.println("after.superClass:" + after.getClass().getSuperclass() + ", ann.superClass:" + ann.getClass().getSuperclass()); 
            // 当前Proxy$Num对象实现了@After注解
            System.out.println( 
                    "after.interfaces:" + after.getClass().getInterfaces()[0].getName() + ", ann.interfaces:" + ann.getClass().getInterfaces()[0].getName());
            // 体现@After(看做是一个接口)继承Annotation接口
            System.out.println(after.getClass().getInterfaces()[0].getInterfaces()[0].getName()); 
        }
    
        @Test
        public void testGetMethod() throws Exception {
            // 代理对象Proxy$Num内的value()方法
            Method after0 = after.getClass().getMethod("value"); 
            // @Afte的value()方法
            Method after1 = after.annotationType().getMethod("value"); 
            // 代理对象Proxy$Num内的value()方法
            Method ann0 = ann.getClass().getMethod("value"); 
            // @Afte的value()方法
            Method ann1 = ann.annotationType().getMethod("value"); 
            System.out.println("[after0]:" + after0.toString() + ", [after1]:" + after1.toString());
            System.out.println("[ann0]:" + ann0.toString() + ", [ann1]:" + ann1.toString());
            System.out.println(after0 == ann0 ? "after0 == ann0" : "after0 != ann0");
    
            // 执行Proxy$Num.value()方法时会调用其代理的@After对象的value()方法,所以得到的结果和@After.value()的结果相同
            System.out.println("after0.invoke:" + after0.invoke(after) + ", after1.invoke:" + after1.invoke(after));
        }
    
        @Test
        public void testGetAnnType(){
            Class<? extends Annotation> aClass = ann.annotationType();
            System.out.println(aClass.getName());
        }
    
    }