JavaEE 初阶篇-深入了解 Junit 单元测试框架和 Java 中的反射机制（使用反射做一个简易版框架）

🔥博客主页：【小扳_-CSDN博客】
❤感谢大家点赞👍收藏⭐评论✍

文章目录

1.0 Junit 单元测试框架概述

1.1 使用 Junit 框架进行测试业务代码

1.2 Junit 单元测试框架的常用注解（Junit 4.xxx 版本）

2.0 反射概述

2.1 获取 Class 对象的三种方式

2.2 获取类的构造器并对其进行操作

2.3 获取类的成员变量

2.4 获取类的成员方法

3.0 使用反射做一个简易版的框架

1.0 Junit 单元测试框架概述

可以用来对方法进行测试，它是第三方公司开源出来的（很多开发工具已经集成了 Junit 框架，比如 IDEA）

优点：

1）可以灵活的编写测试代码，可以针对某个方法执行测试，也支持一键完成对全部方法的自动化测试，且各自独立。

2）不需要程序员去分析测试结果，会自动生成测试报告出来。

具体步骤：

1）将 Junit 框架的 jar 包导入到项目中（注意：IDEA 集成了 Junit 框架，不需要我们手动导入）

2）为需要测试的业务类，定义对应的测试类，并为每个方法，编写对应的测试方法（测试方法必须：公共、无参、无返回值）

3）测试方法上必须声明 @Test 注解，然后在测试方法中，编写代码调用被测试的业务方法进行测试。其实就是列出实际例子进行测试。

4）开始测试：选中测试方法，右键选择 “Junit 运行”，如果测试通过则是绿色；如果测试失败，则是红色。

1.1 使用 Junit 框架进行测试业务代码

举个例子：

业务代码：
//这是项目的业务代码
public class ProjectBusiness {

    //项目业务一:获取字符串的长度
    public static void printLength(String str){
        System.out.println(str.length());
    }

    //项目业务二:获取字符串最大的索引下标
    public static int getMaxIndex(String str){
        if (str == null){
            return -1;
        }
        return str.length();
    }
}
测试业务代码：
import org.junit.Test;

//测试业务:对项目业务代码进行测试
public class TestBusiness {

    //针对每一个方法进行测试，定义测试方法必须是公开、无参、无返回值

    //对业务一代码进行测试
    //记得要加上注解
    @Test
    public void testPrintLength(){
        //然后调用业务一的代码，列举实际例子
        ProjectBusiness.printLength("你好世界!!!");
        ProjectBusiness.printLength("你好小板");
        ProjectBusiness.printLength(null);
    }


}
对于业务一代码来说很明显是缺少了一个 if 判断是否为 null ，假设我们没有发现，现在来看测试结果：

测试出来的结果也明确的表示是因为空指针导致的测试失败。

将代码改进加上 if 判断是否为 null 之后的测试运行结果：

这样就测试通过了，不过需要注意的是，当前测试通过是指：目前写的业务代码是没有异常报错，但是对于逻辑是否正确，当前的测试正确与代码业务逻辑是否跟我们所想的没有任何关联，再次注意：此时的测试的通过，是指写到实际例子中没有抛异常、没有报错仅此而已，万一程序员写的实际例子考虑不周全，会导致测试覆盖面不够全面。

断言机制：程序员可以通过预测业务方法的结果，从而实现测试出来的结果与我们一开始所认为的结果是否相同，从而来判断代码逻辑是否正确。

断言方法的参数：

调用静态的断言方法，第一个参数是如果预测的结果与测试出来的结果不一样时，提供的消息。第二个参数是自己预测的结果。第三个参数是测试出来的结果。

对业务二代码进行测试：

业务二代码：

//这是项目的业务代码
public class ProjectBusiness {

    //项目业务二:获取字符串最大的索引下标
    public static int getMaxIndex(String str){
        if (str == null){
            return 0;
        }
        return str.length();
    }
}

测试业务二代码：

import org.junit.Assert;
import org.junit.Test;
//测试业务:对项目业务代码进行测试
public class TestBusiness {


    //对业务二代码进行测试
    @Test
    public void testGetMaxIndex(){
        //接着调用业务二的方法
        int index1 = ProjectBusiness.getMaxIndex(null);
        //进行断言
        Assert.assertEquals("此处出现 BUG 啦!!!",0,index1);

        int index2 = ProjectBusiness.getMaxIndex("你好鸭小板");
        //进行断言
        Assert.assertEquals("此处出现 BUG 啦!!!",4,index2);
    }


}

