[开发测试]Java【Junit/Reflect/Annotation】

Java【Junit/Reflect/Annotation】

一、Junit单元测试

1.1 测试分类

• 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。
• 白盒测试：需要写代码。关注程序具体的执行流程。

Junit属于白盒测试。

1.2 Junit使用

使用步骤

• 定义一个测试类（测试用例）

  建议测试类的类名写为被测试的类名+Test，例如CalculatorTest，测试的包名应写为xxx.xxx.xx.test，例如com.s0cket.test。

• 定义测试方法，可以独立运行

  建议方法名写为test+测试的方法名 :testAdd()，返回值void，参数列表：空参

• 测试方法上加上注解@Test

• 导入Junit依赖环境

结果判定

**红色：失败，绿色：成功。**一般我们会使用断言操作来处理结果:Assert.assertEquals(3,result);

补充

@Before：修饰的方法会在测试方法之前被自动执行，

@After：修饰的方法会在测试方法执行之后自动被执行

代码实例

public class CalculatorTest {
    /**
     * 初始化方法
     * 用于资源申请，所有测试方法在执行之前都会先执行该方法
     */
    @Before
    public void init(){
        System.out.println("init...");
    }
    /**
     * 释放资源方法
     * 在所有测试方法执行完后，都会自动指定该方法
     */
    @After
    public void close(){
        System.out.println("close...");
    }
    /**
     * 测试add方法
     */
    @Test
    public void testAdd(){
        System.out.println("in test...");
        // 1、创建计算器对象
        Calculator c = new Calculator();
        // 2、调用add方法
        int result = c.add(1,2);
        // 3、断言 断言这个结果是3
        Assert.assertEquals(3,result);
    }
}

二、反射

反射机制及相关概念

反射：将类的各个组成部分封装为其他对象，这就是反射机制。

反射的好处：一是可以在程序运行过程中操作这些对象；二是可以解耦，提高程序的可扩展性。

反射是框架设计的灵魂。框架，换句话说就是”半成品软件“，可以在框架的基础上进行软件开发，简化代码。

2.1 获取Class对象

可以通过三种方式获取Class对象：

• Class.forName("全类名")：将字节码文件加载进内存，返回Class对象。使用场景：多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
• 类名.class：通过类名的属性class获取。使用场景：多用于参数的传递。
• 对象.getClass()：getClass()方法在Object类中定义着。使用场景：多用于对象获取字节码的方式。

/**
 * Class.forName("全类名")：将字节码文件加载进内存，返回Class对象。使用场景：多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
 * 类名.class：通过类名的属性class获取。使用场景：多用于参数的传递。
 * 对象.getClass()：getClass()方法在Object类中定义着。使用场景：多用于对象获取字节码的方式。
 */
public static void main(String[] args) throws Exception {
    // Class.forName("全类名")
    Class cls1 = Class.forName("com.s0cket.domain.Person");
    System.out.println(cls1);
    // 类名.class
    Class cls2 = Person.class;
    System.out.println(cls2);
    // 对象.getClass()
    Person p = new Person();
    Class cls3 = p.getClass();
    System.out.println(cls3);
    // 判断获取到的class对象是不是同一个
    System.out.println(cls1 == cls2);
    System.out.println(cls2 == cls3);
}

