Java 注解和反射详解

女爷i 2023-03-04 06:46 13阅读 0赞

### 文章目录 ###

*  注解
 *   *  什么是注解？
     *  内置注解
     *  元注解
     *   *  @Target
         *  @Retention
         *  @Documented
         *  @Inherited
     *  自定义注解
 *  反射
 *   *  静态语言 VS 动态语言
     *   *  动态语言
         *  静态语言
     *  Java 反射机制概述
     *  Java 反射机制提供的功能
     *  Java 反射优点和缺点
     *  反射相关的主要 API
     *  理解 Class 类并获取 Class 实例
     *   *  Class 类
         *   *   *  Class 类的常用方法
         *  获取 Class 类的实例
     *  所有类型的 Class 对象
     *  Java 内存分析
     *  类的加载与 ClassLoader 的理解
     *  获取运行时类的完整结构 & 动态创建对象执行方法
     *  性能对比分析
     *   *  setAccessible
     *  通过反射去操作泛型
     *  反射操作注解
     *  扩展
     *   *  自定义注解的场景及实现

# 注解 #

## 什么是注解？ ##

*  Annotation 是从 JDK 1.5 开始引入的新技术
 *  Annotation 的作用
    
     *  不是程序本身，可以对程序作出解释（这一点和注释没什么区别）
     *  可以被其它程序（比如：编译器等）读取
 *  Annotation 的格式
    
     *  注解是以 “@注释名” 在代码中存在的，还可以添加一些参数值，例如： @SuppressWarnings(value=“unchecked”)
 *  Annotation 在哪里使用？
    
     *  可以附加在 package，class，method，field 等上面，相当于给他们添加了额外的辅助信息，我们可以通过反射机制编程实现对这些元数据的访问

如：（重写父类方法的时候会有个 @Override 注解）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70]

## 内置注解 ##

*  @Override：定义在 java.lang.Override 中，此注解只适用于修辞方法，表示一个方法声明打算重写超类中的另一个方法声明

@Target(value=METHOD)
    @Retention(value=SOURCE)
    public @interface Override

*  @Deprecated：定义在 java.lang.Deprecated 中，此注释可以用于修辞方法，属性，类，表示不鼓励程序员使用这样的元素，通常是因为它很危险或者存在更好的选择

@Documented
    @Retention(value=RUNTIME)
    @Target(value={ CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,PARAMETER,TYPE})
    public @interface Deprecated

*  @SuppressWarnings：定义在 java.lang.SuppressWarings 中，用来抑制编译时的警告信息，与前两个注释有所不同，你需要添加一个参数才能正确使用，这些参数都是已经定义好了的，我们选择性的使用就好了
    
     *  @SuppressWarnings(“all”)
     *  @SuppressWarnings(“unchecked”)
     *  @SuppressWarnings(value=\{“unchecked”,“deprecation”\})
     *  等等…

@Target(value={ TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
    @Retention(value=SOURCE)
    public @interface SuppressWarnings

## 元注解 ##

*  元注解的作用就是负责注解其它注解，Java 定义了 4 个标准的 meta-annotation 类型，它们被用来提供对其它注解类型做说明
 *  这些类型和它们所支持的类在 java.lang.annotation 包中可以找到（@Target，@Retention，@Documented，@Inherited）

### @Target ###

用于描述注解的使用范围（即：被描述的注解可以用在什么地方）

如：我们自定义一个注解  
![在这里插入图片描述][20200801203820184.png]  
ElementType 是一个枚举类，该类中提供了一些简单的分类（以下是该类的部分截图）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 1]  
然后我们使用该注解

public class Test01 { 
        @MyAnnotation
        public void test() { 
    
        }
    }

在 @MyAnnotation 中还定义了可以在类中使用，所以也可以在类上面使用该注解，如：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 2]

### @Retention ###

表示需要在什么级别保存该注释信息，用于描述注解的生命周期（SOURCE < CLASS < **RUNTIME**）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 3]

### @Documented ###

说明该注解将被包含在 javadoc 中  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 4]

### @Inherited ###

说明子类可以继承父类中的该注解

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 5]

## 自定义注解 ##