测试结果：

这里出现了测试错误，我们预期 4 ，实际测试出来的结果是 5 。显然是我们的业务二代码逻辑与我们一开始所认为的结果不一样。

现在将业务二代码逻辑进行改进：

    //项目业务二:获取字符串最大的索引下标
    public static int getMaxIndex(String str){
        if (str == null){
            return 0;
        }
        return str.length()-1;
    }

再来进行测试。

测试结果：

1.2 Junit 单元测试框架的常用注解（Junit 4.xxx 版本）

1）@Test：测试类中的方法必须用它修饰才能成为测试方法，才能启动执行。

2）@Before：用来修饰一个实例方法，该方法会在每一个测试方法执行之前执行一次。

3）@After：用来修饰一个实例方法，该方法会在每一个测试方法执行之后执行一次。

4）@BeforeClass：用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次。

5）@AfterClass：用来修饰一个静态方法，该方法会在所有测试方法之后只执行一次。

在测试方法执行前执行的方法，常用于：初始化资源。

在测试方法执行后执行的方法。常用于：释放资源。

代码演示：

import org.junit.*;

//测试业务:对项目业务代码进行测试
public class TestBusiness {

    //在执行全部测试方法之前，先执行以下代码
    @BeforeClass
    public static void bfc(){
        System.out.println("在执行bfc方法，在全部测试方法之前执行且只执行一次");
    }

    //执行每个测试代码之前都会先执行以下的方法
    @Before
    public void bf(){
        System.out.println("在执行bf方法啦!!!");
    }

    //执行每个测试代码之后都会执行以下的方法
    @After
    public void at(){
        System.out.println("在执行at方法啦!!!");
    }

    
    //在执行全部测试方法之后，再执行以下代码
    @AfterClass
    public static void atc(){
        System.out.println("在执行atc方法，在全部测试方法之后执行且只执行一次");
    }


    //针对每一个方法进行测试，定义测试方法必须是公开、无参、无返回值
    //对业务一代码进行测试
    //记得要加上注解
    @Test
    public void testPrintLength(){
        //然后调用业务一的代码，列举实际例子
        ProjectBusiness.printLength("你好世界!!!");
        ProjectBusiness.printLength("你好小板");
        ProjectBusiness.printLength(null);
        System.out.println("业务代码一执行完毕！！！");
    }

    //对业务二代码进行测试
    @Test
    public void testGetMaxIndex(){
        //接着调用业务二的方法
        int index1 = ProjectBusiness.getMaxIndex(null);
        //进行断言
        Assert.assertEquals("此处出现 BUG 啦!!!",0,index1);

        int index2 = ProjectBusiness.getMaxIndex("你好鸭小板");
        //进行断言
        Assert.assertEquals("此处出现 BUG 啦!!!",4,index2);
        System.out.println("业务代码二执行完毕！！！");
    }
    
}

全部测试方法的结果：

2.0 反射概述

Java 反射是指在运行时动态地获取类的信息、调用类的方法、操作类的属性等能力。Java 反射机制提供了一种在运行时检查类、接口、字段和方法的能力，而不需要在编译时就知道这些信息。

使用 Java 反射，可以在运行时动态地加载类、创建对象、调用方法、访问属性等，这为编写灵活的、可扩展的程序提供了便利。反射机制允许程序在运行时获取类的信息，甚至可以动态地修改类的行为。

简单来说：反射是在类加载之后对类进行操作的一种机制，允许以编程的方式解剖类中的各种成分（构造器、成员变量、成员方法等）。

反射过程：

1）反射第一步：加载类、获取类的字节码：Class 对象。

2）获取类的构造器：Constructor 对象

3）获取类的成员变量：Field 对象

4）获取类的成员方法：Method 对象

2.1 获取 Class 对象的三种方式

第一种方式：

Class c1 = 类名.class

public class demo1 {
    public static void main(String[] args) throws ClassNotFoundException {

        //通过类名来获取Class对象
        Class c1 = Cat.class;
        System.out.println(c1.getName());

    }
}

第二种方式：

调用 Class 提供的方法：public static Class forName(String package);

该参数名为：全类名

public class demo1 {
    public static void main(String[] args) throws ClassNotFoundException {

        //通过全类名获取Class对象
        Class c2 = Class.forName("Reflection.Cat");
        System.out.println(c2.getName());

    }
}

第三种方式：

Object 提供的方法：public Class getClass();

