自定义注解：

参考自：https://blog.csdn.net/cb905259982/article/details/73161948

和 https://www.cnblogs.com/gmq-sh/p/4798194.html

一、 元注解（meta-annotation）：

是放在被定义的一个注解类的前面，作用就是负责注解其他注解。

1. 元注解定义：new->annotation->name: Annotation01->finish

（1）注解的定义使用关键词 @interface，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。

（2） public @interface 注解名 {定义体}

（3）在定义注解时，不能继承其他的注解或接口

（4） @interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。

（5）并在上面一行注明@Rentention(arg) 或者@Target(args) 。

示例：

@Rentention(RetentionPolicy.RUNTIME)

public @interface Annotation01 {

//定义公共的final静态属性

.....

//定以公共的抽象方法

......

}

(6) 注解参数的可支持数据类型：

1.所有基本数据类型（int,float,boolean,byte,double,char,long,short)

2.String类型

3.Class类型

4.enum类型

5.Annotation类型

6.以上所有类型的数组

　Annotation类型里面的参数该怎么设定:

　　第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；　　

　　第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和 String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;　　

第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。

简单的自定义注解和使用注解实例：

 1 package annotation;
 2 import java.lang.annotation.Documented;
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 /**
 8  * 水果名称注解
 9  * @author peida
10  *
11  */
12 @Target(ElementType.FIELD)
13 @Retention(RetentionPolicy.RUNTIME)
14 @Documented
15 public @interface FruitName {
16     String value() default "";
17 }
18 
19 package annotation;
20 import java.lang.annotation.Documented;
21 import java.lang.annotation.ElementType;
22 import java.lang.annotation.Retention;
23 import java.lang.annotation.RetentionPolicy;
24 import java.lang.annotation.Target;
25 /**
26  * 水果颜色注解
27  * @author peida
28  *
29  */
30 @Target(ElementType.FIELD)
31 @Retention(RetentionPolicy.RUNTIME)
32 @Documented
33 public @interface FruitColor {
34     /**
35      * 颜色枚举
36      * @author peida
37      *
38      */
39     public enum Color{ BULE,RED,GREEN};
40     /**
41      * 颜色属性
42      * @return
43      */
44     Color fruitColor() default Color.GREEN;
45 }
46 
47 package annotation;
48 import annotation.FruitColor.Color;
49 public class Apple {
50     @FruitName("Apple")
51     private String appleName;
52     @FruitColor(fruitColor=Color.RED)
53     private String appleColor;
54         public void setAppleColor(String appleColor) {
55         this.appleColor = appleColor;
56     }
57     public String getAppleColor() {
58         return appleColor;
59     }
60     public void setAppleName(String appleName) {
61         this.appleName = appleName;
62     }
63     public String getAppleName() {
64         return appleName;
65     }
66     public void displayName(){
67         System.out.println("水果的名字是：苹果");
68     }
69 }

2. 注解元素的默认值：

注解元素必须有确定的值，要么在定义注解的默认值中指定，要么在使用注解时指定，非基本类型的注解元素的值不可为null。因此, 使用空字符串或0作为默认值是一种常用的做法。这个约束使得处理器很难表现一个元素的存在或缺失的状态，因为每个注解的声明中，所有元素都存在，并且都具有相应的值，为了绕开这个约束，我们只能定义一些特殊的值，例如空字符串或者负数，一次表示某个元素不存在，在定义注解时，这已经成为一个习惯用法。例如：

 1 package annotation;
 2 import java.lang.annotation.Documented;
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 /**
 8  * 水果供应者注解
 9  * @author peida
10  *
11  */
12 @Target(ElementType.FIELD)
13 @Retention(RetentionPolicy.RUNTIME)
14 @Documented
15 public @interface FruitProvider {
16     /**
17      * 供应商编号
18      * @return
19      */
20     public int id() default -1;
21     /**
22      * 供应商名称
23      * @return
24      */
25     public String name() default "";
26     /**
27      * 供应商地址
28      * @return
29      */
30     public String address() default "";
31 }

3.元注解的类型（位于java.lang.annotation包）

（1）@Retention（保留，记忆力的意思）：用来说明该注解类的生命周期。它有以下三个参数：

RetentionPolicy.SOURCE : 注解只保留在源文件中（在源文件中有效）

RetentionPolicy.CLASS : 注解保留在class文件中（:在class文件中有效），在加载到JVM虚拟机时丢弃

RetentionPolicy.RUNTIME : 注解保留在程序运行期间（在运行时有效），此时可以通过反射获得定义在某个类上的所有注解。

示例：

