【Java EE】Day01 基础加强、Junit单元测试、反射、注解

〇、总结

1、测试：三个注解、断言判断

2、反射：三个阶段获取字节码对象的三种方式、忽略成员变量权限方法setAccessible(true)

3、注解：内置注解SupressWarning&Deprecated、元注解本质（javap反编译字节码后是继承Annotation的接口）及属性（Target、Retention、Documented、Inherited），解析注解获取属性值getAnnotation(注解名)建立接口类对象（方法：创建类对象newInstance()，得到方法getMethod()，运行方法method.invoke(类对象)）

一、Junit单元测试

1、白盒测试

• 步骤
  • 定义测试类com.itcast.Test.CalculatorTest
  • 定义测试方法void testAdd()

  给测试方法加注解

  • @Test
  • @Before：资源申请
  • @After：资源释放
  • 导入Junit的依赖环境
• 结果判定：
  • 使用断言操作 处理 结果
  • Assert.assertEquals(期望的结果,运算的结果);
  • 绿色：通过，红色：不通过

二、反射

https://www.cnblogs.com/liujinhui/p/14288009.html

1、概述

• 反射：
  • 将类的各个组成部分封装为不同对象
  • 是框架（半成品软件，可以在其之上开发）设计的灵魂
• Java代码在计算机中经历的三个阶段
  • Source源代码阶段
  • Class类对象阶段：通过类加载器把字节码加载到内存
  • Runtime运行时阶段
• 反射机制：　在类对象阶段创建和封装
  • 成员变量--field
  • 构造方法
  • 成员方法--method　
• 好处：
  • 可以在运行过程中操作对象
  • 解耦（读取配置文件），提高程序可扩展性

2、获取字节码class对象的三种方式

• 三种方式代表三个阶段
  • 源代码阶段：Class.forName("全类名（包名.类名）")
    • 常用于配置文件，手动加载
  • 类对象阶段：类名.class
  • 运行时阶段：对象.getClass()：getClass() 返回此 Object的运行时类
    • 用于对象获取字节码

package com.liujinhui.Day1209BaseEnhance.reflect;
import com.liujinhui.Day1209BaseEnhance.domain.Person;
import com.liujinhui.Day1209BaseEnhance.domain.Student;

public class ReflectDemo1 {
    /*
        获取class的三种方式
            源代码阶段（1）Class.forName("全类名（包名.类名）")：将字节码文件加载进内存，返回Class对象
            【只有字节码文件，没有进内存，需要手动将其加载到内存，使用forName这种手动加载方式】
            类对象阶段（2）类名.class：通过类名的属性class获取
            【字节码已经加载到内存，不需要再加载，只需要获取，没有对象通过类名的属性获取该对象】
            运行时阶段（3）对象.getClass()：getClass() 返回此 Object的运行时类，在Object类中定义
            【已经有对象，可以通过对象的方法进行获取类对象，封装在Object中的方法】
    * */
    public static void main(String[] args) throws Exception{
        //1.Class.forName("全类名（包名.类名）")
        //Class类的静态方法static Class<?> forName(String className) 返回与给定字符串名称的类或接口相关联的 Class对象。
        Class<?> cls1 = Class.forName("com.liujinhui.Day1209BaseEnhance.domain.Person");
        //如果遇到ClassNotFoundClass，是自定义，则说明，类名写错了，需要重写类名
        System.out.println(cls1);//class com.liujinhui.Day1209BaseEnhance.domain.Person
        //2.类名.class
        Class cls2 = Person.class;//删掉泛型
        System.out.println(cls2);
        //3.对象.getClass()：
        Person p=new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);
        //打印形式一样，直接使用==比较三个对象是否相等
        //==比较的是对象的内存地址
        System.out.println(cls1==cls2);
        System.out.println(cls2==cls3);
        //true
        Class c = Student.class;
        System.out.println(c==cls1);//每个字节码文件的物理文件对应的class类对象都不相同
    }
}

3、class功能概述

• 获取成员变量Fields
  • 获取所有getDeclaredFields()
  • 设置值set
  • 获取值get
  • 忽略访问权限检查：d.setAccessible(true)
• 获取成员方法
  • 获取所有getDeclared
  • 执行方法：invoke(obj,Object...args)
