Springboot 注解类里面public @interface xxx 什么意思

@interface 不是interface，是注解类  定义注解
是jdk1.5之后加入的，java没有给它新的关键字，所以就用@interface 这么个东西表示了 
这个注解类，就是定义一个可用的注解，包括这个注解用于什么地方，是类，还是方法，还是property，还是方法入参等等

@Inherited       //这个Annotation 可以被继承  

@Documented  //这个Annotation可以被写入javadoc  

@Retention(RetentionPolicy.RUNTIME)

注解@Retention可以用来修饰注解，是注解的注解，称为元注解。

public enum RetentionPolicy {   
    SOURCE, // 编译器处理完Annotation后不存储在class中   
    CLASS, // 编译器把Annotation存储在class中，这是默认值   
    RUNTIME // 编译器把Annotation存储在class中，可以由虚拟机读取,反射需要   
} 

@Target:注解的作用目标

@Target(ElementType.TYPE)   //接口、类、枚举、注解
　　　　　　　　@Target(ElementType.FIELD) //字段、枚举的常量
　　　　　　　　@Target(ElementType.METHOD) //方法
　　　　　　　　@Target(ElementType.PARAMETER) //方法参数
　　　　　　　　@Target(ElementType.CONSTRUCTOR)  //构造函数
　　　　　　　　@Target(ElementType.LOCAL_VARIABLE)//局部变量
　　　　　　　　@Target(ElementType.ANNOTATION_TYPE)//注解
　　　　　　　　@Target(ElementType.PACKAGE) ///包   

ElementType源码：

public enum ElementType {   
    TYPE, // 指定适用点为 class, interface, enum   
    FIELD, // 指定适用点为 field   
    METHOD, // 指定适用点为 method   
    PARAMETER, // 指定适用点为 method 的 parameter   
    CONSTRUCTOR, // 指定适用点为 constructor   
    LOCAL_VARIABLE, // 指定使用点为 局部变量   
    ANNOTATION_TYPE, //指定适用点为 annotation 类型   
    PACKAGE // 指定适用点为 package   
}  
 

 Annotation的一般形式是 :

public @interface MyAnnotation {  
    String value() default "hahaha";  
} 

其实等同于

public class MyAnnotation extends java.lang.annotation.Annotation{   
     private String value = "hahaha";   
     public void setValue(String value){   
          this.value = value;   
     }   
     public String getValue(){   
          return value;   
      }   
} 

@MyAnnotation(value="hello")     //对应Bean的set方法   
Method method = AnnotationTest.class.getMethod("doSomthing", null);   //取得被注释的方法,AnnotationTest.class为该方法所在的类   
MyRetention mr = method.getAnnotation(MyRetention.class); //取得注释对象   
String value = mr.value();    //取得value的值,对应Bean的get方法. 

  java.lang.annotation.Retention告诉编译器如何对待 Annotation,使用Retention时,需要提供java.lang.annotation.RetentionPolicy的 枚举值.

package com.self;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
 
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTarget
{ }
定义个一注解@MyTarget，用RetentionPolicy.RUNTIME修饰；
package com.self;
import java.lang.reflect.Method;
public class MyTargetTest
{
 @MyTarget
 public void doSomething()
 {
  System.out.println("hello world");
 }
 
 public static void main(String[] args) throws Exception
 {
  Method method = MyTargetTest.class.getMethod("doSomething",null);
  if(method.isAnnotationPresent(MyTarget.class))//如果doSomething方法上存在注解@MyTarget，则为true
  {
   System.out.println(method.getAnnotation(MyTarget.class));
  }
  }
}
上面程序打印：@com.self.MyTarget()，如果RetentionPolicy值不为RUNTIME,则不打印。
 
 @Retention(RetentionPolicy.SOURCE )
public @interface Override
 
@Retention(RetentionPolicy.SOURCE )
public @interface SuppressWarnings
 