1 @Target(ElementType.FIELD)
2 @Retention(RetentionPolicy.RUNTIME)    
3 public @interface Column {
4     public String name() default "fieldName";
5     public String setFuncName() default "setField";
6     public String getFuncName() default "getField"; 
7     public boolean defaultDBValue() default false;
8 }

说明：Column注解的的RetentionPolicy的属性值是RUTIME,这样注解处理器可以通过反射，获取到该注解的属性值，从而去做一些运行时的逻辑处理

（2）@Target : 用于描述注解的使用范围， 即用来说明该注解可以被声明在哪些元素之前。

ElementType.TYPE：说明该注解只能被声明在一个类/接口(包括注解类型) / enum声明前。

ElementType.FIELD：说明该注解只能被声明在一个类的字段前。

ElementType.METHOD：说明该注解只能被声明在一个类的方法前。

ElementType.PARAMETER：说明该注解只能被声明在一个方法参数前。

ElementType.CONSTRUCTOR：说明该注解只能声明在一个类的构造方法前。

ElementType.LOCAL_VARIABLE：说明该注解只能声明在一个局部变量前。

ElementType.ANNOTATION_TYPE：说明该注解只能声明在一个注解类型前。

ElementType.PACKAGE：说明该注解只能声明在一个包名前。

示例：

//示例1：
@Target(ElementType.TYPE)
public @interface Table {
    /**
     * 数据表名称注解，默认值为类名称
     * @return
     */
    public String tableName() default "className";
}

//示例2：
@Target(ElementType.FIELD)
public @interface NoDBColumn {

}

说明：

示例1中注解Table 可以用于注解类、接口(包括注解类型) 或enum声明,

而示例2中注解NoDBColumn仅可用于注解类的成员变量

（3）@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。

定义了注解，并在需要的时候给相关类，类属性加上注解信息，如果没有响应的注解信息处理流程，注解可以说是没有实用价值。如何让注解真真的发挥作用，主要就在于注解处理方法，下一步我们将学习注解信息的获取和处理！

二、 注解的使用

1. 第一步：新建一个annotation，名字为：MyAnnotation.java。（new->annotation-> name:MyAnnotation->finish）

 1 package kklazy.metaannotation;
 2 
 3 import java.lang.annotation.ElementType;
 4 import java.lang.annotation.Retention;
 5 import java.lang.annotation.RetentionPolicy;
 6 import java.lang.annotation.Target;
 7 
 8 /**
 9  * @author whh
10  *
11  */
12 //RUNTIME:在运行时有效，此时可以通过反射获得定义在某个类上的所有注解。
13 @Retention(RetentionPolicy.RUNTIME)
14 @Target(ElementType.METHOD)//METHOD：表明该注解只能被声明在一个类的方法前
15 public @interface MyAnnotation {
16     String hello() default "hello";
17     String world() ;
18 }

2. 第二步：建立一个MyAnnotationTest.java 来使用上面的annotation。

1 package com.dragon.test.annotation;
2 public class MyTest
3 {
4 
5     @MyAnnotation(hello = "Hello,Beijing",world = "Hello,world")
6     public void output() {
7         System.out.println("method output is running ");
8     }
9 }

3. 第三步：用反射机制来调用注解中的内容

 1 package kklazy.metaannotation;
 2 import java.lang.annotation.Annotation;
 3 import java.lang.reflect.Method;
 4 
 5 /**
 6  * @author whh
 7  * 注解处理流程：用反射机制来调用注解中的内容
 8  */
 9 public class AnnotationProcessFlow {
10     /**
11      * @param args
12      */
13     public static void main(String[] args) {
14         //获取调用注解的类
15         Class<MyAnnotationTest> myAnnotationTestClass =  MyAnnotationTest.class;
16         //获得要调用的|方法，output是要调用的方法名字，new Class[]{}为所需要的参数。空则不是这种
17         Method  method = null;
18         try {
19             method=  myAnnotationTestClass.getMethod("output", new Class[]{});
20         } catch (Exception e) {
21             e.printStackTrace();
22         }
23         //判断output方法上是否有类型为MyAnnotation的注解
24         if(method.isAnnotationPresent(MyAnnotation.class)){
25             //获得指定注解MyAnnotation(method.getAnnotation(AnnotationName.class))
26              MyAnnotation  annotation=  method.getAnnotation(MyAnnotation.class);
27              //调用注解的内容(参数)
28              System.out.println(annotation.hello());
29              System.out.println(annotation.world());
30         }
31         System.out.println("-------------------------------------");
32         //获取所有注解  必须是runtime类型的才能获取到注解
33         Annotation[] annotations = method.getAnnotations();
34         for (Annotation annotation : annotations) {
35 
36             // 遍历所有注解的名字
37             System.out.println(annotation.annotationType().getName());
38         }
39     }
40 
41 }

最后结果：

三、自定义注解在项目中案例