注意：同一个字节码文件(**.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的class对象都是同一个。

2.2 获取Class对象的成员变量及操作

Field[] getFields()// 获取所有public修饰的成员变量
Field getField(String name)// 获取指定名称的public修饰的成员变量
Field[] getDeclaredFields()// 获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name)// 获取指定名称的成员变量，不考虑修饰符

通过Class对象进行成员变量的常用操作：

• 设置值: void set(Object obj, Object value)
• 获取值: get(Object obj)
• 忽略访问权限修饰符的安全检查:setAccessiable(true) // 暴力反射

// 获取Person的Class对象
Class personClass = Person.class;
//Field[] getFields()// 获取所有public修饰的成员变量
//Field getField(String name)// 获取指定名称的public修饰的成员变量
//Field[] getDeclaredFields()// 获取所有的成员变量，不考虑修饰符
//Field getDeclaredField(String name)// 获取指定名称的成员变量，不考虑修饰符

// 获取所有Public修饰的成员变量
Field[] fields = personClass.getFields();
for(Field field : fields) {
    System.out.println(field);
}
System.out.println("----------------");
// Field getField(String name)
Field a = personClass.getField("a");
// 获取成员变量a的值
Person p = new Person();
Object value = a.get(p);
System.out.println(value);
// 设置a的值
a.set(p, "张三");
System.out.println(p);

System.out.println("==========================");

//Field[] getDeclaredFields()// 获取所有的成员变量，不考虑修饰符
Field[] declaredFields = personClass.getDeclaredFields();
for (Field declaredField : declaredFields) {
    System.out.println(declaredField);
}
//Field getDeclaredField(String name)// 获取指定名称的成员变量，不考虑修饰符
Field d = personClass.getDeclaredField("name");
// 忽略访问权限修饰符的安全检查
d.setAccessible(true); // 暴力反射-否则访问私有成员变量的时候会报java.lang.IllegalAccessException
Object value2 = d.get(p);
System.out.println(value2);

2.3 获取Class对象的构造方法及操作

Constructor<?>[] getConstructors()
Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor<?>[] getDeclaredConstructors()
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

通过Class对象进行构造器的常用操作：

• 创建对象：T newInstance(Object... initargs)

// 获取Person的Class对象
Class personClass = Person.class;
/**
 * Constructor<?>[] getConstructors()
 * Constructor<T> getConstructor(Class<?>... parameterTypes)
 * Constructor<?>[] getDeclaredConstructors()
 * Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
 */

//Constructor<?>[] getConstructors()
Constructor[] constructors = personClass.getConstructors();
for (Constructor constructor : constructors) {
    System.out.println(constructor);
}

// Constructor<T> getConstructor(Class<?>... parameterTypes)
Constructor constructor = personClass.getConstructor(String.class, int.class);
System.out.println(constructor);

//创建对象
Object person = constructor.newInstance("赵晓", 18);
System.out.println(person);

// 使用无参构造方法创建对象
Object person1 = personClass.getConstructor().newInstance(); // 不可以简化成类对象.newInstance();
System.out.println(person1);

注意：

使用类对象.getConstructor().newInstance();方法来代替过时的空参数构造器简化的创建对象方式类对象.newInstance()。

2.4 获取Class对象的成员方法及操作

Method[] getMethods()
Method getMethod(String name, Class<?>... parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, Class<?>... parameterTypes)

通过Class对象进行成员方法常用操作：

• 执行方法：Object invoke(Object obj, Object... args)
• 获取方法名称：String getName()

// 获取Person的Class对象
Class personClass = Person.class;
/**
 * Method[] getMethods()
 * Method getMethod(String name, Class<?>... parameterTypes)
 * Method[] getDeclaredMethods()
 * Method getDeclaredMethod(String name, Class<?>... parameterTypes)
 */

// 获取指定名称的方法
Method eat_method = personClass.getMethod("eat");
Person p = new Person();
// 执行方法，参数传递类的对象
eat_method.invoke(p);

Method eat_method2 = personClass.getMethod("eat", String.class);
// 执行方法，参数传递类的对象和方法传递的参数
eat_method2.invoke(p,"雪糕");

System.out.println("=====================");

// 获取所有public 修饰的方法
Method[] methods = personClass.getMethods();
for (Method method : methods) {
    // 打印所有public修饰的方法，包括其父类Object的
    System.out.println(method);
    // 获取方法的名称
    String name = method.getName();
    System.out.println(name);
    // 方法也是可以设置权限的
    //method.setAccessible(true);
}

2.5 获取类名

String getName()

// 获取Person的Class对象
Class personClass = Person.class;
// 获取类名(绝对名称）
String calssName = personClass.getName();
System.out.println(calssName);//com.s0cket.domain.Person

2.6 综合案例

案例分析

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以创建任意类的对象，并且执行其中的任意方法

实现方式：配置文件和反射

实现步骤：

• 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
• 在程序中加载读取配置文件
• 使用反射技术来加载类文件进内存
• 创建对象
• 执行方法

配置文件

className=com.s0cket.domain.Student
methodName=sleep

案例代码

/**
 * 需求:写一个"框架"，不能改变该类的任何代码的前提下，可以创建任意类的对象，并且执行其中的任意方法
 * 实现方式：配置文件和反射
 * 实现步骤：
 * 1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中
 * 2.在程序中加载读取配置文件
 * 3.使用反射技术来加载类文件进内存
 * 4.创建对象
 * 5.执行方法
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 创建Properties对象
        Properties pro = new Properties();
        // 获取class目录下的配置文件
        // 需要注意的是配置文件一定要放在src目录下，否则会报空指针异常
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);

        // 获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");

        // 加载该类进内存
        Class cls = Class.forName(className);
        // 创建对象
        Object obj = cls.getConstructor().newInstance();
        // 获取方法对象
        Method method = cls.getMethod(methodName);
        // 执行方法
        method.invoke(obj);
    }
}

需要注意的是，配置文件一定要放在src目录下，否则会报空指针异常。

三、注解

3.1 概念

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

public @interface MyAnno {
    /**
     * 属性值有以下类型：
     * 基本数据类型
     * 枚举
     * 注解
     * 字符串
     * 以及上述四种类型的数组类型
     */
    int value();
    Person per();
    MyAnno2 anno2();
    String[] strs();
}

// 在Worker类上面添加注解，传递各个类型的属性值示例
@MyAnno(value = 12, per=Person.p1, anno2 = @MyAnno2, strs = {"zhaoxiao","dddd"})
public class Worker {
}