@Retention(RetentionPolicy.RUNTIME )
public @interface Deprecated
由上可以看出，只有注解@Deprecated在运行时可以被JVM读取到
 
注解中可以定义属性，看例子：
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation
{
 String hello() default "gege";
  String world();
  int[] array() default { 2, 4, 5, 6 };
  EnumTest.TrafficLamp lamp() ;
  TestAnnotation lannotation() default @TestAnnotation(value = "ddd");
  Class style() default String.class;
}
上面程序中，定义一个注解@MyAnnotation，定义了6个属性，他们的名字为：
hello,world,array,lamp,lannotation,style.
属性hello类型为String,默认值为gege
属性world类型为String,没有默认值
属性array类型为数组,默认值为2，4，5，6
属性lamp类型为一个枚举,没有默认值
属性lannotation类型为注解,默认值为@TestAnnotation，注解里的属性是注解
属性style类型为Class,默认值为String类型的Class类型
 
看下面例子:定义了一个MyTest类，用注解@MyAnnotation修饰，注解@MyAnnotation定义的属性都赋了值
@MyAnnotation(hello = "beijing", world="shanghai",array={},lamp=TrafficLamp.RED,style=int.class)
public class MyTest
{
 @MyAnnotation(lannotation=@TestAnnotation(value="baby"), world = "shanghai",array={1,2,3},lamp=TrafficLamp.YELLOW)
 @Deprecated
 @SuppressWarnings("")
 public void output()
 {
  System.out.println("output something!");
 }
}
 接着通过反射读取注解的信息：
public class MyReflection
{
 public static void main(String[] args) throws Exception
 {
  MyTest myTest = new MyTest();
    Class<MyTest> c = MyTest.class;
    Method method = c.getMethod("output", new Class[] {});
       //如果MyTest类名上有注解@MyAnnotation修饰，则为true
  if(MyTest.class.isAnnotationPresent(MyAnnotation.class))
  {
   System.out.println("have annotation");
  }
   if (method.isAnnotationPresent(MyAnnotation.class))
   {
   method.invoke(myTest, null); //调用output方法
   //获取方法上注解@MyAnnotation的信息
     MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
    String hello = myAnnotation.hello();
   String world = myAnnotation.world();
   System.out.println(hello + ", " + world);//打印属性hello和world的值
   System.out.println(myAnnotation.array().length);//打印属性array数组的长度
   System.out.println(myAnnotation.lannotation().value()); //打印属性lannotation的值
   System.out.println(myAnnotation.style());
   }
    //得到output方法上的所有注解，当然是被RetentionPolicy.RUNTIME修饰的
     Annotation[] annotations = method.getAnnotations();
      for (Annotation annotation : annotations)
  {
   System.out.println(annotation.annotationType().getName());
  }
   }
}
上面程序打印：
have annotation
output something!
gege, shanghai
3
baby
class java.lang.String
com.heima.annotation.MyAnnotation
java.lang.Deprecated
如果注解中有一个属性名字叫value,则在应用时可以省略属性名字不写。
可见，@Retention(RetentionPolicy.RUNTIME )注解中，RetentionPolicy.RUNTIME是注解属性值，属性名字是value,
属性的返回类型是RetentionPolicy，如下：
public @interface MyTarget
{
    String value();
}
可以这样用：
  @MyTarget("aaa")
 public void doSomething()
 {
  System.out.println("hello world");
 }
 
注解@Target也是用来修饰注解的元注解，它有一个属性ElementType也是枚举类型，
值为：ANNOTATION_TYPE CONSTRUCTOR  FIELD LOCAL_VARIABLE METHOD PACKAGE PARAMETER TYPE
如@Target(ElementType.METHOD) 修饰的注解表示该注解只能用来修饰在方法上。
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTarget
{
 String value() default "hahaha";
}
如把@MyTarget修饰在类上，则程序报错，如：
@MyTarget
public class MyTargetTest