java 编程基础：注解 提取注解信息，利用自定义注解编写测试类，注解绑定事件

Posted 2021-05-18 zhangmingda

提取注解信息

使用注解修饰了类、方法、成员变量等成员之后，这些注解不会自己生效，必须由开发者提供相应工具来提取并处理注解信息。

 

Java使用java.lang.annotation.Annotation接口代表程序元素前面的注解，该接口是所有注解的父接口。Java5在java.lang.reflect包下新增了AnnotatedElement接口，该接口代表程序中可以接受注解程序元素(就是哪些类可以被注解修饰)。该接口主要有如下几个实现类。

• Class: 类定义
• Constructor: 构造器定义
• Field: 类的成员变量定义
• Method: 类的方法定义
• Packag: 的包定义

 

对于AnnotatedElement的实现类，Java提供了如下几个方法来获取修饰其的注解的信息：

• A getAnnotation(Class annotationClass): 返回该程序元素上存在的、指定类型的注解，如果该类型的注解不存在，则返回null。
• A getDeclaredAnnotation(Class ann tationClass): 这是Java8新增的方法，该方法尝试获取直接修饰该程序元素，指定类型的注解（不会获取到从父类集成来的注解）。如果该类型的注解不存在，则返回null
• Annotation[] getAnnotations(): 返回该程序元素上存在的所有注解
• Annotation[] getDeclaredAnnotations(): 返回直接修饰该程序元素的所有注解（不会获取到从父类集成来的注解）
• boolean isAnnotationPresent(Class annotationClass): 判断该程序元素是否存在指定类型的注解，如果存在则返回true 否则返回 false
• A[] getAnnotationsByType(Class annotationClass): 该方法的功能与面介绍的getAnnotation()方法基本相似，由于Java8增加了重复注解功能，因此需要使用该方法获取修饰该程序元素、指定类型的注解
• A[] getDeclaredAnnotationsByType(Class annotationClass): 该方法功能与前面介绍 getDeclaredAnnotations()方法基本相似 但由于Java8新增了重复注解功能，需要使用该方法获取直接修饰该程序元素、指定类型的多个注解（不会获取到从父类集成来的注解）

 

先定义一个注解，可以在运行的时候获取到：

package com.zmd.myAnnotation;
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME) //配置生命周期运行时可以获取到
@Inherited //配置注解的继承性，用了注解的父类，子类默认被修饰
public @interface MyAnnotation {
    String name() default "zmd";
    int age() default 22;
}

定义一个父类使用注解

package com.zmd.myAnnotation;

import java.lang.annotation.Annotation;

@MyAnnotation(name = "hehe",age = 1)
public class MyClass {
    public static void main(String[] args) {
        //判断是否有MyAnnotation注解修饰
        System.out.println(MyClass.class.isAnnotationPresent(MyAnnotation.class)); //true
        //获取包括继承父类的注解。
        Annotation annotation = MyClass.class.getAnnotation(MyAnnotation.class);
        if (annotation instanceof MyAnnotation){
            MyAnnotation myAnnotation = (MyAnnotation) annotation;
            System.out.println("tag is:" + annotation);  //tag is:@com.zmd.myAnnotation.MyAnnotation(name="hehe", age=1)
            System.out.println("name is:" + myAnnotation.name()); //name is:hehe
            System.out.println("age is:" + myAnnotation.age()); //age is:1
        }
    }
}

定义子类继承父类获取注解信息

package com.zmd.myAnnotation;
import java.lang.annotation.Annotation;

public class MySubClass extends MyClass {
    public static void main(String[] args) {
        //是不是有MyAnnotation注解修饰
        System.out.println(MySubClass.class.isAnnotationPresent(MyAnnotation.class)); //true
        //获取指定类型的Annotation
//        Annotation annotation = SubClass.class.getAnnotation(MyAnnotation.class);//用这行代码，可以获取到MyAnnotation，因为MyAnnotation是获取所有包括继承性的
        Annotation annotation = MySubClass.class.getDeclaredAnnotation(MyAnnotation.class);//用这行代码无法获取到MyAnnotation,因为我们getDeclaredAnnotation方法只能获取到直接修饰该类的注解，不能获取到从父类继承过来的注解
        System.out.println(annotation); //null
        if (annotation instanceof MyAnnotation) { //false 啥也没输出
            System.out.println("tag is " + annotation);
            System.out.println("name is " + ((MyAnnotation) annotation).name());
            System.out.println("age is " + ((MyAnnotation) annotation).age());
        }
    }
}

编写测试工具

利用自定义注解标识可测试的方法，编写测试工具类，用于测试那些只标识了可以测试的方法

1、编写自定义注解

package com.zmd.autotestTools;

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

@Retention(RetentionPolicy.RUNTIME) //运行时可获取
@Target(ElementType.METHOD) //只能修饰方法
public @interface Testable {
}

2、编写使用注解的类

package com.zmd.autotestTools;

public class MyClass {
    @Testable
    public static void m1() {};

    public static void m2() {};

    @Testable
    public static void m3() {throw new RuntimeException();};

    public static void m4() {};

    @Testable
    public static void m5() {throw new IllegalArgumentException();};

    public static void m6() {};

    @Testable
    public static void m7() {};

    public static void m8() {};
}

3、编写工具类测试 使用注解的类中的方法

package com.zmd.autotestTools;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**
 * @ClassName TestMethod
 * @projectName: object1
 * @author: Zhangmingda
 * @description： XXX
 * date: 2021/5/18.
 */
public class TestMethod {
    public static void test(Class<?> cls) throws IllegalAccessException, InstantiationException {
        //获取所有的方法
        Method[] methods = cls.getMethods();
        //创建一个实例
        MyClass myClass = (MyClass) cls.newInstance();
        for (Method method : methods){
            //如果方法被修饰，意思是可以测试
            if (method.isAnnotationPresent(Testable.class)){
                //那就测试
                try {
                    //如果是静态方法
                    if (Modifier.isStatic(method.getModifiers())){
                        method.invoke(null);
                    }else {
                        method.invoke(MyClass.class);
                    }
                    System.out.println(method.getName() + "测试成功");
                }catch (InvocationTargetException e) {
//                    e.printStackTrace();
                    System.err.println(method.getName() + "测试失败");
                }

            }
        }
    }

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        test(MyClass.class);
    }
}