概述

注解Annotation是一种引用数据类型，编译之后也是生成xxx.class文件，其定义的语法格式是：
[修饰符列表] @interface 注解类型名{ }
注解使用在类、属性、方法、变量、别的注解等上面，其实可以出现在几乎所有的标识符上，示例如下：

  1. package annotation;
  3. public @interface MyAnnotation {
  5. }
  1. package annotation;
  3. @MyAnnotation
  4. public class AnnotationTest01  {
  6.     @MyAnnotation
  7.     private int no;
  9.     @MyAnnotation
  10.     public String name;
  12.     protected String password;
  14.     @MyAnnotation
  15.     public static final float PI = 3.14f;
  17.     @MyAnnotation
  18.     public void test(){
  20.         @MyAnnotation
  21.         int num;
  22.     }
  24.     @MyAnnotation
  25.     public void run(@MyAnnotation String name){
  27.     }
  29. }
  1. package annotation;
  3. @MyAnnotation
  4. public @interface OneAnnotatione {
  5. }

JDK内置的注解

java.lang包下的注释类型：
Deprecated是用@Deprecated注释的程序元素，不鼓励程序员使用这样的元素，通常是因为它很危险或存在更好的选择；
Override表示一个方法声明打算重写超类中的另一个方法声明；
SuppressWarning显示应该在注释元素中取消显示指定的编译器警告。

Override注解

  1. package annotation;
  2. /*
  3. @Target(ElementType.METHOD)
  4. @Retention(RetentionPolicy.SOURCE)
  5. public @interface Override {
  6. }
  7. ①只能注解方法
  8. ②这个注解是给编译器参考的，和运行阶段没有关系
  9. ③凡是java中的方法带有这个注解的，编译器都会进行编译检查，若没有重写父类编译器就会报错
  10.  */
  11. public class AnnotationTest02 {
  12.     @Override
  13.     public String toString() {
  14.         return super.toString();
  15.     }
  16. }

注解最后编译生成.class文件。
以上，注解的注解称为元注解，@Target、@Retention就是元注解。

关于@Target注解

这是一个元注解，用来标注“注解类型”的“注解”，这个注解可以用来标注“被标注的注解”应该出现在哪些位置上。比如@Target(ElementType.METHOD)就表示被标注的注解可以出现在方法上。

关于@Retention注解

这是一个元注解，用来标记“被标记的注解”应该最终保存在哪里。
比如，@Retention(RetentionPolicy.SOURCE)就表示该注解最终只能被保留在java源文件中；
@Retention(RetentionPolicy.CLASS)表示该注解最终保留到class文件中；
@Retention(RetentionPolicy.RUNTIME)表示该注解最终保留到class文件中，并且可以被反射机制读取到。

Deprecated注解

  1. @Documented
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
  4. public @interface Deprecated {
  5. }
  1. package annotation;
  3. /*
  4. 已过时，有更好的替代，尽量不要调用
  5.  */
  6. public class AnnotationTest03 {
  7.     public static void main(String[] args) {
  8.         //表示这个方法已过时
  9.         AnnotationTest03 at = new AnnotationTest03();
  10.         at.doSome();    //do some...
  11.         AnnotationTest03.doSome();  //do some...
  12.         AnnotationTest03.doOther(); //do other...
  13.     }
  15.     @Deprecated
  16.     public static void doSome(){
  17.         System.out.println("do some...");
  18.     }
  20.     public static void doOther(){
  21.         System.out.println("do other...");
  22.     }
  24. }

自定义注解

  1. package annotation;
  3. public @interface OneAnnotatione {
  4.     String value();
  5. }
  1. package annotation;
  3. public @interface MyAnnotation {
  4.     /**
  5.      * 我们通常在注解中可以定义属性，以下这个是MyAnnotation的name属性
  6.      * 看着像一个方法，实际上他就是一个属性name
  7.      * @return
  8.      */
  9.     String name();
  10.     String color();
  12.     /**
  13.      * 年龄属性默认为25
  14.      * @return
  15.      */
  16.     int age() default 25;
  17.     String value();
  18. }
  1. package annotation;
  3. public class AnnotationTest04 {
  4.     //(属性名=属性值)
  5.     @MyAnnotation(name = "zhangsan",color = "黑色",value = "xixixi")
  6.     public void doSome(){
  7.         System.out.println("do some...");
  8.     }
  10.     //注解属性只有value时，在使用时该属性名可以省略
  11.     @OneAnnotatione("圣诞老人")
  12.     public void doOther(){
  13.         System.out.println("do other...");
  14.     }
  15. }

自定义注解的使用

  1. package annotation;
  3. public @interface OneAnnotatione {
  4.     String value();
  5. }
  1. package annotation;
  3. public @interface MyAnnotation {
  4.     /**
  5.      * 我们通常在注解中可以定义属性，以下这个是MyAnnotation的name属性
  6.      * 看着像一个方法，实际上他就是一个属性name
  7.      * @return
  8.      */
  9.     String name();
  10.     String color();
  12.     /**
  13.      * 年龄属性默认为25
  14.      * @return
  15.      */
  16.     int age() default 25;
  17.     String value();
  18. }
  1. package annotation.annotation4;
  3. public @interface OtherAnnotation {
  4.     int age();
  5.     String[] email();
  6.     Season[] seasonArray();
  7. }
  1. package annotation.annotation4;
  3. public enum Season {
  4.     SPRING,SUMMER,AUTNMN,WINTER
  5. }
  1. package annotation.annotation4;
  3. public class OtherAnnotationTest {
  4.     @OtherAnnotation(age = 25,email = {"zs@qq.com","ls@sohu.com"},seasonArray = Season.AUTNMN)
  5.     public void doSome(){
  7.     }
  9.     //数组只有一个则大括号可省略
  10.     @OtherAnnotation(age = 26,email = "zs@163.com",seasonArray = {Season.SPRING,Season.WINTER})
  11.     public void doOther(){
  13.     }
  14. }

