文章目录
- 1. Junit 单元测试
- 1.1 Junit 单元测试概述
- 1.2 普通测试方法的缺点
- 1.3 Junit 使用：白盒测试
- 1.4 断言和 Before、After 注解
- 1.4.1 断言
- 1.4.2 Before、After 注解
- 1.4.3 实例代码
- 2. 注解
- 2.1 注解概念概述
- 2.2 JDK 中预定义的一些注解
- 2.3 自定义注解
- 2.3.1 格式：
- 2.3.2 注解本质
- 2.3.3 属性：接口中的抽象方法
- 2.3.4 元注解：用于描述注解的注解
- 2.4 在程序使用 (解析) 注解：获取注解中定义的属性值
- 2.5 案例：简单的测试框架
- 3. 模块化
- 3.1 模块化概述
- 3.2 模块的基本使用案例
- 3.3 模块服务的基本使用
1. Junit单元测试
1.1 Junit单元测试概述
- 测试分类：
1. 黑盒测试：不需要写代码（看不到代码），给输入值，看程序是否能够输出期望的值。
2. 白盒测试：需要写代码的。关注程序具体的执行流程。
1.2 普通测试方法的缺点
- 一个 main 方法只能测试一个方法，测试另一个方法需要注释掉其余方法，防止干扰。
- 测试类要和被测试类要放在同一个包内，不方便管理测试代码
public class CalculatorTest {
public static void main(String[] args) {
//创建对象
Calculator c = new Calculator();
//调用
/* int result = c.add(1, 2);
System.out.println(result);*/
int result = c.sub(1, 1);
System.out.println(result);
String str = "abc";
}
}/**
* 计算器类
*/
public class Calculator {
/**
* 加法
* @param a
* @param b
* @return
*/
public int add (int a , int b){
//int i = 3/0;
return a - b;
}
/**
* 减法
* @param a
* @param b
* @return
*/
public int sub (int a , int b){
return a - b;
}
}1.3 Junit使用：白盒测试
- 步骤：
- 定义一个测试类 (测试用例)
测试类名：被测试的类名 Test
例如： CalculatorTest
包名：xxx.xxx.xx.test
例如： cn.XXX.test - 定义测试方法：可以独立运行
方法名：test 测试的方法名 testAdd ()
返回值：void
参数列表：空参 - 给方法加 @Test，点击下一行的右边 run，该方法就能独立运行了
- 导入 junit 依赖环境，不用导包，直接 ctrl+1 提示 as junit4 classpath
* 判定结果（控制台左上角颜色）：
* 红色：失败
* 绿色：成功1.4 断言和Before、After注解
1.4.1 断言
- 一般不会输出结果自己判断代码逻辑，没有什么意义，采用代码来判断代码逻辑是否 ok
- 一般我们会使用断言操作来处理结果：
- Assert.assertEquals (期望的结果，运算的结果);
- 看期望的结果和运算结果是否相同，如果断言失败就是红色，表明代码有 bug，没有满足预期。如果是绿色则成功。
1.4.2 Before、After注解
* @Before:
* 修饰的方法会在测试方法之前被自动执行，一般应用与资源的申请
* @After:
* 修饰的方法会在测试方法执行之后自动被执行，一般应用与资源的释放
利用 Before、After注解 可以简化重复代码书写
即使代码报错，被Before、After修饰的方法也会执行1.4.3 实例代码
import cn.itcast.junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
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("我被执行了");
//1.创建计算器对象
System.out.println("testAdd...");
Calculator c = new Calculator();
//2.调用add方法
int result = c.add(1, 2);
//System.out.println(result);
//3.断言 我断言这个结果是3
Assert.assertEquals(3,result);
}
@Test
public void testSub(){
//1.创建计算器对象
Calculator c = new Calculator();
int result = c.sub(1, 2);
System.out.println("testSub....");
Assert.assertEquals(-1,result);
}
}2. 注解
2.1 注解概念概述
- 注解概念：说明程序的。给计算机看的
- 注释：用文字描述程序的。给程序员看的
- 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是 JDK1.5 及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
- 概念描述：
- JDK1.5 之后的新特性
- 说明程序的
- 使用注解：@注解名称
* 作用分类：
①编写文档：通过代码里标识的注解生成文档【生成文档doc文档（api）】
②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
2.2 JDK中预定义的一些注解
@Override ：检测被该注解标注的方法是否是继承自父类 (接口) 的方法，一种安全检查，若不是父类的方法 Override 会报错
@Deprecated：该注解标注的内容，表示已过时，会有横线。但是还是可以使用的，只是不推荐使用
@SuppressWarnings：压制警告，不显示警告
一般传递参数all @SuppressWarnings(“all”) 压制所有的警告
2.3 自定义注解
- 参考 jdk 的注解格式
2.3.1 格式：
元注解
public @interface 注解名称{
属性列表;
}2.3.2 注解本质
本质：通过反编译，注解本质上就是一个接口，该接口默认继承Annotation接口
public interface MyAnno extends java.lang.annotation.Annotation {}
- 定义一个注解，默认就继承了 Annotation 接口
2.3.3 属性：接口中的抽象方法
* 属性要求特点：
1. 属性的返回值类型有下列取值
* 基本数据类型
* String
* 枚举
* 注解
* 以上类型的数组
- 注解中不允许其他的返回类型抽象方法
2. 定义了属性，在使用时需要给属性赋值
1. 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
2. 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可，注意名称只能是value。
3. 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略public @interface MyAnno {
int value();
Person per();
MyAnno2 anno2();
String[] strs();
//若不想赋值，默认张三
String name() default "张三";
}// 注解的使用相当于属性，需要赋值
//@MyAnon(value=1,strs="ll")
@MyAnno(value=12,per = Person.P1,anno2 = @MyAnno2,strs={"bbb","aaa"})
public class Worker {
}
}2.3.4 元注解：用于描述注解的注解
* @Target：描述注解能够作用的位置
* ElementType取值：
* TYPE：表示注解可以作用于类上
* METHOD：表示注解可以作用于方法上
* FIELD：表示注解可以作用于成员变量上
* @Retention：描述注解被保留的阶段【Java程序运行的三个阶段】
* @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到，一般自定义注解都是设置RetentionPolicy.RUNTIME
* @Documented：描述注解是否被抽取到api文档中，会在api文档中体现
- 在Java文件目录下，打开控制台，输入 javadoc Worker.java 生成api文档
* @Inherited：描述注解是否被子类继承/**
元注解：用于描述注解的注解
* @Target：描述注解能够作用的位置
* @Retention：描述注解被保留的阶段
* @Documented：描述注解是否被抽取到api文档中
* @Inherited：描述注解是否被子类继承
*
*/
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
}2.4 在程序使用(解析)注解：获取注解中定义的属性值
- 注解大多数是用来替换配置文件的
- 案例：通过注解获取数据，利用反射运行中指定类的指定方法
- 重点：拿到注解配置的属性值
1. 获取注解定义的位置的对象 （Class，Method,Field）
2. 获取指定的注解
* getAnnotation(Class)
//其实就是在内存中生成了一个该注解接口的子类实现对象
public class ProImpl implements Pro{
public String className(){
return "cn.itcast.annotation.Demo1";
}
public String methodName(){
return "show";
}
}
3. 调用注解中的抽象方法获取配置的属性值/**
* 描述需要执行的类名，和方法名
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {
String className();
String methodName();
}@Pro(className = "cn.test.annotation.Demo1",methodName = "show")
public class ReflectTest {
public static void main(String[] args) throws Exception {
/*
前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
*/
//1.解析注解,拿到注解中配置的属性值
//1.1获取该类的字节码文件对象
Class<ReflectTest> reflectTestClass = ReflectTest.class;
//2.获取上边的注解对象
//其实就是在内存中生成了一个该注解接口的子类实现对象
/*
相当于如下
public class ProImpl implements Pro{
public String className(){
return "cn.test.annotation.Demo1";//返回注解配置的属性值
}
public String methodName(){
return "show";//返回注解配置的属性值
}
}
*/
Pro an = reflectTestClass.getAnnotation(Pro.class);
//3.调用注解对象中定义的抽象方法，获取返回值
String className = an.className();//调用的该注解接口的子类实现对象的方法
String methodName = an.methodName();
System.out.println(className);
System.out.println(methodName);
//3.加载该类进内存
Class cls = Class.forName(className);
//4.创建对象
Object obj = cls.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}2.5 案例：简单的测试框架
- 利用注解，测试 Calculator 计算器
/**
* 小明定义的计算器类
*/
public class Calculator {
//加法
@Check
public void add(){
String str = null;
str.toString();
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...");
}
}@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}/**
* 简单的测试框架
*
* 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中
*/
public class TestCheck {
public static void main(String[] args) throws IOException {
//1.创建计算器对象
Calculator c = new Calculator();
//2.获取字节码文件对象，因为我们期望等会能获取到Calculator所有的方法
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.newLine();
}
}
}
bw.write("本次测试一共出现 "+number+" 次异常");
bw.flush();
bw.close();
}
}* 小结：
1. 以后大多数时候，我们会使用注解，而不是自定义注解
2. 注解给谁用？
1. 编译器
2. 给解析程序用
3. 注解不是程序的一部分，可以理解为注解就是一个标签3. 模块化
3.1 模块化概述
- Java 语言随着这些年的发展已经成为了一门影响深远的编程语言，无数平台，系统都采用 Java 语言编写。但是，伴随着发展，Java 也越来越庞大，逐渐发展成为一门 “臃肿” 的语言。而且，无论是运行一个大型的软件系统，还是运行一个小的程序，即使程序只需要使用 Java 的部分核心功能， JVM 也要加载整个 JRE 环境。
- 为了给 Java “瘦身”，让 Java 实现轻量化，Java 9 正式的推出了模块化系统。Java 被拆分为 N 多个模块，并允许 Java 程序可以根据需要选择加载程序必须的 Java 模块，这样就可以让 Java 以轻量化的方式来运行
- 其实，Java 7 的时候已经提出了模块化的概念，但由于其过于复杂，Java 7，Java 8 都一直未能真正推出，直到 Java 9 才真正成熟起来。对于 Java 语言来说，模块化系统是一次真正的自我革新，这种革新使得 “古老而庞大” 的 Java 语言重新焕发年轻的活力
3.2 模块的基本使用案例
- 不同模块下的类不能用，即使导包也不行。
- 解决办法：在模块目录下新建一个名为 module-info.java 的描述性文件，该文件专门定义模块名，访问权限，模块依赖等信息，描述性文件中使用模块导出和模块依赖来进行配置并使用
- 模块中所有未导出的包都是模块私有的，他们不能在模块之外被访问的
- 一个模块要访问其他的模块，必须明确指定依赖那些模块，未明确的模块不能访问
- 要想跨越模块应用类，需要一个模块在其描述性文件中配置导出，另一个模块在其描述性文件配置中配置模块依赖。
- 模块导出格式：exports 包名；
- 模块依赖格式：requires 模块名；
- 注意：模块名报错，需要按下 Alt+Enter 提示，然后选择模块依赖
- 在项目中创建两个模块。一个是 myOne, 一个是 myTwo
- 在 myOne 模块中创建以下包和以下类，并在类中添加方法
package com.demo;
public class Student {
public void Student(){
System.out.println("好好学习天天向上");
}
}package com.demo02;
public class Teacher {
public void Teacher(){
System.out.println("教书育人");
}
}- 在 myTwo 模块中创建以下包和以下类，并在类中创建对象并使用
import com.demo.Student;
//import com.demo02.Teacher;
public class Test01 {
public static void main(String[] args) {
Student s = new Student();
s.study();
// Teacher t = new Teacher();
}
}- 在 myOne 模块中 src 目录下，创建 module-info.java，并写入以下内容
module myOne {
exports com.demo;
}- 在 myTwo 模块中 src 目录下，创建 module-info.java，并写入以下内容
module myTwo {
requires myOne;
}3.3 模块服务的基本使用
- 服务：从 Java6 开始 Java 提供了一种服务机制，允许服务提供者和服务使用者之间完成解耦，简单来说，就是服务使用者只面向接口编程，但不清楚服务提供者的实现类
- Java9 的模块化系统则进一步的简化了 Java 的服务机制。Java9 允许将服务定义在一个模块中，并使用 uses‘语句来声明服务接口，然后针对该服务接口提供不同的服务实现类，这些服务实现类可以分布在不同的模块中，服务实现模块则使用 provides 语句为服务接口实现类服务使用者只需要面向接口编程即可。
- 服务提供者需要提供具体的实现类，服务使用者只需要知道接口
- 在 myOne 模块中新建一个包，提供一个接口和两个实现类
package com.demo03;
public interface MyService {
void service();
}package com.demo03.impl;
import com.demo03.MyService;
public class Test02 implements MyService {
@Override
public void service() {
System.out.println("helloTest02" );
}
}import com.demo03.MyService;
public class Test implements MyService {
@Override
public void service() {
System.out.println("helloTest");
}
}- 在 myOne 模块中修改 module-info.java 文件，添加以下内容
module myOne {
exports com.demo01;
exports com.demo03;// 模块导出
// provides MyService with Test; 服务提供 指定MyService的服务实现类是Test
provides MyService with Test02;
}- 在 myTwo 模块中修改 module-info.java 文件，添加以下内容
module myTwo {
requires myOne;
//声明服务接口
uses MyService;//使用接口，并不知道该接口是那个包的，只知道接口接口名
}- 在 myTwo 模块中新建一个测试类，使用服务
- ServiceLoader: 一种加载服务实现的工具
import java.util.ServiceLoader;
public class Test02 {
public static void main(String[] args) {
//加载服务
ServiceLoader<MyService> myServices = ServiceLoader.load(MyService.class);
//遍历服务
for(MyService my : myServices) {
my.service();//输出helloTest
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
