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 小结
多数情况下,我们会使用注解,但不是自定义注解。注解是给编译器和解析程序用的。注解不是程序的一部分,可以理解为注解就是一个标签。