• 获取构造方法
  • 获取所有getDeclared
  • 创建对象newInstance()
• 获取类名

4、案例：根据配置文件创建任意类对象并执行任意方法

package com.liujinhui.Day1209BaseEnhance.reflect;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/*
    假设的框架类
    改配置文件使程序的扩展性更强，配置文件中使用了全类名，则使用了反射机制
* */
public class ReflectTest {
    /**
     * @author: Liu Jinhui
     * @description: 创建任意对象
     * @date: 2020/12/9 20:42
     * @return  * @param null
     */
    public static void main(String[] args) throws Exception{
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意方法
        * */
        //1.加载配置文件
        //1.1.创建Properties对象
        Properties pro=new Properties();
        //1.2加载配置文件，转换为一个双列map集合
        //1.2.1获取class目录下配置文件的方式，使用类加载器完成
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        //得到该类下的配置文件流
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        //加载属性流
        pro.load(is);
        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");
        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

三、注解

1、概念

• Annotation，又称Java标注，jdk5后，用于说明程序
• 作用分类
  • 编译检查@Override
  • 编写文档-生成doc文档@Documented
  • 代码分析

2、JDK内置注解

• @Override：检查是否是继承自父类重写的方法
• @Deprecated：标记过时的方法，如Date
• @SuppressWarnings("all")：让编译器忽略注解中声明的警告

3、注解的格式/本质

• 元注解

• 反编译可以查看注解的内容

• 本质是一个接口并继承自Annotation接口
  • 所有注释类型扩展的公共接口，接口本身不定义注释类型
• 注解中的属性：对应接口中的成员方法

4、属性定义

• 要求：
  • 属性的取值限定为：基本类型、String、枚举enum的对象、注解及对应数组
• 定义属性，使用时需要给属性赋值
  • default取默认值
  • 一个属性名为value可以不写
  • 数组赋值需要使用{}，如果只有一个值可以省略

5、元注解

• 描述注解的注解
• 包括
  • @Target：描述作用的位置（类、方法、成员变量）
    • @Target(value = {ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})
  • @Retention：描述注解被保留的阶段（RetentionPolicy.Source/Class/Runtime）
  • @Documented：描述是否被抽取到文档中
  • @Inherited：是否被子类继承，是的话，子类会自动继承父类的注解

6、解析注解：通过注解创建任意类的对象并执行指定方法

• 获取注解中定义的属性值
• 步骤
  • 获取定义的位置的对象（Class,Method,Field）
  • 获取指定注解getAnnotation(Class)--实际是在内存中生成了一个该注解接口的子类对象
  • 调用主机的抽象方法获取配置的属性值

package com.liujinhui.Day1209BaseEnhance.annotation;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/*
    假设的框架类
    改配置文件使程序的扩展性更强，配置文件中使用了全类名，则使用了反射机制
* */
@Pro(className = "com.liujinhui.Day1209BaseEnhance.annotation.Demo1",methodName = "show")
//要写全类名
public class ReflectTest {
    /**
     * @author: Liu Jinhui
     * @description: 创建任意对象
     * @date: 2020/12/9 20:42
     * @return  * @param null
     */
    public static void main(String[] args) throws Exception{
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码，可以创建任意类的对象，可以执行任意方法
        * */
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上面的注解对象
        //method也有getAnno
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        /*
            public class ProIMpl implements Pro{
                   public String className(){
                        return  "com.liujinhui.Day1209BaseEnhance.annotation.Demo1";
                   }
                   public String methodName(){
                        return "show";
                   }
         */
        //3.调用注解对象中调用的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className+methodName);
        //4.加载该类进内存
        Class cls = Class.forName(className);
        //5.创建类对象
        Object obj = cls.newInstance();
        //6.获取方法对象
        Method method = cls.getMethod(methodName);
        //7.执行方法
        method.invoke(obj);
    }
}　　　

7、案例：简单的测试框架

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

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

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

定义类别

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

/**
 * 小明定义的计算器类
 * 需要测试是否有错误
 */
public class Calculator {
    //加法
    @Check
    public void add(){
        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...");
    }
}

测试

package com.liujinhui.Day1209BaseEnhance.annotation.demo;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

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