【重难点】注解

一、概念

1、概念--Annotation

是 JDK5.0 引入的一种注释机制。 Java 语言中的类、方法、变量、参数和包等都可以被标注，用于说明程序，给计算机看。

（注释：用文字描述 程序，给程序员看）

2、使用：

• @注解名称
• @Override重写
• @Test

3、作用

• 编译检查
• 生成doc文档【文档注释】
  • javadoc HelloWorld.java
  • /**
  • *@author ljh
  • */
• 代码分析

4、常见的内置注解（Java预定义的注解）

• @Override：检查是否是重写（父类/接口）的方法
• @Deprecated：标记过时方法，编译时会警告
• @SuppressWarnings/@SuppressWarnings("all")：忽略注解中声明的警告 

二、自定义注解

1、格式

  元注解
public @interface 注解名称(){
     属性列表
}

2、本质

反编译后

 

 

 本质上是一个接口，该接口默认继承Annotation 接口

Annotation 接口：所有注释类型扩展的公共接口，手动扩展这个接口不限定注释类型，此接口本身并不定义注释类型。

3、属性

接口中可以定义的抽象成员方法

要求

• 属性方法返回值
  • 基本数据类型
  • String
  • 枚举
  • 注解
  • 上述类型的数组
  • 不包括void空类型
• 使用时需要给属性赋值
  • 数组赋值时需要使用{}包裹，一个元素可以省略
  • 只有一个属性需要赋值且属性名为value时，可只写值省略value
  • @SuppressWarnings("all")的属性是一个字符数组String[] value;

package com.liujinhui.Day1209BaseEnhance.annotation;
public @interface MyAnno {
    int age();
   String name() default "张三";
    Person per();
    MyAnno2 anno2();
    String[] show3();
}

  @MyAnno(age = 1,name="张三")//所以称为属性
    public void demo(){
        show1();
        Date date=new Date();
    }

4、元注解：描述注解的注解

1 @Target(ElementType.METHOD)//作用位置：方法
@Retention(RetentionPolicy.SOURCE)//能被保留到什么阶段：Source源码阶段
public @interface ZJName {
}

• @Documented：描述 注解是否被抽取到API文档中 
• @Inherited：描述注解是否被子类继承，加注解后，子类会自动继承父类的注解
• @Target：描述注解能够作用的位置
  • @Target(value = {ElementType.TYPE})//表示该Anno3注解可以作用于类上

  • @Target(value = {ElementType.METHOD})//表示该Anno3注解可以作用于方法上

  • @Target(value = {ElementType.FIELD})//表示该Anno3注解可以作用于成员变量上

  • @Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})

• @Retention：描述注解被保留的阶段（Source/Class/Runtime）
  • @Retention(RetentionPolicy.RUNTIME)当前被描述的注解，会保留到class字节码文件中，并被JVM读取到

　　

 

使用：自定义@MyAnno3注解

import java.lang.annotation.*;
@Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
//可以抽取到文档中
@Inherited
public @interface MyAnno3 {
}

5、解析注解：获取注解中的属性值

步骤：

• 获取注解定义的位置的对象（Class,Method,Field）

• 获取指定注解 getAnnotation(Class)

//其实就是在内存中生成了一个该注解接口的子类实现对象
public class ProIMpl implements Pro{
      public String className(){
          return"com.liujinhui.Day1209BaseEnhance.annotation.Demo1";
      }
      public String methodName(){
           return "show";
      }
}

• 调用注解中的抽象方法获取配置的属性值

 三、案例

1、自定义注解执行任意类的任意方法

package com.liujinhui.Day1209BaseEnhance.annotation;

public class Demo1 {
    public void show(){
        System.out.println("demo1 show");
    }
}

package com.liujinhui.Day1209BaseEnhance.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/*
    描述需要执行的类名和方法名
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {
    String className();
    String methodName();
}
/*
    public class ProIMpl implements Pro{
           public String className(){
                return  "com.liujinhui.Day1209BaseEnhance.annotation.Demo1";
           }
           public String methodName(){
                return "show";
           }

 */

package com.liujinhui.Day1209BaseEnhance.annotation;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/*
    假设的框架类
    改配置文件使程序的扩展性更强，配置文件中使用了全类名，则使用了反射机制
* */
@Pro(className = "com.liujinhui.Day1209BaseEnhance.annotation.Demo1",methodName = "show")
//要写全类名
public class ReflectTest {
    /**
     * @author: Liu Jinhui
     * @description: 创建任意对象
     * @date: 2020/12/9 20:42
     * @return  * @param null
     */
    public static void main(String[] args) throws Exception{
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意方法
        * */
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上面的注解对象
        //method也有getAnno
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        /*
            public class ProIMpl implements Pro{
                   public String className(){
                        return  "com.liujinhui.Day1209BaseEnhance.annotation.Demo1";
                   }
                   public String methodName(){
                        return "show";
                   }
         */
        //3.调用注解对象中调用的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className+methodName);
        //4.加载该类进内存
        Class cls = Class.forName(className);
        //5.创建对象
        Object obj = cls.newInstance();
        //6.获取方法对象
        Method method = cls.getMethod(methodName);
        //7.执行方法
        method.invoke(obj);
    }
}

2、通过注解实现简单的测试框架

要求：

当主方法执行后，会自动执行被检测的所有方法（加了@Check的方法）

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(value = {ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Check {
}

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

/**
 * 小明定义的计算器类
 * 需要测试是否有错误
 */
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...");
    }
}

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 简单的测试框架
 * 当主方法执行后，会自动执行被检测的所有方法（加了@Check的方法）
 * 判断方法是否有异常，并记录到文件中
 */
public class TestCheck {
    public static void main(String[] args) throws IOException {
        //1.创建计算器对象
        Calculator c = new Calculator();
        //2.获取字节码文件对象
        Class cls = c.getClass();
        //3.获取所有的方法
        Method[] methods = cls.getMethods();
        int number=0;//记录异常出现的次数
        BufferedWriter bw=new BufferedWriter(new FileWriter("bug.txt"));
        for (Method method : methods) {
            //4.判断方法上是否有check注解
            if (method.isAnnotationPresent(Check.class)) {
                //判断当前方法上有无指定注解
                //5.有就执行该方法
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常
                    number++;
                    //记录到文件中
                    bw.write(method.getName() + "方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称：" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因：" + e.getCause().getMessage());
                    bw.newLine();
                    bw.write("-----------------------");
                }
            }
        }
        bw.write("本次测试共出现"+ number +"次异常");
        bw.flush();
        bw.close();
    }
}

3、总结

• 常用jdk内置注解而不是自定义注解
• 注解给编译器解析程序用
• 注解不是程序的一部分，而是相当于程序的标签