注解与注释

• 注解：说明程序用的，给计算器看的。

• 注释：用文字描述程序的，给程序员看的。

注解的几个作用：

• 编写文档：通过代码里标识的注解生成文档【生成文档doc文档】

/**
 * 注解javadoc演示
 *
 * @author pkgsbeq
 * @version 1.0
 * @since 1.5
 */
public class AnnoDemo01 {
    /**
     * 计算两个数的和
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     */
    public int add(int a, int b){
        return a + b;
    }
}

通过javadoc命令运行一下java文件即可在同级目录下生成一堆文件，其中index.html为生成的文档。

• 代码分析：通过代码里标识的注解对代码进行分析【使用反射】

• 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

3.2 JDK中预定的一些注解

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

@SuppressWarnings("all")
public class AnnoDemo02 {
    @Override
    public String toString(){
        return super.toString();
    }
    @Deprecated
    public void show01() {
        // 有缺陷，需要弃用
    }
    public void show02(){
        // 替代show01方法
    }
}

3.3 自定义注解

格式

元注解
public @interface 注解名称{}

本质:注解本质上就是一个接口，该接口默认继承Annotation接口

属性

属性是指接口中可以定义的成员方法。

属性的返回值类型：基本数据类型、String、枚举、注解、以及上述四种类型的数组。

定义了属性后，在使用时需要给属性赋值。给属性赋值的三个注意点：

• 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
• 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略。
• 数组赋值时，值使用{}报过。如果数组中只有一个值，则{}省略。

元注解

用于描述注解的注解成为元注解。

/** 
* @Target：描述注解能够作用的位置
   * ElementType取值：
  	 *TYPE: 可以作用于类上
     *METHOD: 可以作用与方法上
     *FIELD：可以作用于成员量上
* @Retention：描述注解被保留的阶段
	 * @Retention(RetentionPolicy.RUNTIME):当前被描述的注解，会保留到class字节码文件中，并被JVM读取到。
* @Documented:描述注解是否被抽取到api文档中
* @Inherited:描述注解是否被子类继承
**/

@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD}) // 表示该MyAnno3注解只能作用在类上
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
}

3.4 在程序中使用（解析）注解

使用（解析）：获取注解中定义的属性值。

(1)获取注解定义的位置的对象(Class,Method,Field)

(2)获取指定的注解，getAnnotation(Class) 其实是在内存中生成了该注解接口的实现类对象。

(3)调用注解中的后向方法获取配置的属性值

/**
 * 定义注解
 * 描述需要执行的类名和方法名
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {
    String className();
    String methodName();
}

/**
 * 框架类：使用注解来代替配置文件，通过反射来调用类中方法
 */
@Pro(className = "com.s0cket.annotation.Demo01", methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 1.获取该类的字节码文件对象
        Class reflectTestClass = ReflectTest.class;
        // 2.获取该类的注解对象
        /*
            getAnnotation(Class) 其实是在内存中生成了该注解接口的实现类对象
            public class ProImpl implements Pro(){
                @Override
                public String className(){
                    return "com.s0cket.annotation.Demo01";
                }
                @Override
                public String methodName(){
                    return "show";
                }
            }
         */
        // 需要强制转换
        Pro an = (Pro) reflectTestClass.getAnnotation(Pro.class);
        // 3.调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        // 4.加载该类进内存
        Class cls = Class.forName(className);
        // 5.创建对象
        Object obj = cls.getConstructor().newInstance();
        // 6.获取方法对象
        Method method = cls.getMethod(methodName);
        // 7.执行方法
        method.invoke(obj);
    }

}

3.5 综合案例：通过注解和解析程序完成对已知程序类的测试

自定义注解：

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Check {
}

需要进行测试的计算器类

// 已有的计算器类，需要对其方法进行测试
public class Calculator {
    // 加法
    @Check
    public void add() {
        System.out.println("1 + 0 =" + (1+0));
    }
    // 减法
    @Check
    public void sub() {
        System.out.println("3 - 2 =" + (3-2));
    }
    // 乘法
    @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注解的方法进行检测，将方法运行出现的错误写入到txt文件中。

/**
 * 简单的框架测试
 *
 * 当主方法执行后，会自动执行被检测的所有方法(加了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) {
            //System.out.println(method);
            // 4.判断方法上是否有Check注解
            if(method.isAnnotationPresent(Check.class)){
                // 5.有就执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    // 捕获异常
                    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.newLine();
                }
            }
        }
        bw.write("本次测试共出现了" + number + "次异常！");
        bw.flush();
        bw.close();
    }
}

3.6 小结

多数情况下，我们会使用注解，但不是自定义注解。注解是给编译器和解析程序用的。注解不是程序的一部分，可以理解为注解就是一个标签。

超强干货来袭

云风专访：近40年码龄，通宵达旦的技术人生