通过反射获取注解属性值

  1. package annotation;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. @Target({ElementType.METHOD,ElementType.TYPE,ElementType.FIELD,ElementType.CONSTRUCTOR})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface MyAnnotation {
  11.     String value() default "杭州西湖区";
  12. }
  1. package annotation;
  3. @MyAnnotation
  4. public class MyAnnotationTest {
  5.     @MyAnnotation
  6.     int i;
  8.     @MyAnnotation
  9.     public void doSome(){
  11.     }
  13.     @MyAnnotation
  14.     public MyAnnotationTest(){
  16.     }
  17. }
  1. package annotation;
  3. import java.lang.annotation.Annotation;
  5. public class ReflectAnnotationTest {
  6.     public static void main(String[] args) throws Exception{
  7.         //获取这个类的对象
  8.         Class c = Class.forName("annotation.MyAnnotationTest");
  9.         //判断这个类是否有注解@MyAnnotation
  10. //        boolean annotationPresent = c.isAnnotationPresent(MyAnnotation.class);
  11. //        System.out.println(annotationPresent);  //true
  12.         //判断类上是否有这个注解，如果有，就拿到
  13.         if (c.isAnnotationPresent(MyAnnotation.class)){
  14.             //这一切都是因为@Retention(RetentionPolicy.RUNTIME)
  15.             MyAnnotation myAnnotation = (MyAnnotation)c.getAnnotation(MyAnnotation.class);
  16.             System.out.println(myAnnotation); //@annotation.MyAnnotation(value=杭州西湖区)
  17.             //获取注解对象的属性怎么办？和调接口没区别
  18.             String value = myAnnotation.value();
  19.             System.out.println(value);  //杭州西湖区
  20.         }
  22.         //判断String这个类上是否有@MyAnnotation这个注解
  23.         Class c2 = Class.forName("java.lang.String");
  24.         System.out.println(c2.isAnnotationPresent(MyAnnotation.class));//false
  26.     }
  27. }

通过反射获取方法上的注解信息

  1. package annotation.annotation6;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. @Target(ElementType.METHOD)
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface MyAnnotation {
  11.     String username();
  12.     String password();
  13. }
  1. package annotation.annotation6;
  3. import java.lang.reflect.Method;
  5. public class MyAnnotationTest {
  7.     @MyAnnotation(username = "admin",password = "123")
  8.     public void doSome(){
  10.     }
  12.     //获取MyAnnotationTest的doSome方法上面的注解信息
  13.     public static void main(String[] args) throws Exception{
  14.         Class c = Class.forName("annotation.annotation6.MyAnnotationTest");
  15.         Method method = c.getDeclaredMethod("doSome");
  16.         //判断该方法上是否有这个注解
  17.         if (method.isAnnotationPresent(MyAnnotation.class)){
  18.             MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
  19.             System.out.println(annotation.username());  //admin
  20.             System.out.println(annotation.password());  //123
  21.         }
  22.     }
  23. }

注解灵魂拷问 : 有什么用?

现在提一个需求:
假设有这样一个注解:@Id,这个注解只能出现在类上面.当这个类上有这个注解的时候,要求这个类中必须有一个int类型的属性,如果没有这个属性就报异常,如果有就正常执行.
image.png

  1. package annotation.annotation7;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Target;
  6. @Target(ElementType.TYPE)
  7. public @interface Id {
  8. }
  1. package annotation.annotation7;
  3. @Id
  4. public class User {
  5. //    int id;
  6.     String name;
  7.     String password;
  8. }
  1. package annotation.annotation7;
  3. public class HasNotIdPropertyException extends RuntimeException {
  4.     public HasNotIdPropertyException(String message) {
  5.         super(message);
  6.     }
  8.     public HasNotIdPropertyException() {
  9.     }
  10. }
  1. package annotation.annotation7;
  3. import java.lang.reflect.Field;
  5. public class HasIdAnnotationTest {
  6.     public static void main(String[] args) throws Exception{
  7.         Class userClass = Class.forName("annotation.annotation7.User");
  8.         Field[] dfs = userClass.getDeclaredFields();
  9.         boolean isOk = false;
  10.         for (Field df : dfs) {
  11.             if ("id".equals(df.getName())&&"int".equals(df.getType().getSimpleName())){
  12.                 isOk = true;
  13.                 break;
  14.             }
  15.         }
  16.         while (!isOk){
  17.             throw new HasNotIdPropertyException("被@Id标注的注解必须含有一个int类型的属性！");
  18.         }
  19.     }
  20. }

这里运行是成功的,就是说，当我们故意注释掉User类的id属性时，就会报这个异常；放开注释时，回父正常，代码正确。达到预期效果。
image.png

事实证明这个例子没啥用，即不写该自定义注解并标注在User类上，测试也能有相同效果。
记住获取反射注解的方法是：

  1. Class c = Class.forName("annotation.annotation6.MyAnnotationTest");
  2. Method method = c.getDeclaredMethod("doSome");
  3. MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);