*  使用 @interface 自定义注解时，自动继承了 java.lang.annotation.Annotation 接口
 *  分析：
    
     *  @interface 用来声明一个注解，格式：public @interface 注解名 \{定义内容\}
     *  其中的每一个方法实际上是声明了一个配置参数
     *  方法的名称就是参数的名称
     *  返回值类型就是参数的类型（返回值只能是基本类型，Class，String，enum）
     *  可以通过 default 来声明参数的默认值
     *  如果只有一个参数成员，一般参数名为 value
     *  注解元素必须要有值，我们定义注解元素时，经常使用空字符串，0 作为默认值

import java.lang.annotation.*;
    
    /** * @author Woo_home * @create by 2020/8/1 20:12 */
    public class Test01 { 
    
        // 注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
        @MyAnnotation(age = 18, name = "lisa")
        public void test() { 
    
        }
        
        @DemoAnnotation("注解测试")
        public void test1() { 
    
        }
    }
    
    @Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface MyAnnotation { 
        // 注解的参数：参数类型 + 参数名()
        String name() default "";
    
        int age();
    
        // 如果默认值为 -1，代表不存在
        int id() default -1;
    
        String[] schools() default { "大学"};
    }
    
    @Target({ ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @interface DemoAnnotation { 
        String value();
    }

# 反射 #

## 静态语言 VS 动态语言 ##

### 动态语言 ###

动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其它结构上的变化。通俗一点说就是在运行时代码可以根据某些条件改变自身结构

### 静态语言 ###

与动态语言相对应，运行时结构不可变的语言就是静态语言，如 Java、C、C++

Java 不是静态语言，但是 Java 可以称之为 “准动态语言”。即 Java 有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。Java 的动态性让编程的时候更加灵活

## Java 反射机制概述 ##

Reflection（反射）是 Java 被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取得任何类的内部信息，并能直接操作任意对象的内部属性以及方法

Class c = Class.forName("java.lang.String");

加载完类之后，在堆内存的方法区中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象就包含了完整类的类的结构信息。我们可以通过对这个对象看到的类的结构。这个对象就像一面镜子，通过这个镜子看到类的结构，所以，我们形象地称之为：反射

*  **正常方式：引入需要的 “ 包类 ” 名称 ——> 通过 new 实例化 ——> 取得实例化对象**
 *  **反射方式：实例化对象 ——> getClass() 方法 ——> 得到完整的 “包类” 名称**

## Java 反射机制提供的功能 ##

*  在运行时判断任意一个对象所属的类
 *  在运行时构造任意一个类的对象
 *  在运行时判断任意一个类所具有的成员变量和方法
 *  在运行时获取泛型信息
 *  在运行时调用任意一个对象的成员变量和方法
 *  在运行时处理注解
 *  生成动态代理

## Java 反射优点和缺点 ##

**优点：** 可以实现动态创建对象和编译，体现出很大的灵活性

**缺点：** 对性能有影响。使用反射基本上是一种解释操作，我们可以告诉 JVM，我们希望做什么并且它满足我们什么要求，这类操作总是慢于直接执行相同的操作

## 反射相关的主要 API ##

*  java.lang.Class 代表一个类
 *  java.lang.reflect.Method 代表类的方法
 *  java.lang.reflect.Field 代表类的成员变量
 *  java.lang.reflect.Constructor 代表类的构造器

## 理解 Class 类并获取 Class 实例 ##

先定义一个实体类

// 定义一个实体类
    public class User { 
    
        private int id;
    
        private String name;
    
        private int age;
    
        public User() { 
        }
    
        public User(int id, String name, int age) { 
            this.id = id;
            this.name = name;
            this.age = age;
        }
    
        public int getId() { 
            return id;
        }
    
        public void setId(int id) { 
            this.id = id;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

主程序

package com.java.demo.reflect;
    
    /** * @author Woo_home * @create by 2020/8/1 20:12 */
    public class Test01 { 
        public static void main(String[] args) throws Exception { 
            // 通过反射获取类的 Class 对象
            Class<?> aClass = Class.forName("com.java.demo.reflect.User");
            System.out.println(aClass);
        }
    }

输出：  
![在这里插入图片描述][20200801214531787.png]  
**一个类在内存中只有一个 Class 对象，一个类被加载之后，类的整个结构都会被封装在 Class 对象中**

### Class 类 ###

在 Object 类中定义了以下方法，此方法将被所有子类继承

public final native Class<?> getClass();

上面的方法返回值的类型是一个 Class 类，此类是 Java 反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称

对于每个类而言，JRE 都为其保留了一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构（class / interface / enum / annotation / primitive type/void / \[\]）

*  Class 本身也是一个类
 *  Class 对象只能由系统建立对象
 *  一个加载的类在 JVM 中只会有一个 Class 实例
 *  一个 Class 对象对应的是一个加载到 JVM 中的一个 .class 文件
 *  每个类的实例都会记得自己是由哪个 Class 实例所生成
 *  通过 Class 可以完整地得到一个类中的所有被加载的结构
 *  Class 类是 Reflection 的根源，针对任何你想动态加载、运行的类、唯有先获得响应的 Class 对象

##### Class 类的常用方法 #####

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>功能说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>static Class forName(String name)</td> 
   <td>返回指定类名 name 的 Class 对象</td> 
  </tr> 
  <tr> 
   <td>Object newInstance()</td> 
   <td>调用缺省构造函数，返回 Class 对象的一个实例</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>返回此 Class 对象所表示的实体（类、接口、数组类、或 void）的名称</td> 
  </tr> 
  <tr> 
   <td>Class getSuperClass()</td> 
   <td>返回当前 Class 对象的父类的 Class 对象</td> 
  </tr> 
  <tr> 
   <td>Class[] getInterfaces()</td> 
   <td>获取当前 Class 对象的接口</td> 
  </tr> 
  <tr> 
   <td>ClassLoader getClassLoader()</td> 
   <td>返回该类的类加载器</td> 
  </tr> 
  <tr> 
   <td>Constructor[] getConstructors()</td> 
   <td>返回一个包含某些 Constructor 对象的数组</td> 
  </tr> 
  <tr> 
   <td>Method getMethod(String name, Class… T)</td> 
   <td>返回一个 Method 对象，此对象的形参类型为 paramType</td> 
  </tr> 
  <tr> 
   <td>Field[] getDeclaredFields()</td> 
   <td>返回 Field 对象的一个数组</td> 
  </tr> 
 </tbody> 
</table>

### 获取 Class 类的实例 ###

public class Test01 { 
        public static void main(String[] args) throws Exception { 
            // 方式一：forName 获得
            Class aClass = Class.forName("com.java.demo.reflect.User");
            System.out.println(aClass);
    
            // 方式二：通过对象获得
            Class aClass1 = new User().getClass();
            System.out.println(aClass1);
    
            // 方式三：通过类名.class 获得
            Class<User> aClass2 = User.class;
            System.out.println(aClass2);
        }
    }

## 所有类型的 Class 对象 ##

public class Test01 { 
        public static void main(String[] args) { 
            Class objectClass = Object.class;            // 类
            Class comparableClass = Comparable.class;    // 接口
            Class aClass = String[].class;               // 一维数组
            Class aClass1 = int[][].class;               // 二维数组
            Class overrideClass = Override.class;        // 注解
            Class elementTypeClass = ElementType.class;  // 枚举
            Class integerClass = Integer.class;          // 基本数据类型
            Class voidClass = void.class;                // void
            Class classClass = Class.class;              // Class
    
            System.out.println(objectClass);
            System.out.println(comparableClass);
            System.out.println(aClass);
            System.out.println(aClass1);
            System.out.println(overrideClass);
            System.out.println(elementTypeClass);
            System.out.println(integerClass);
            System.out.println(voidClass);
            System.out.println(classClass);
        }
    }

输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 6]

## Java 内存分析 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 7]

## 类的加载与 ClassLoader 的理解 ##

*  加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class 对象
 *  链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程
    
     *  验证：确保加载的类信息符合 JVM 规范，没有安全方面的问题
     *  准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
     *  解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程
 *  初始化：
    
     *  执行类构造器< clint>() 方法的过程，类构造器< clint>() 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的（类构造器是构造类信息的，不是构造该类对象的构造器）
     *  当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
     *  虚拟机会保证一个类的< clint>() 方法在多线程环境中被正确加锁和同步

package com.java.demo.reflect;
    
    /** * @author Woo_home * @create by 2020/8/1 20:12 */
    public class Test01 { 
        public static void main(String[] args) { 
            /** * 1、加载到内存，会产生一个类对应的 Class 对象 * 2、链接，链接结束后 m = 0 * 3、初始化 <clint>() { System.out.println("A 类静态代码块初始化"); m = 300; m = 100; } m = 100; */
            A a = new A();
            System.out.println(A.m);
        }
    }
    
    class A { 
        static { 
            System.out.println("A 类静态代码块初始化");
            m = 300;
        }
    
        static int m = 100;
    
        public A() { 
            System.out.println("A 类的无参构造函数初始化");
        }
    }

输出：  
![在这里插入图片描述][20200801225508586.png]

## 获取运行时类的完整结构 & 动态创建对象执行方法 ##

Field、Method、Constructor、SuperClass、Interface、Annotation

*  实现的全部接口
 *  所继承的父类
 *  全部的构造器
 *  全部的方法
 *  全部的 Field
 *  注解
 *  …

具体可以看下之前写的这篇文章，写得很详细 [Java反射机制的简单使用][Java]

## 性能对比分析 ##

### setAccessible ###

*  Method 和 Field、Constructor 对象都有 setAccessible() 方法
 *  setAccessible 作用是启动和禁用访问安全检查的开关
 *  参数值为 true 则提示反射的对象在使用时应该取消 Java 语言访问检查
    
     *  提高反射的效率，如果代码中必须用反射，而该语句需要频繁的被调用，那么请设置为 true
     *  使得原本无法访问的私有成员也可以访问
 *  参数值为 false 则指示反射的对象应该实施 Java 语言访问检查

package com.java.demo.reflect;
    
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    /** * @author Woo_home * @create by 2020/8/1 20:12 */
    public class Test01 { 
    
        // 普通方式调用
        public static void test01() { 
            User user = new User();
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 100000000; i++) { 
                user.getName();
            }
            long endTime = System.currentTimeMillis();
            System.out.println("普通方式执行 1 亿次：" + (endTime - startTime) + "ms");
        }
    
        // 反射方式调用
        public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { 
            User user = new User();
            Class c = user.getClass();
            Method getName = c.getDeclaredMethod("getName", null);
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 100000000; i++) { 
                getName.invoke(user, null);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("反射方式执行 1 亿次：" + (endTime - startTime) + "ms");
        }
    
        // 反射方式调用，关闭检测
        public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { 
            User user = new User();
            Class c = user.getClass();
            Method getName = c.getDeclaredMethod("getName", null);
            getName.setAccessible(true);
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 100000000; i++) { 
                getName.invoke(user, null);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("关闭检测方式执行 1 亿次：" + (endTime - startTime) + "ms");
        }
    
        public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { 
            test01();
            test02();
            test03();
        }
    }

输出：  
![在这里插入图片描述][20200802220324649.png]

通过输出结果可以发现，普通方式执行是最快的，其次就是关闭检测的方式

## 通过反射去操作泛型 ##

*  Java 采用泛型擦除的机制来引入泛型，Java 中的泛型仅仅是给编译器 javac 使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除
 *  为了通过反射操作这些类型，Java 新增了 ParameterizedType，GenericArrayType，TypeVariable 和 WildcardType 几种类型来代表不能被归一到 Class 类中的类型但是又和原始类型齐名的类型
    
     *  ParameterizedType：表示一种参数化类型，比如 Collection< String>
     *  GenericArrayType：表示一种元素类型时参数化类型或者类型变量的数组类型
     *  TypeVariable ：是各种类型变量的公共父接口
     *  WildcardType ：代表一种通配符类型表达式

package com.java.demo.reflect;
    
    import java.lang.reflect.Method;
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.List;
    import java.util.Map;
    
    /** * @author Woo_home * @create by 2020/8/1 20:12 */
    public class Test01 { 
    
        public void test01(Map<String, User> map, List<User> list) { 
            System.out.println("test01");
        }
    
        public Map<String, User> test02() { 
            System.out.println("test02");
            return null;
        }
    
        // 通过反射获取泛型
        public static void main(String[] args) throws NoSuchMethodException { 
            Method test01 = Test01.class.getMethod("test01", Map.class, List.class);
            // 获取通用参数类型
            Type[] genericParameterTypes = test01.getGenericParameterTypes();
            // 迭代遍历
            for (Type genericParameterType : genericParameterTypes) { 
                System.out.println("# " + genericParameterType);
                if (genericParameterType instanceof ParameterizedType) { 
                    // 获取实际参数类型
                    Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                    for (Type actualTypeArgument : actualTypeArguments) { 
                        System.out.println(actualTypeArgument);
                    }
                }
            }
    
            Method test02 = Test01.class.getMethod("test02", null);
            Type genericReturnType = test02.getGenericReturnType();
            if (genericReturnType instanceof ParameterizedType) { 
                Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) { 
                    System.out.println(actualTypeArgument);
                }
            }
        }
    }

输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 8]

