JavaSE——单元测试、反射、注解、动态代理

单元测试

单元测试概述

单元测试

• 单元测试就是针对最小的功能单元编写测试代码，Java程序最小的功能单元是方法，因此，单元测试就是针对Java方法的测试，进而检查方法的正确性。

目前测试方法是怎么进行 的，存在什么问题。

• 只有一个main方法，如果一个方法的测试失败了，其他方法测试都会受到影响。
• 无法得到测试的结果报告，需要程序员自己去观察测试是否成功。
• 无法实现自动化测试。

Junit单元测试框架

• Junit是使用Java语言实现的单元测试框架，它是开源的。
• 几乎所有的IDE工具都集成了Junit，Junit目前最新版本是5

Junit优点

• Junit可以灵活的选择执行哪些测试方法，可以一键执行全部测试方法。
• Junit可以生成全部方法的测试报告。
• 单元测试中的某个方法测试失效了，不会影响其他测试方法的测试。

小结

1. Junit单元测试是做什么的？
   • 测试类中方法的正确性
2. Junit单元测试的优点是什么？
   • Junit可以选择执行哪些测试方法，可以一键执行全部测试方法的测试。
   • Junit可以生成测试报告，如果测试良好则是绿色；如果测试失败则是红色。
   • 单元测试中的某个测试方法失败了，不会影响其他测试方法的测试。

单元测试快速入门

步骤：单元测试快速入门

需求：使用单元测试进行业务方法预期结果、正确性测试

分析：

1. 将Junit的jar包导入到项目中
   • IDEA通常整合好了Junit框架，一般不需要导入。
   • 如果IDEA没有整合好，需要自己手动导入Junit的2个jar包到模块
2. 编写测试方法：该测试方法必须是公共的无参数无返回值的非静态方法
3. 在测试方法上使用@Test注解：标注该方法是一个测试方法
4. 在测试方法中完成被测试方法的预期正确性测试
5. 选择测试方法，选择“Junit运行” ， 如果测试良好则是绿色；如果测试失败，则是红色

/**
 * 业务方法
 */
public class UserService {
   
    public String loginName(String loginName, String passWord) {
   
        if ("admin".equals(loginName) && "12345".equals(passWord)) {
   
            return "登录成功";
        } else {
   
            return "用户名或者密码有问题！";
        }
    }
    public void selectNames(){
   
        System.out.println(10/0);
        System.out.println("查询全部用户名称成功！");
    }
}

/**
    测试类
 */
public class TestUserService {
   
    /**
        测试方法
        注意点：
            1.必须是公开的，无参数，无返回值的方法
            2.测试方法必须使用@Test注解标记
     */
    @Test
    public void testLoginName(){
   
        UserService userService = new UserService();
        String rs = userService.loginName("admin","123456");

        //进行预期结果的正确性测试：断言
        Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);
    }

    @Test
    public void testSelectNames(){
   
        UserService userService = new UserService();
        userService.selectNames();
    }
}
output:

output:

单元测试常用注解

Junit常用注解（Junit 4.xxxx版本)

注解	说明
@Test	测试方法
@Before	用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次
@After	用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次
@BeforeClass	用来修饰静态方法，该方法会在所有测试方法执行之前执行一次
@AfterClass	用来修饰静态方法，该方法会在所有测试方法之后执行一次

• 开始执行的方法：初始化资源。
• 执行完之后的方法：释放资源。

/**
    测试类
 */
public class TestUserService {
   
    //修饰实例方法的
    @Before
    public void before(){
   
        System.out.println("======before方法执行一次=======");
    }

    @After
    public void after(){
   
        System.out.println("========after方法执行一次=========");
    }

    //修饰静态方法的
    @BeforeClass
    public static void beforeClass(){
   
        System.out.println("========beforeClass方法执行一次=========");
    }

    @AfterClass
    public static void afterClass(){
   
        System.out.println("========afterClass方法执行一次=========");
    }
    /**
        测试方法
        注意点：
            1.必须是公开的，无参数，无返回值的方法
            2.测试方法必须使用@Test注解标记
     */
    @Test
    public void testLoginName(){
   
        UserService userService = new UserService();
        String rs = userService.loginName("admin","123456");

        //进行预期结果的正确性测试：断言
        Assert.assertEquals("您的业务功能可能出现问题","登录成功",rs);
    }

    @Test
    public void testSelectNames(){
   
        UserService userService = new UserService();
        userService.selectNames();
    }
}
output:
========beforeClass方法执行一次=========
======before方法执行一次=======
查询全部用户名称成功！
========after方法执行一次=========
========afterClass方法执行一次=========

Junit常用注解（Junit 5.xxxx版本)

