[开发测试]基础加强 Junit反射注解

Junit单元测试

测试分类

黑盒测试：黑盒测试又叫功能测试、数据驱动测试或给予需求规格说明书的功能测试。这种测试注重于测试软件的功能性需求。
白盒测试：白盒测试又称结构测试、逻辑驱动测试或基于程序代码内部结构的测试。此时，需要深入考察程序代码的内部结构、逻辑设计等等。白盒测试需要测试工程师具备很深的软件开发工地，精通相应的开发语言，一般的软件测试工程师难以胜任该工作。

Junit使用步骤 白盒

1、定义一个测试类（测试用例）
测试类名：被测试类名+Test
包名：xxx.xxx.xx.Test
2、定义测试方法：可以独立运行
方法名：test+测试方法名
返回值：void
参数列表：空参
3、给方法+@Test
4、导入junit依赖
判定结果：红色代表失败，绿色代表成功
一般使用断言的操作来处理结果

 Assert.assertEquals(期望值,运算值);

计算器类

public class Calculator {
    public int add(int a,int b){
        //int i = 3/0;
        return a - b;
    }

    public int sub(int a,int b){
        return a - b;
    }
}

测试类

import org.junit.Assert;
import org.junit.Test;

public class CalculatorTest {


    /*
    * 测试add方法
    * */
    @Test
    public void testAdd(){
        //1、创建计算器对象
        Calculator c = new Calculator();
        //2、调用add方法
        int result = c.add(1,2);
       //3、断言：断言这个结果是3
        Assert.assertEquals(3,result);//期望值是3真实值是result
    }
}

初始化方法 @Before

/*
    * 初始化方法：
    * 用于申请资源，所有测试方法在执行之前都会先执行该测试方法*/
    @Before
    public void init(){
        System.out.println("init.....");
    }

释放资源方法 @After

 /*
    * 释放资源方法：
    * 在所有测试方法执行完后，都会自动执行该方法*/
    @After
    public void close(){
        System.out.println("close.....");
    }

反射

框架设计的灵魂

框架：半成品软件

可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制。

好处：
1、在程序运行过程中，操作这些对象。
2、可以解耦，提高程序的可扩展性。

获取Class字节码对象的方式：

1、Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象，多用于配置文件，将类名定义在配置文件中，读取文件，加载类
2、类名.class:通过类名的属性class获取
多用于参数的传递
3、对象.getClass（）：getClass（）方法在Object类中定义，所有对象都有这种方法
多用于对象的获取字节码的方式

public class ReflectDemo01 {
    public static void main(String[] args) throws Exception {
        //1、Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
        Class cls1 = Class.forName("cn.day18.domain.Person");
        System.out.println(cls1);

        //2、类名.class:通过类名的属性class获取
        Class<Person> cls2 = Person.class;
        System.out.println(cls2);

        //3、对象.getClass（）：getClass（）方法在Object类中定义，所有对象都有这种方法
        Person p = new Person();
        Class<? extends Person> cls3 = p.getClass();
        System.out.println(cls3);

        //用==比较三个对象
        System.out.println(cls1==cls2);//true
        System.out.println(cls1==cls3);//true
        System.out.println(cls2==cls3);//true
    }
}

结论：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获得class对象都是同一个。

Class功能

获取功能

获取成员变量们

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

 public static void main(String[] args) throws Exception {
        //0、获取Person的class对象
        Class personClass = Person.class;
        //1、获取成员变量们
        //Field[] getFields() 获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);//public java.lang.String cn.day18.domain.Person.a
        }


        //Field getField(string name) 获取指定名称的public修饰的成员变量
        Field a = personClass.getField("a");
        System.out.println(a);//public java.lang.String cn.day18.domain.Person.a
        //获取到成员变量可以设置值void set(Object obj,Object value)，获取值get(Object obj)
        //获取成员变量a的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);//null
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);//Person{name='null', age=0, a='张三', b='null', c='null', d='null'}


        //Field[] getDeclaredFields()获取所有的成员变量，不考虑访问权限修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);//获取所有的成员变量
            //private java.lang.String cn.day18.domain.Person.name
            //private int cn.day18.domain.Person.age
            //public java.lang.String cn.day18.domain.Person.a
            //protected java.lang.String cn.day18.domain.Person.b
            //java.lang.String cn.day18.domain.Person.c
            //private java.lang.String cn.day18.domain.Person.d
        }


        //Field getDeclaredField(string name) 获取指定名称的成员变量
        Field d = personClass.getDeclaredField("d");
        //在访问有访问权限修饰符时，忽略访问权限的安全检查
        d.setAccessible(true);//暴力反射
        Object value1 = d.get(p);
        System.out.println(value1);//null
        d.set(p,"李四");
        System.out.println(p);//Person{name='null', age=0, a='张三', b='null', c='null', d='李四'}


    }
}

获取构造方法们

Constructor<?>[]getConstructors()
constructor getConstructor(类<?>… parameterTypes)
constructor getDeclaredConstructor(类<?>… parameterTypes)
Constructor<?>[] getDeclaredConstructors()

public class ReflectDemo03 {
    public static void main(String[] args) throws Exception {
        //0、获取Person的class对象
        Class personClass = Person.class;
        //constructor<T> getConstructor(类<?>... parameterTypes)
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);//public cn.day18.domain.Person(java.lang.String,int)
        //创建对象newInstance
        Object o = constructor.newInstance("张三", 23);
        System.out.println(o);//Person{name='张三', age=23, a='null', b='null', c='null', d='null'}