public class demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过对象名来获取
        Cat cat = new Cat();
        Class c3 = cat.getClass();
        System.out.println(c3.getName());
    }
}

以上三种获取 Class 对象都是同一个对象，因为 Cat 类的字节码文件只有一份。可以通过代码进行比较以下。

public class demo1 {
    public static void main(String[] args) throws ClassNotFoundException {

        //通过类名来获取Class对象
        Class c1 = Cat.class;
        System.out.println(c1.getName());

        //通过全类名获取Class对象
        Class c2 = Class.forName("Reflection.Cat");
        System.out.println(c2.getName());
        //通过对象名来获取
        Cat cat = new Cat();
        Class c3 = cat.getClass();
        System.out.println(c3.getName());

        System.out.println(c1 == c2);
        System.out.println(c3 == c2);
        System.out.println(c1 == c3);
    }
}

运行结果：

2.2 获取类的构造器并对其进行操作

获取构造器的方法：

1）Constructor[] getConstructors()：获取全部构造器（只能获取 public 修饰的）

代码演示：

import java.lang.reflect.Constructor;

public class demo2 {
    public static void main(String[] args) {
        //第一步先获取Class对象
        Class c = Cat.class;

        //第二步利用Class对象提供的方法来获取构造器
        //获取全部用 Public 修饰的构造器
        Constructor[] constructors = c.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + " => 参数有 " + constructor.getParameterCount() + " 个");
        }

        
    }
}

运行结果：

2）Constructor[] getDeclaredConstructors()：获取全部构造器（只要存在就能拿到）

代码演示：

import java.lang.reflect.Constructor;

public class demo3 {
    public static void main(String[] args) {
        //第一步先获取Class对象
        Class c = Cat.class;

        //第二步再来获取全部构造器(即使用private修饰的构造器也可以获取到)
        Constructor[] constructors = c.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + " =>参数有 " + constructor.getParameterCount() + " 个");
        }

    }

}

运行结果：

3）Constructor[] getConstructor()：获取某个构造器（只能获取 public 修饰的）

代码演示：

import java.lang.reflect.Constructor;

public class demo4 {
    public static void main(String[] args) throws NoSuchMethodException {
        //第一步先获取Class对象
        Class c = Cat.class;
        //第二步再获取指定的构造器
        //先获取无参的构造器
        Constructor c1 = c.getConstructor();
        System.out.println(c1.getName() + " => 参数有 " + c1.getParameterCount() + " 个");

        //获取有参的构造器
        Constructor c2 = c.getConstructor(String.class,int.class);
        System.out.println(c2.getName() + " => 参数有 " + c2.getParameterCount() + " 个");
        
    }
}

运行结果：

4）Constructor[] getDeclaredConstructor()：获取某个构造器（只要存在就能拿到）

代码演示：

import java.lang.reflect.Constructor;

public class demo5 {
    public static void main(String[] args) throws NoSuchMethodException {
        //第一步先获取Class对象
        Class c = Cat.class;
        //第二步再获取指定的构造器
        //先获取无参的构造器
        Constructor c1 = c.getDeclaredConstructor();
        System.out.println(c1.getName() + " => 参数有 " + c1.getParameterCount() + " 个");

        //获取有参的构造器
        Constructor c2 = c.getDeclaredConstructor(String.class,int.class);
        System.out.println(c2.getName() + " => 参数有 " + c2.getParameterCount() + " 个");
    }
}

运行结果：

获取类构造器的作用：

利用获取的构造器来创建对象。

Constructor 提供的方法：

1）T newInstance(Object)：调用次构造器对象表示的构造器，并传入参数，完成对象的初始化并返回。

2）public void setAccessible(boolean flag)：设置为 true ，表示禁止检查访问控制（暴力反射）。

代码演示：

Cat 类

public class Cat {
    String name;
    int age;

    public Cat(){

    }