## 反射操作注解 ##

*  getAnnotations
 *  getAnnotation

先定义两个注解，待会儿会用到

// 类名注解
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface Tables { 
        String value();
    }
    
    // 属性的注解
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @interface Fields { 
        String columnName();
        String type();
        int length();
    }

然后我们在实体类中使用我们定义的注解（是不是跟 JPA 有点像？）

@Tables("db_student")
    public class Student { 
    
        @Fields(columnName = "db_id", type = "int", length = 10)
        private int id;
    
        @Fields(columnName = "db_age", type = "int", length = 10)
        private int age;
    
        @Fields(columnName = "db_name", type = "varchar", length = 3)
        private String name;
    
        public Student() { 
        }
    
        public Student(int id, int age, String name) { 
            this.id = id;
            this.age = age;
            this.name = name;
        }
    
        public int getId() { 
            return id;
        }
    
        public void setId(int id) { 
            this.id = id;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        @Override
        public String toString() { 
            return "Student{" +
                    "id=" + id +
                    ", age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

然后反射来获取注解信息

public class Test01 { 
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException { 
            Class c1 = Class.forName("com.java.demo.reflect.Student");
    
            // 通过反射获得注解
            Annotation[] annotations = c1.getAnnotations();
            for (Annotation annotation : annotations) { 
                System.out.println(annotation);
            }
    
            // 获得注解的 value 值
            Tables tables = (Tables) c1.getAnnotation(Tables.class);
            String value = tables.value();
            System.out.println(value);
    
            // 获得类指定的注解
            Field field = c1.getDeclaredField("name");
            Fields annotation = field.getAnnotation(Fields.class);
            System.out.println(annotation.columnName());
            System.out.println(annotation.type());
            System.out.println(annotation.length());
        }
    }

输出：  
![在这里插入图片描述][20200802224114239.png]

## 扩展 ##

### 自定义注解的场景及实现 ###

登陆、权限拦截、日志处理，以及各种 Java 框架，如 Spring，Hibernate，Junit 提到注解就不能不说到反射，Java 自定义注解是通过运行时靠反射获取注解。

实际开发中，例如我们要获取某个方法的调用日志，可以通过 AOP（动态代理机制）给方法添加切面，通过反射来获取方法包含的注解，如果包含日志注解，就进行日志记|录

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70]: /images/20230208/7ba9fe2e7cca49f799897db1fa7aa7fe.png
[20200801203820184.png]: /images/20230208/bb5c7d7c2f644ba4922982cee3f21374.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 1]: /images/20230208/3133cc42cd724e88a0577f24fab81c66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 2]: /images/20230208/76189e8c54ea4f75a15e456b49123803.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 3]: /images/20230208/ace0a11279d846e58372ffcf68fb26b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 4]: /images/20230208/939609e5a0ce45dfaf6b105b46967b2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 5]: /images/20230208/5ec96a6c8c5e477785c4af5a2320e939.png
[20200801214531787.png]: /images/20230208/c49edbcbfc104584bad3b723356b88fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 6]: /images/20230208/7e858282541e4c208e9206d650082409.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 7]: /images/20230208/ac307385bcab41b9ba0013c8462a6b1a.png
[20200801225508586.png]: /images/20230208/ca054573ac9f496c9f26380e82a8f815.png
[Java]: https://blog.csdn.net/Woo_home/article/details/103503382
[20200802220324649.png]: /images/20230208/1a05ddc2a3e74e2689d1f8f9a10ea77c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1dvb19ob21l_size_16_color_FFFFFF_t_70 8]: /images/20230208/dc9325cfc17c4e0abd01028bf3010ba0.png
[20200802224114239.png]: /images/20230208/1604f3cca0be46d4b92340d00b9ddd98.png