注解	说明
@Test	测试方法
@BeforeEach	用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次
@AfterEach	用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次
@BeforeAll	用来修饰静态方法，该方法会在所有测试方法之前执行一次
@AfterAll	用来修饰静态方法，该方法会在所有测试方法之后执行一次

• 开始执行的方法：初始化资源
• 执行完之后的方法：释放资源

反射

反射概述

• 反射是指对于任何一个Class类，在“运行的时候”都可以直接得到这个类的全部成分
• 在运行时，可以直接得到这个类的构造器对象：Constructor
• 在运行时，可以直接得到这个类的成员变量对象：Filed
• 在运行时，可以直接得到这个类的成员方法对象：Method
• 这种运行时动态获取类信息以及动态调用类中成分的能力称为Java语言的反射机制。

反射的关键：

• 反射的第一步都是先得到编译后的Class类对象，然后就可以得到Class的全部成分。

HelloWorld.java -> javac -> HelloWorld.class
Class c = HelloWorld.class;

1. 反射的基本作用、关键？
   • 反射是在运行时获取类的字节码文件对象：然后可以解析类中的全部成分
   • 反射的核心思想和关键就是：得到编译以后的class文件对象。

反射获取类对象

反射的第一步：获取Class类的对象

public class Test {
   
    public static void main(String[] args) throws Exception {
   
        //1.Class类中的一个静态方法：forName(全限名：类名+包名）
        Class c = Class.forName("com.csl.d2_reflect_class.Student");
        System.out.println(c);//Student.class

        //2.类名.class
        Class c2 = Student.class;
        System.out.println(c2);

        //3.对象.getClass()   获取对象对应类的Class对象
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3);
    }
}
public class Student {
   
}
output:
class com.csl.d2_reflect_class.Student
class com.csl.d2_reflect_class.Student
class com.csl.d2_reflect_class.Student

1. 反射的第一步是什么？
   • 获取Class类对象，如此才可以解析类的全部成分。
2. 获取Class类的对象的三种方式。
   • 方式一：Class c1 = Class.forName(“全类名”);
   • 方式二：Class c2 = 类名.class
   • 方式三：Class c3 = 对象.getClass();

反射获取构造器对象

使用反射技术获取构造器对象并使用

• 反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。
• Class类中用于获取构造器的方法

方法	说明
Contructor<?> [ ] getConstructors( )	返回所有构造器对象的数组(只能拿public的)
Constructor<?>[ ] getDeclaredConsturctors( )	返回所有构造器对象的数组，存在就能拿到
Constructor getConstructor(Class<?>… parmeterTypes)	返回单个构造器对象（只能拿public的）
Constructor getDeclaredConstructor(Class<?>… parameterTypes)	返回单个构造器对象，存在就能拿到

public class TestStudent01 {
   
    //1.getConstructors:
    //获取全部的构造器：只能获取public修饰的构造器
    //Constructor[] getConstuctors()
    @Test
    public void getConstructors() {
   
        //a.第一步，获取类对象
        Class c = Student.class;
        //b.提取类中的全部构造器对象(这里只能拿public修饰的）
        Constructor[] constructors = c.getConstructors();
        //c.遍历构造器、
        for (Constructor constructor : constructors) {
   
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    //2.getDeclaredConstructors();
    //获取全部的构造器，无所谓权限是否可及
    @Test
    public void getDeclraredConstructors() {
   
        //a.第一步获取类对象
        Class c = Student.class;
        //b.提取类中的全部构造器对象
        Constructor[] constructors = c.getDeclaredConstructors();
        //c.遍历构造器
        for (Constructor constructor : constructors) {
   
            System.out.println(constructor.getName() + "===>" + constructor.getParameterCount());
        }
    }

    //3.getConstructors(Class... parameterTypes)
    //获取某个构造器：只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception {
   
        //a.获取类对象
        Class c = Student.class;
        //b.定位单个构造器对象(按照参数定位无参数的构造器）
        Constructor cons = c.getConstructor();
        System.out.println(cons.getName() + "===>" + cons.getParameterCount());
    }

    //4.getDeclaredConstructor
    //获取某个构造器：只要存在的都可以拿到不考虑修饰符
    @Test
    public void getDeclaredConstructor() throws Exception {
   
        //a.获取类对象
        Class c = Student.class;
        //b.定位某个有参构造器
        Constructor cons2 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(cons2.getName() + "===>" + cons2.getParameterCount());
    }
}

使用反射技术获取构造器对象并使用

• 获取构造器的作用依然是初始化一个对象返回。

Constructor类中用于创建对象的方法

符号	说明
T newInstance(Object… initargs)	根据指定的构造器创建对象
public void setAccessible(boolean flag)	设置为true，表示取消访问检查，进行暴力反射

public class Student {
   
    private String name;
    private int age;

    private Student() {
   
        System.out.println("无参构造器执行！");
    }

    public Student