        //使用空参构造器
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);//public cn.day18.domain.Person(java.lang.String,int)
        //创建对象newInstance
        Object o1 = constructor1.newInstance();
        System.out.println(o1);//Person{name='null', age=0, a='null', b='null', c='null', d='null'}
        //如果使用空参构造方法创建对象，操作是可以简化的
        Object o2 = personClass.newInstance();
        System.out.println(o2);//Person{name='null', age=0, a='null', b='null', c='null', d='null'}


    }
}

获取成员方法们
Method[] getMethods()
Method getMethod(string name,类<?>… parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name，类<?>… parameterTypes)

public class ReflectDemo04 {
    public static void main(String[] args) throws Exception {
        //0、获取Person的class对象
        Class personClass = Person.class;
        //获取指定名称的方法
        Method eat = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法，Object invoke(Object obj,Object... args)
         //因为对象p没有参数对象，所以实参对象传递p就行
        eat.invoke(p);//eat...

        //获取指定带有参数的方法
        Method eat1 = personClass.getMethod("eat", String.class);
        //执行方法
        eat1.invoke(p,"馒头");//eat...馒头

        //Method[] getMethods() 获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            String name = method.getName();
            //获取方法名：String getName
            System.out.println(name);

            //public java.lang.String cn.day18.domain.Person.getName()
            //getName
            //public java.lang.String cn.day18.domain.Person.toString()
            //toString
            //public void cn.day18.domain.Person.setName(java.lang.String)
            //setName
            //public void cn.itcast.day18.domain.Person.eat()
            //eat
            //public void cn.day18.domain.Person.eat(java.lang.String)
            //eat
            //public int cn.day18.domain.Person.getAge()
            //getAge
            //public void cn.day18.domain.Person.setAge(int)
            //setAge
            //public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
            //wait
            //public final void java.lang.Object.wait() throws java.lang.InterruptedException
            //wait
            //public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
            //wait
            //public boolean java.lang.Object.equals(java.lang.Object)
            //equals
            //public native int java.lang.Object.hashCode()
            //hashCode
            //public final native java.lang.Class java.lang.Object.getClass()
            //getClass
            //public final native void java.lang.Object.notify()
            //notify
            //public final native void java.lang.Object.notifyAll()
            //notifyAll
        }
        }

获取类名
String getName()

 //获取类名
        String name = personClass.getName();
        System.out.println(name);//cn.day18.domain.Person

案例

需求：写一个类“框架”,可以帮我们创建任意类的对象，并且执行其中的任意方法
我们之前使用的创建类，创建对象方法的弊端是：既然创建的类是一个框架，即为一个半成品，不允许修改的，所以不能改变该类任何代码，可以执行创建任意类的对象，可以执行任意方法。所以我们就需要使用反射完成这样的需求

框架类
实现：配置文件、反射
步骤：1、将需要创建的对象的全类名和需要执行的方法定义在配置文件中
2、在程序中加载读取配置文件，使用反射技术来加载类文件进内存
3、创建对象
4、执行方法

定义类

package cn.day18.domain;

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

    public String a;
    protected String b;
    String c;
    private String d;


    public Person() {
    }

    public Person(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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat(){
        System.out.println("eat...");
    }
    public void eat(String food){
        System.out.println("eat..." + food);
    }

}

配置文件

className = cn.day18.domain.Person
methodName = eat

测试类

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //不能改变该类任何代码，可以执行创建任意类的对象，可以执行任意方法
        //1、加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //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.getDeclaredConstructor().newInstance();
        //5、获取方法对象
        Method method = cls.getMethod(methodName);
        //6、执行方法
        method.invoke(obj);
    }
}

注解

概念：说明程序的，给计算机看的
注释：用文字表述程序。给程序员看的
注解（Annotation）,也叫元数据，一种代码级别的说明，他是JDK1.5及以后版本引入的一个特性，与类、接口、枚举、是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
作用：
1、编写文档：通过代码里标识的注解生成文档【生成文档doc】
2、代码分析：通过代码里标识的注解对代码进行分析【使用反射】
3、编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
JDK中预定义的一些注解
@Override：检测被该注解标注的方法是否是继承自父类（接口）的
@Deprecated：将该注解标注的内容以过时
@SuppressWarnings：压制警告

public class AnnoDemo2 {

    @Override
    public String toString() {
        return super.toString();
    }

    @Deprecated
    public void show1(){
        //有缺陷
    }
    @SuppressWarnings("all")
    public void show2(){
        //替代show2方法
    }
    public void demo(){
        show1();
    }
}

自定义注解

格式：元注解 public @interface MyAnno {}
本质：注解本质上就是一个接口，该接口默认继承Annotation接口
public interface MyAnno extends iava.lang.annotation.Annotation{}
属性：接口中的抽象方法
1、属性的返回值类型：基本数据类型，String，枚举，注解，以上类型的注解
2、定义了属性，在使用时需要给属性赋值。如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时可以不进行属性赋值；如果只有一个属性需要赋值，并且属性的名称时value，则value可以省略，直接定义值即可。
3、数组赋值需要使用{}包裹值，如果只有一个值，则大括号可以省略