    private Cat(String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

利用反射获取有参构造器，来创建 Cat 对象：

import java.lang.reflect.Constructor;

public class demo6 {
    public static void main(String[] args) throws Exception {
        //第一步先获取Class对象
        Class c = Cat.class;
        //第二步再获取构造器
        Constructor constructor = c.getDeclaredConstructor(String.class,int.class);
        //由于Cat类中的有参构造器是private修饰的，所以需要设置禁止检查
        constructor.setAccessible(true);
        //最后再来利用获取的构造器来创建Cat对象
        Cat cat = (Cat) constructor.newInstance("小板",2);
        //再来查看对象是否创建成功
        System.out.println(cat);
    }
}

运行结果：

2.3 获取类的成员变量

Class 提供从类中获取成员变量的方法：

1）public Field[] getFields()：获取类的全部成员变量（只能获取 public 修饰的）

代码演示：

import java.lang.reflect.Field;

public class demo7 {
    public static void main(String[] args) {
        //先获取Class对象
        Class c = Cat.class;
        //再获取成员变量(只能获取全部的public修饰的成员变量)
        Field[] fields = c.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
    }
}

运行结果：

2）public Field[] getDeclaredFields()：获取类的全部成员变量（只要存在就能拿到）

代码演示：

import java.lang.reflect.Field;

public class demo7 {
    public static void main(String[] args) {
        //先获取Class对象
        Class c = Cat.class;
        //再获取成员变量(只能获取全部的成员变量)
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
    }
}

运行结果：

3）public Field[] getField(String name)：获取类的某个成员变量（只能获取 public 修饰的）

代码演示：

import java.lang.reflect.Field;

public class demo8 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class c = Cat.class;
        //根据名字来获取变量对象
        Field fieldName = c.getField("name");
        System.out.println(fieldName.getName());

        Field fieldAge = c.getField("age");
        System.out.println(fieldAge.getName());
    }
}

运行结果：

4）public Field[] getDeclaredField(String name)：获取类的某个成员变量（只要存在就能拿到）

代码演示：

import java.lang.reflect.Field;

public class demo8 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class c = Cat.class;
        //根据名字来获取变量对象
        Field fieldName = c.getDeclaredField("name");
        System.out.println(fieldName.getName());

        Field fieldAge = c.getDeclaredField("age");
        System.out.println(fieldAge.getName());
    }
}

运行结果：

获取到成员变量的作用：

获取到的成员变量对象可以用来赋值、取值操作。

常用方法：

1）void set(Object obj,Object value)：赋值，第一个参数为 Cat 实例对象，第二个参数为需要赋值为 value 。

2）Object get(Object obj)：取值，参数为 Cat 实例对象。

3）public void setAccessible(boolean flag)：设置为 true ，表示禁止检查访问控制（暴力反射）

代码演示：

import java.lang.reflect.Field;

public class demo9 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        //先获取class对象
        Class c = Cat.class;

        //Cat 的实例对象
        Cat cat = new Cat();
        //再获取变量对象
        Field fieldName = c.getDeclaredField("name");
        Field fieldAge = c.getDeclaredField("age");

        //禁止检查访问控制
        fieldName.setAccessible(true);
        fieldAge.setAccessible(true);
        //进行赋值操作
        fieldName.set(cat,"小板");
        fieldAge.set(cat,2);

        //再进行取值操作
        String name = (String) fieldName.get(cat);
        int age = (int) fieldAge.get(cat);

        //查看是否赋值成功
        System.out.println(cat);

    }
}

运行结果：

2.4 获取类的成员方法

Class 提供了从类中获取成员方法的 API ：

1）Method[] getMethods()：获取类的全部成员方法（只能获取 public 修饰的方法）

代码演示：


import java.lang.reflect.Method;
import java.util.Arrays;

public class demo10 {
    public static void main(String[] args) {
        //先获取class对象
        Class c = Cat.class;
        //再获取全部public修饰的方法
        Method[] methods = c.getMethods();
        for (Method method : methods) {
            System.out.println(method.getName() + " =>" + Arrays.toString(method.getParameterTypes()) +  " => " + method.getReturnType());
        }
    }
}

运行结果：

2）Method[] getDeclaredMethods()：获取类的全部成员方法（只要存在就能拿到）

代码演示：

import java.lang.reflect.Method;
import java.util.Arrays;

public class demo10 {
    public static void main(String[] args) {
        //先获取class对象
        Class c = Cat.class;
        //再获取全部public修饰的方法
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() + " =>" + Arrays.toString(method.getParameterTypes()) +  " => " + method.getReturnType());
        }
    }
}

运行结果：

3）Method getMethod(String name,参数类型)：获取类的某个成员方法（只能获取 public 修饰的）

代码演示：

import java.lang.reflect.Method;
import java.util.Arrays;

public class demo11 {
    public static void main(String[] args) throws Exception {
        
        //先获取class对象
        Class c = Cat.class;
        //再获取指定方法
        Method setNameMethod = c.getMethod("setName", String.class);
        System.out.println(setNameMethod.getName() + " => " + Arrays.toString(setNameMethod.getParameterTypes()) + " => " + setNameMethod.getReturnType());
        
    }
}

