关于面试技巧:基础篇深入解析JAVA注解机制

java实现注解的底层原理和概念

• java注解是JDK1.5引入的一种正文机制，java语言的类、办法、变量、参数和包都能够被注解标注。和Javadoc不同，java注解能够通过反射获取标注内容
• 在编译器生成.class文件时，注解能够被嵌入字节码中，而jvm也能够保留注解的内容，在运行时获取注解标注的内容信息
• java提供的注解能够分成两类：

<br/>作用在代码上的性能注解（局部）:

<br/>让给程序员开发自定义注解的元注解（和关键字@interface配合应用的注解）

• Annotation是所有注解类的独特接口，不必显示实现。注解类应用@interface定义（代表它实现Annotation接口），搭配元注解应用，如下

package java.lang.annotation;public interface Annotation {    boolean equals(Object obj);    int hashCode();    String toString();    // 返回定义的注解类型，你在代码申明的@XXX,相当于该类型的一实例    Class<? extends Annotation> annotationType();}-----自定义示例-----@Retention( value = RetentionPolicy.RUNTIME)@Target(value = ElementType.TYPE)public @interface ATest {    String hello() default  "siting";}

ATest的字节码文件，编译器让自定义注解实现了Annotation接口

public abstract @interface com/ATest implements java/lang/annotation/Annotation {  // compiled from: ATest.java  @Ljava/lang/annotation/Retention;(value=Ljava/lang/annotation/RetentionPolicy;.RUNTIME)  @Ljava/lang/annotation/Target;(value={Ljava/lang/annotation/ElementType;.TYPE})  // access flags 0x401  public abstract hello()Ljava/lang/String;    default="siting"}

• 自定义注解类型时，个别须要用@Retention指定注解保留范畴RetentionPolicy，@Target指定应用范畴ElementType。RetentionPolicy保留范畴只能指定一个，ElementType应用范畴能够指定多个
• 注解信息怎么和代码关联在一起，java所有事物都是类，注解也不例外，退出代码System.setProperty("sum.misc.ProxyGenerator.saveGeneratedFiles","true"); 可生成注解相应的代理类

在代码里定义的注解，会被jvm利用反射技术生成一个代理类，而后和被正文的代码（类，办法，属性等）关联起来

五种元注解详解

• @Retention：指定注解信息保留阶段，有如下三种枚举抉择。只能选其一

public enum RetentionPolicy {    /** 注解将被编译器抛弃，生成的class不蕴含注解信息 */    SOURCE,    /** 注解在class文件中可用，但会被JVM抛弃;当注解未定义Retention值时，默认值是CLASS */    CLASS,    /** 注解信息在运行期(JVM)保留（.class也有），能够通过反射机制读取注解的信息,      * 操作方法看AnnotatedElement(所有被正文类的父类) */    RUNTIME}

• @Documented：作用是通知JavaDoc工具，以后注解自身也要显示在Java Doc中(不罕用)
• @Target：指定注解作用范畴，可指定多个

public enum ElementType {    /** 适用范围：类、接口、注解类型，枚举类型enum */    TYPE,    /** 作用于类属性 (includes enum constants) */    FIELD,    /** 作用于办法 */    METHOD,    /** 作用于参数申明 */    PARAMETER,    /** 作用于构造函数申明 */    CONSTRUCTOR,    /** 作用于局部变量申明 */    LOCAL_VARIABLE,    /** 作用于注解申明 */    ；,    /** 作用于包申明 */    PACKAGE,    /** 作用于类型参数（泛型参数）申明 */    TYPE_PARAMETER,    /** 作用于应用类型的任意语句(不包含class) */    TYPE_USE}

TYPE_PARAMETER的用法示例

class D<@PTest T> { } // 注解@PTest作用于泛型T

TYPE_USE的用法示例

//用于父类或者接口 class Test implements @Parent TestP {} //用于构造函数new @Test String("/usr/data")//用于强制转换和instanceof查看,留神这些注解中用于内部工具//它们不会对类型转换或者instanceof的查看行为带来任何影响String path=(@Test String)input;if(input instanceof @Test String) //注解不会影响//用于指定异样public Person read() throws @Test IOException.//用于通配符绑定List<@Test ? extends Data>List<? extends @Test Data>@Test String.class //非法，不能标注class

• @Inherited：示意以后注解会被注解类的子类继承。即在子类Class<T>通过getAnnotations()可获取父类被@Inherited润饰的注解。而注解自身是不反对继承

@Inherited@Retention( value = RetentionPolicy.RUNTIME)@Target(value = ElementType.TYPE)public @interface ATest {  }----被ATest注解的父类PTest----@ATestpublic class PTest{ }---Main是PTest的子类----public class Main extends PTest {    public static void main(String[] args){        Annotation an = Main.class.getAnnotations()[0];          //Main能够拿到父类的注解ATest，因为ATest被元注解@Inherited润饰        System.out.println(an);    }}  ---result--@com.ATest()  

• @Repeatable：JDK1.8新退出的，表明自定义的注解能够在同一个地位重复使用。在没有该注解前，是无奈在同一个类型上应用雷同的注解屡次

  //Java8前无奈重复使用注解  @FilterPath("/test/v2")  @FilterPath("/test/v1")  public class Test {}

应用动静代理机制解决注解

• 反射机制获取注解信息

--- 作用于注解的注解----@Inherited@Retention( value = RetentionPolicy.RUNTIME)@Target(value = {ElementType.ANNOTATION_TYPE})public @interface AnnotationTest {    String value() default "AnnotationTest";}------父类-------public class PTest {}------被注解润饰的package-info.java------//package-info.java@AnTest("com-package-info")package com;-------------@AnnotationTest("AnnotationTest")@Inherited@Retention( value = RetentionPolicy.RUNTIME)@Target(value = {ElementType.TYPE_USE,ElementType.PACKAGE,ElementType.FIELD,        ElementType.TYPE_PARAMETER,ElementType.CONSTRUCTOR,ElementType.LOCAL_VARIABLE})public @interface AnTest  {    String value() default  "siting";}

运行示例

//注解类@AnTest("mainClass")//注解泛型参数                                       //注解继承父类public class Main<@AnTest("parameter") T > extends @AnTest("parent") PTest {    @AnTest("constructor")  //注解构造函数    Main(){ }    //注解字段域    private @AnTest("name") String name;    //注解泛型字段域    private @AnTest("value") T value;    //注解通配符    private @AnTest("list")List<@AnTest("generic") ?>list;    //注解办法    @AnTest("method")                       //注解办法参数    public String hello(@AnTest("methodParameter") String name)            throws @AnTest("Exception") Exception { // 注解抛出异样        //注解局部变量,当初运行时临时无奈获取（疏忽）        @AnTest("result") String result;        result = "siting";        System.out.println(name);        return  result;    }    public static void main(String[] args) throws Exception {        Main<String>  main = new Main<> ();        Class<Main<Object>> clazz = (Class<Main<Object>>) main.getClass();        //class的注解        Annotation[] annotations = clazz.getAnnotations();        AnTest testTmp = (AnTest) annotations[0];        System.out.println("润饰Main.class注解value: "+testTmp.value());        //结构器的注解        Constructor<Main<Object>> constructor = (Constructor<Main<Object>>) clazz.getDeclaredConstructors()[0];        testTmp = constructor.getAnnotation(AnTest.class);        System.out.println("润饰结构器的注解value: "+testTmp.value());        //继承父类的注解        AnnotatedType annotatedType = clazz.getAnnotatedSuperclass();        testTmp = annotatedType.getAnnotation(AnTest.class);        System.out.println("润饰继承父类的注解value: "+testTmp.value());        //注解的注解        AnnotationTest annotationTest = testTmp.annotationType().getAnnotation(AnnotationTest.class);        System.out.println("润饰注解的注解AnnotationTest-value: "+annotationTest.value());        //泛型参数 T 的注解        TypeVariable<Class<Main<Object>>> variable = clazz.getTypeParameters()[0];        testTmp = variable.getAnnotation(AnTest.class);        System.out.println("润饰泛型参数T注解value: "+testTmp.value());        //一般字段域 的注解        Field[] fields = clazz.getDeclaredFields();        Field nameField = fields[0];        testTmp = nameField.getAnnotation(AnTest.class);        System.out.println("润饰一般字段域name注解value: "+testTmp.value());        //泛型字段域 的注解        Field valueField = fields[1];        testTmp = valueField.getAnnotation(AnTest.class);        System.out.println("润饰泛型字段T注解value: "+testTmp.value());        //通配符字段域 的注解        Field listField = fields[2];        AnnotatedParameterizedType annotatedPType = (AnnotatedParameterizedType)listField.getAnnotatedType();        testTmp = annotatedPType.getAnnotation(AnTest.class);        System.out.println("润饰泛型注解value: "+testTmp.value());        //通配符注解 的注解        AnnotatedType[] annotatedTypes = annotatedPType.getAnnotatedActualTypeArguments();        AnnotatedWildcardType annotatedWildcardType = (AnnotatedWildcardType) annotatedTypes[0];        testTmp = annotatedWildcardType.getAnnotation(AnTest.class);        System.out.println("润饰通配符注解value: "+testTmp.value());        //办法的注解        Method method = clazz.getDeclaredMethod("hello", String.class);        annotatedType = method.getAnnotatedReturnType();        testTmp = annotatedType.getAnnotation(AnTest.class);        System.out.println("润饰办法的注解value: "+testTmp.value());        //异样的注解        annotatedTypes =  method.getAnnotatedExceptionTypes();        testTmp = annotatedTypes[0].getAnnotation(AnTest.class);        System.out.println("润饰办法抛出谬误的注解value: "+testTmp.value());        //办法参数的注解        annotatedTypes = method.getAnnotatedParameterTypes();        testTmp = annotatedTypes[0].getAnnotation(AnTest.class);        System.out.println("润饰办法参数注解value: "+testTmp.value());        //包的注解        Package p = Package.getPackage("com");        testTmp = p.getAnnotation(AnTest.class);        System.out.println("润饰package注解value: "+testTmp.value());        main.hello("hello");    }}

后果

润饰Main.class注解value: mainClass润饰结构器的注解value: constructor润饰继承父类的注解value: parent润饰注解的注解AnnotationTest-value: AnnotationTest润饰泛型参数T注解value: parameter润饰一般字段域name注解value: name润饰泛型字段T注解value: value润饰泛型注解value: list润饰通配符注解value: generic润饰办法的注解value: method润饰办法抛出谬误的注解value: Exception润饰办法参数注解value: methodParameter润饰package注解value: com-package-infohello

spring.AOP和注解机制

spring.AOP相当于动静代理和注解机制在spring框架的联合实现

• 前要常识：面向切面编程(AOP)和动静代理

  • C是面向过程编程的，java则是面向对象编程，C++则是两者兼备，它们都是一种标准和思维。面向切面编程也一样，能够简略了解为：切面编程专一的是部分代码，次要为某些点植入加强代码
  • 思考要部分退出加强代码，应用动静代理则是最好的实现。在被代理办法调用的前后，能够退出须要的加强性能；因而spring的切面编程是基于动静代理的
  • 切面的概念

• spring.aop提供的切面注解

• spring的告诉注解其实是告诉+指定连接点组成，分五种（Before、After、After-returning、After-throwing、Around）

• 在spring切面根底上，开发具备加强性能的自定义注解 (对注解进行切面)

新建spring-web + aop 我的项目；新建如下class------ 指标Controller ------@RestControllerpublic class TestController {    @STAnnotation    @RequestMapping("/hello")    public String hello(){  return "hello@csc";  }}------ Controller注解 -------@Retention( value = RetentionPolicy.RUNTIME)@Target(value = ElementType.METHOD)public @interface STAnnotation {    String value() default "注解hello!";}------ Controller切面 ------@Aspect@Componentpublic class ControllerAspect {    //切点:注解指定关联 (对注解进行切面)    @Pointcut("@annotation(STAnnotation)")    public void controllerX(){}    //切点:门路指定关联    @Pointcut("execution(public * com.example.demo.TestController.*(..))")    public void controllerY(){}    //在controllerY()切点执行之前的连接点退出告诉    @Before("controllerY()")    public void yBefore(JoinPoint joinPoint) throws Throwable {        //能够退出加强代码        MethodSignature methodS = (MethodSignature)joinPoint.getSignature();        Method method = methodS.getMethod();        if (method.isAnnotationPresent(STAnnotation.class)) {            STAnnotation annotation = method.getAnnotation(STAnnotation.class);            System.out.println(annotation.value());        }        System.out.println("controllerY");    }    //controllerX()切点执行之后的连接点退出告诉    @After("controllerX()")    public void xBefore(JoinPoint joinPoint) throws Throwable {        //能够退出加强代码        System.out.println("controllerX");    }}

启动我的项目；执行curl http://127.0.0.1:8080/hello,控制台输入如下

（题外）@FunctionalInterface原理介绍

• Lambda 表达式的构造：（...args）-> { ... code }

  • lambda在python,C++都对应的定义，java也有，lambda个别由入参，处理过程组成。如果解决代码只有一行，中括号{} 能够省略。其实就是简化的函数。在java里，lambda用函数式接口实现
• @FunctionalInterface作用于接口，接口能够承受lambda表达式作为右值，此类接口又叫函数式接口，其规定润饰的接口只能有一个形象的办法（不包扣静态方法和默认、公有办法）。attention:不加@FunctionalInterface润饰，只定义一个形象办法的接口默认也是函数式接口

@FunctionalInterfacepublic interface Func {  void hello(String name); }---------------------public static void main(String[] args) {        Func func = (name) -> System.out.println(name);        func.hello("siting");    }

查看对应的Main.class字节码文件 javap.exe -p -v -c Main.class

Constant pool:   #1 = Methodref          #8.#28         // java/lang/Object."<init>":()V   //常量值中后面的#0示意疏导办法取BootstrapMethods属性表的第0项(字节码在最上面)   #2 = InvokeDynamic      #0:#33         // #0:hello:()Lcom/Func;   #3 = String             #34            // siting   #4 = InterfaceMethodref #35.#36        // com/Func.hello:(Ljava/lang/String;)V   #5 = Fieldref           #37.#38        // java/lang/System.out:Ljava/io/PrintStream;   #6 = Methodref          #39.#40        // java/io/PrintStream.println:(Ljava/lang/String;)V   #7 = Class              #41            // com/Main .... // main执行字节码 public static void main(java.lang.String[]);    descriptor: ([Ljava/lang/String;)V    flags: ACC_PUBLIC, ACC_STATIC    Code:      stack=2, locals=2, args_size=1           // 动静取得一个CallSite对象，该对象是一个外部类，实现了Func接口         0: invokedynamic #2,  0              // InvokeDynamic #0:hello:()Lcom/Func;         5: astore_1         6: aload_1         7: ldc           #3                  // String siting         // 调用CallSite对象的hello办法         9: invokeinterface #4,  2            // InterfaceMethod com/Func.hello:(Ljava/lang/String;)V        14: return.... //lambda表达式 会编译出公有动态类        private static void lambda$main$0(java.lang.String);    descriptor: (Ljava/lang/String;)V    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC    Code:      stack=2, locals=1, args_size=1         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;         3: aload_0         4: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V         7: return.... //lambda表达式 会编译出一个对应的外部类         SourceFile: "Main.java"InnerClasses:     public static final #59= #58 of #62; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandlesBootstrapMethods:  0: #30 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;    Method arguments:      #31 (Ljava/lang/String;)V      //调用Main办法里的lambda$main$0静态方法（真正执行lambda的逻辑的办法）      #32 invokestatic com/Main.lambda$main$0:(Ljava/lang/String;)V      #31 (Ljava/lang/String;)V

从下面的字节码可看出，1：lambda表达式会被编译成一个公有静态方法和一个外部类；2：外部类实现了函数式接口，而实现办法会调用一个Main.class里一静态方法 3：静态方法lambda$main$0里是咱们本人写的代码逻辑。运行参数加上-Djdk.internal.lambda.dumpProxyClasses能够查看lambda对应外部类的具体信息

• 罕用函数式接口

欢送指注释中谬误

关注公众号，一起交换

参考文章

• Annotation详解
• Java注解（Annotation）原理详解
• Java Lambda表达式 实现原理剖析