Java之注解

注解

注解本质上就是一个接口，继承了java.lang.annotation.Annotation类。
如下的代码自定义一个注解，并指定了此注解作用于类上，并且这个注解会被保留到class字节码文件中。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {

    String className();
    String methodName();

}

对上面的代码反编译，输出如下的信息：

public interface com.sks.annotation.Pro extends java.lang.annotation.Annotation {
  public abstract java.lang.String className();
  public abstract java.lang.String methodName();
}

注解中的方法称为属性，实际上和接口中的抽象方法的意思是一样的。属性的返回值类型有下列取值：

• 基本数据类型
• String
• 枚举
• 注解
• 以上类型的数组
  如果我们在注解中定义了属性，那么在使用注解时需要对属性赋值；
  1.如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值;
  2.如果只有一个属性需要赋值，切属性的名称是value，则value可以省略；
  3.数组赋值时，值使用{}包裹，如果数组中只有一个值，{}可以省略；

以上面的自定义的Pro注解为例，我们需要指定它的className属性和method属性的值。

@Pro(className = "com.sks.annotation.Demo1",methodName = "show")

元注解：用来描述注解的注解；

1. @Target：描述注解能够作用的位置；使用枚举类型的ElementType来指定，TYPE：可以作用于类上；Field：作用于成员变量上；Method：作用于方法上；

2. @Retention：描述注解被保留的阶段；
   @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被jvm读取到

3. @Documented：注解是否被抽取到doc文档中；

4. @Inherited：描述注解是否被子类继承；

注解的应用

如果用过框架的话应该都知道，注解很重要的应用就是去减少传统的配置文件；例如：我们在spring中，配置一个bean可以通过注解的方式也可以通过配置文件的方式。

例1

自定义注解

/**
 * 描述需要执行的类名和方法名
 * @author dell
 * @date 2021/5/21 13:59
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {

    String className();
    String methodName();

}

public class Demo1 {

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

}

@Pro(className = "com.sks.annotation.Demo2",methodName = "show2")
public class ReflectTest {

    public static void main(String[] args) {
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上边的注解对象
        Pro pro = reflectTestClass.getAnnotation(Pro.class);
		 //其实就是在内存中生成了一个该注解接口的子类实现对象
        /*
        public class ProImpl implements Pro {
            public String className() {
                return "com.sks.annotation.Demo1";
            }

            public String methodName() {
                return "show";
            }
        }
        */
        //3.调用注解对象中定义的抽象方法，获取返回值
        String className = pro.className();
        String methodNmae = pro.methodName();
        System.out.println(className);
        System.out.println(methodNmae);
    }

}

例2

这里自定义了一个Check注解。

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

需要被测试的类。

public class Calculator {

    /**
     * 加法
     */
    @Check
    public void add() {
        int a =  5 / 0;
        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注解的方法进行测试，如果方法有异常，会自动生成bug.txt文件记录下来。

public class TestCheck {

    public static void main(String[] args) throws IOException {
        //1.
        Calculator calculator = new Calculator();

        //获取字节码文件对象
        Class cls = calculator.getClass();
        //获取所有方法
        Method[] methods = cls.getMethods();

        int num = 0;
        Writer out;
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));

        //判断方法上是否有check注解
        for(Method method : methods) {
            if (method.isAnnotationPresent(Check.class)) {
                //有，执行
                try {
                    method.invoke(calculator);
                } catch (Exception e) {
                   //

                    num++;
                    bw.write(method.getName() + "出现异常");
                    bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因:" + e.getCause().getMessage());
                    bw.newLine();
                    bw.write("----------------------");
                    bw.newLine();
                }
            }
        }

        bw.write("本次测试一共出现" + num + "次异常");

        bw.flush();
        bw.close();
        
    }
}

总结

一般情况下，我们不认为注解是程序的一部分。因为即使一个方法没有注解，方法也还是方法。
注解一般是给编译器和解析程序使用的，我们上面写的那个TestCheck就是一个解析程序。

参考

• 注解学习视频