运行结果：

4）Method getDeclaredMethod(String name,参数类型)：获取类的某个成员方法（只要存在就能拿到）

代码演示：

import java.lang.reflect.Method;
import java.util.Arrays;

public class demo11 {
    public static void main(String[] args) throws Exception {

        //先获取class对象
        Class c = Cat.class;
        //再获取指定方法
        Method setNameMethod = c.getDeclaredMethod("setName", String.class);
        System.out.println(setNameMethod.getName() + " => " + Arrays.toString(setNameMethod.getParameterTypes()) + " => " + setNameMethod.getReturnType());

    }
}

运行结果：

成员方法的作用：

执行某个对象的方法。

Methos 提供的方法：

1）public Object invoke(Object obj,方法的参数)：触发某个对象的该方法执行。

2）public void setAccessible(boolean flag)：设置为 true ，表示禁止检查访问控制（暴力反射）

代码演示：

import java.lang.reflect.Method;

public class demo12 {
    public static void main(String[] args) throws Exception {
        //先获取class对象
        Class c = Cat.class;

        //Cat对象
        Cat cat = new Cat();
        //再来获取指定的方法来设置名字,年龄
        Method setNameMethod = c.getDeclaredMethod("setName", String.class);
        setNameMethod.setAccessible(true);
        setNameMethod.invoke(cat,"小板");

        Method setAgeMethod = c.getDeclaredMethod("setAge", int.class);
        setNameMethod.setAccessible(true);
        setAgeMethod.invoke(cat,2);

        //查看是否设置成功
        Method getNameMethod = c.getDeclaredMethod("getName");
        getNameMethod.setAccessible(true);
        String name = (String) getNameMethod.invoke(cat);
        System.out.println(name);

        Method getAgeMethod = c.getDeclaredMethod("getAge");
        getAgeMethod.setAccessible(true);
        int age = (int) getAgeMethod.invoke(cat);
        System.out.println(age);

        System.out.println(cat);
    }
}

运行结果：

3.0 使用反射做一个简易版的框架

需求：对于任意一个对象，该框架都可以把对象的字段名和对应的值，保存到文件中去。

实现步骤：

1）定义一个方法，可以接收任意对象。

2）每收到一个对象后，使用反射获取该对象的 class 对象，然后获取全部成员变量。

3）遍历成员遍历，然后提取成员变量在该对象中具体的值。

4）把成员变量名和值，写出到文件中即可。

代码如下：

学生类：

public class Student {
    public String name;
    public int age;
    public double height;
    public String gender;
    public String description;

    public Student(String name, int age, double height, String gender, String description) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.gender = gender;
        this.description = description;
    }
}

老师类：

public class Teacher {
    public String name;
    public int age;
    public double height;
    public String gender;
    public String description;

    public Teacher(String name, int age, double height, String gender, String description) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.gender = gender;
        this.description = description;
    }
}

核心业务代码：

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;

public class Project {

    public static void business(Object obj) throws IllegalAccessException, FileNotFoundException {
        //创建I/O对象，可追加
        PrintStream ps = new PrintStream(new FileOutputStream("D:\\software\\code\\2023_java\\2023_java_code\\code_24_5_3\\src\\Reflection\\Text.text",true));

        //先获取class对象
        Class c = obj.getClass();
        ps.println("==============" + c.getName() + "==============");

        //再获取全部成员变量
        Field[] fields = c.getDeclaredFields();
        //将其进行遍历
        for (Field field : fields) {
            String name = field.getName();
            String value = field.get(obj) + "";
            ps.println(name + " => " + value);
        }

        //记得关闭资源
        ps.close();
    }
}

对业务代码进行测试：

import org.junit.Test;

import java.io.FileNotFoundException;

public class TestProject {

    //对该项目业务进行测试:
    @Test
    public void testProject() throws FileNotFoundException, IllegalAccessException {
        Teacher teacher = new Teacher("小板",20,175.5,"男","热爱学习技术且分享技术");
        Teacher teacher1 = new Teacher("小狗",22,179.5,"男","热爱骨头且分享骨头");
        Teacher teacher2 = new Teacher("小扳手",22,174.5,"男","热爱奋斗");

        Student student = new Student("小童",21,170.0,"女","爱笑");
        Student student1 = new Student("小黑",20,178.0,"女","爱哭");

        Project.business(teacher);
        Project.business(teacher1);
        Project.business(teacher2);
        Project.business(student);
        Project.business(student1);

    }
}

测试结果：