注解_自定义注解

---

努力努力再努力xLg

注解

​ 说明程序的，是用来给计算机看的。

简单说明一下注解

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

作用分类：

1. 编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
2. 代码分析：通过代码里标识的注解对代码进行分析【使用反射】
3. 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

* JDK中预定义的一些注解
    * @Override ：检测被该注解标注的方法是否是继承自父类(接口)的
    * @Deprecated：该注解标注的内容，表示已过时
    * @SuppressWarnings：压制警告
        * 一般传递参数all  @SuppressWarnings("all")

* 自定义注解
    * 格式：
        元注解
        public @interface 注解名称{
            属性列表;
        }

    * 本质：注解本质上就是一个接口，该接口默认继承Annotation接口
        * public interface MyAnno extends java.lang.annotation.Annotation {}

    * 属性：接口中的抽象方法
        * 要求：
            1. 属性的返回值类型有下列取值
                * 基本数据类型
                * String
                * 枚举
                * 注解
                * 以上类型的数组

            2. 定义了属性，在使用时需要给属性赋值
                1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
                2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
                3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
    
    * 元注解：用于描述注解的注解
        * @Target：描述注解能够作用的位置
            * ElementType取值：
                * TYPE：可以作用于类上
                * METHOD：可以作用于方法上
                * FIELD：可以作用于成员变量上
        * @Retention：描述注解被保留的阶段
            * @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
        * @Documented：描述注解是否被抽取到api文档中
        * @Inherited：描述注解是否被子类继承

使用反编译 来证明注解在机器中的样子

1. 创建一个注解类@MyAnnoTest

   1. 复制到同一路径，修改编码为GDK，删掉文件头的package。
   2. 然后使用javac编译
   3. 在使用javap反编译

   // 原文件
   pubulic @interface MyAnnoTest{}
   
   // 使用javap 命令 反编译class文件得到
   // compiled from "MyAnnoTest.java"
   public interface MyAnnoTest extends java.lang.annotation.Annotation {
   }
   
   ** 从这里可以看出，注解本身就是一个接口，该接口默认继承Annotation 接口
   

   案例

   使用自定义注解，实现类的测试

   * 测试计算机类中方法是否通过！
   

   Calculator

   package com.java.myannotation.demo;
   
   /**
    * 计算器类
    *
    * @author by Mr. Li
    * @date 2019/12/27 16:28
    */
   public class Calculator {
       // 加法
       @Check
       public void add() {
           System.out.println("1 + 0 = " + (1 + 0));
       }
   
       // 减法
       @Check
       public void sub() {
           System.out.println("1 - 0 = " + (1 - 0));
       }
   
       // 乘法
       @Check
       public void mul() {
           System.out.println("1 * 0 = " + (1 * 0));
       }
   
       // 除法
       @Check
       public void div() {
           System.out.println("1 / 0 = " + (1 / 0));
       }
   
       public void show() {
           System.out.println("没有bug。。。");
       }
   }
   
   

   @Check

   package com.java.myannotation.demo;
   
   import java.lang.annotation.*;
   
   /**
    * 自定义注解
    *
    * @author by Mr. Li
    * @date 2019/12/27 16:32
    */
   @Target({ElementType.TYPE, ElementType.METHOD})
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Check {
   }
   
   

   CheckLog测试类

   package com.java.myannotation.demo;
   
   import java.io.BufferedWriter;
   import java.io.FileWriter;
   import java.io.IOException;
   import java.lang.reflect.Method;
   
   /**
    * 测试
    * 1. 首先获取计算机对象，在获取字节码对象
    * 2. 获取当前类中有哪些方法添加了check注解
    * 3. 然后再将执行结果答写入log中
    *
    * @author by Mr. Li
    * @date 2019/12/27 16:42
    */
   public class CheckLog {
       public static Integer num = 0;
   
       public static void main(String[] args) throws IOException {
           Calculator calculator = new Calculator();
           // 获取字节码对象，方便获取 方法 和 注解个数
           Class clazz = calculator.getClass();
   
           // 获取 流对象
           BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("log.txt"));
   
           // 获取字节码对象中的所有方法
           Method[] methods = clazz.getMethods();
           for (Method method : methods) {
               // 判断该方法上是否添加了@check 注解
               if (method.isAnnotationPresent(Check.class)) {
                   // 执行 该方法
                   try {
                       method.invoke(calculator);
                   } catch (Exception e) {
                       //记录 错误的次数
                       num++;
                       // 如果出现异常，说明该方法中有错误，将错误日志答应到 log文件中
                       bufferedWriter.write(method.getName() + "方法出现异常了");
                       bufferedWriter.newLine();
                       bufferedWriter.write("异常名称:" + e.getCause().getClass().getSimpleName());
                       bufferedWriter.newLine();
                       bufferedWriter.write("异常原因:" + e.getCause().getMessage());
                       bufferedWriter.newLine();
                       bufferedWriter.write("------------------------");
                       bufferedWriter.newLine();
                   }
   
               }
           }
           bufferedWriter.write("本次测试一共异常了" + num + "次");
           bufferedWriter.flush();
           bufferedWriter.close();
       }
   }
   
   

   结果

结果.png

使用注解的方式 实现对类的实例化

使用注解方式，完成反射中使用的经典案例

ReflectAnno

package com.java.myannotation.demo;

import java.lang.annotation.*;

/**
 * 使用注解方式 完成反射中的经典案例
 * 实现对任意类的实例化
 *
 * @author by Mr. Li
 * @date 2019/12/27 17:09
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ReflectAnno {
    /**
     * 需要实例化的 类路径
     *
     * @return
     */
    String className();

    /**
     * 需要执行的方法
     *
     * @return
     */
    String classMethod();
}

测试类

package com.java.myannotation.demo;

/**
 * 测试类
 *
 * @author by Mr. Li
 * @date 2019/12/27 17:17
 */
@ReflectAnno(className = "com.java.myannotation.demo.Person", classMethod = "eat")
public class ReflectAnnoTest {
    public static void main(String[] args) throws Exception {
        // 获取 当前类中的注解属性
        Class clazz = ReflectAnnoTest.class;
        ReflectAnno annotation = clazz.getAnnotation(ReflectAnno.class);
        String className = annotation.className();
        String classMethod = annotation.classMethod();

        // 执行
        Class aClass = Class.forName(className);
        aClass.getMethod(classMethod).invoke(aClass.newInstance());
    }

}

使用自定义注解，实现SpringAop环绕通知实现日志管理

TODO