Java单元测试和类加载
Java单元测试和类加载
回顾：
1 Lambda表达式：相等于匿名内部类，实现代码作为方法的参数传统。
函数式接口 变量=(参数列表)->{
方法体
};
注意： ->操作符 分成两部分
左侧：（参数列表）
右侧: 方法体
1 左侧的类型可以省略，类型推断
2 左侧没有参数，写一个（）
3 左侧有一个参数, （）可以省略
4 右侧如果只有一条语句,可以省略{}，如果有返回值，只有一条语句，return省略，如果有多条语句，必须写{}
5 Labmda表达式没有生成内部类
6 访问局部变量，加上final
函数式接口：只有一个抽象方法
Consumer 消费型 有参数没有返回值
Supplier 供给型 没有参数有返回值
Function 函数型 有参数有返回值
Predicate 断言型 有参数 返回值boolean
2 方法引用： 如果方法体中只调用一条语句，可以使用方法引用
对象::实例方法
System.out::println
类名::静态方法
Integer:compare
类名::实例方法
String::equals
Employee::getName
类名::new 创建对象
Employee::new
数组引用
String[]::new
3 Stream API
流：包含对集合和数组的操作
三步
1 创建流
Stream.of()
Arrays.stream()
集合的.stream()
Stream.iterate()
Stream.generate();
2 中间操作
filter 排除不满足条件数据
limit 限制
skip 跳过
distinct 去重复
map 映射
3 终止操作
forEach();
allMatch()
anyMatch()
noneMath();
findFirst();
findAny();
count();
reduce() 归约
collect() 收集
时间和日期
LocalDate
LocalTime
LocalDateTime
Instant 时间时刻
时间矫正器
时间格式化
DateTimeFormatter
今天任务
1.单元测试
2.注解
3.类加载器
教学目标
1.掌握单元测试
2.掌握注解
3.理解类加载器
第一节：单元测试
1.1 什么是软件测试
软件测试是程序的一种执行过程，目的是尽可能发现并改正被测试软件中的错误，提高软件的可靠性。
1.2 测试分类
按照是否知道源代码
黑盒测试：不关心具体的逻辑代码，只测功能
白盒测试：测试逻辑代码
灰盒测试
从软件开发的过程
单元测试Unit Testing
集成测试Integrated Testing
系统测试System Testing
根据测试的次数
冒烟测试
压力测试
1.3 Junit单元测试
Junit是一个基于Java语言的单元测试框架。是白盒测试的一种技术。
演示测试1
public class Operation {
public int add(int x,int y) {
return x^y;
}
public int sub(int x,int y) {
return x-y;
}
}
public class OperationTest {
@Test
public void testAdd() {
Operation operation=new Operation();
int result=operation.add(20, 30);
System.out.println(result);
Assert.assertEquals(50, result);
}
@Test
public void testSub() {
Operation operation=new Operation();
int result=operation.sub(10,5);
System.out.println(result);
}
}
演示测试2
有一个学生类StudentDao，添加测试类
public class StudentDao {
public void add() {
System.out.println("添加学生");
}
public void update() {
System.out.println("更新学生");
}
}
public class StudentDaoTest {
@BeforeClass
public static void setUpBeforeClass() throws Exception {
System.out.println("测试类执行之前。。。。。。。。。");
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
System.out.println("测试类执行之后。。。。。。。。。");
}
@Before
public void setUp() throws Exception {
System.out.println("方法之前执行........");
}
@After
public void tearDown() throws Exception {
System.out.println("方法之后执行........");
}
@Test
public void test() {
System.out.println("测试方法");
}
@Test
public void test2() {
System.out.println("测试方法2");
}
@Test
public void testAdd() {
StudentDao studentDao=new StudentDao();
studentDao.add();
}
@Test
public void testUpdate() {
StudentDao studentDao=new StudentDao();
studentDao.update();
}
}
注意：
①测试方法上必须使用@Test进行修饰
②测试方法必须使用public void 进行修饰，不能带任何的参数
③新建一个源代码目录来存放我们的测试代码，即将测试代码和项目业务代码分开
④测试类所在的包名应该和被测试类所在的包名保持一致
⑤测试单元中的每个方法必须可以独立测试，测试方法间不能有任何的依赖
⑥测试类使用Test作为类名的后缀（不是必须）
⑦测试方法使用test作为方法名的前缀（不是必须）
第二节：注解
注释：给代码添加说明和解释，注释帮助开发人员理解程序。（Comment）
注解：给代码添加说明,这个说明给程序使用。
从 JDK 5.0 开始,Java 增加了对元数据(MetaData) 的支持, 也就是Annotation(注解)。
三个基本的 Annotation:
@Override:限定重写父类方法, 该注解只能用于方法
@Deprecated:用于表示某个程序元素(类, 方法等)已过时
@SuppressWarnings: 抑制编译器警告.
什么是注解
Annotation其实就是代码里的特殊标记, 它用于替代配置文件，也就是说，传统方式通过配置文件告诉类如何运行，有了注解技术后，开发人员可以通过注解告诉类如何运行。在Java技术里注解的典型应用是：可以通过反射技术去得到类里面的注解，以决定怎么去运行类。
注解技术的要点：
如何定义注解
如何反射注解，并根据反射的注解信息，决定如何去运行类
2.1自定义注解：
定义新的 Annotation 类型使用@interface关键字
声明注解的属性
注解属性的作用：原来写在配置文件中的信息，可以通过注解的属性进行描述。
Annotation的属性声明方式：Stringname();
属性默认值声明方式：Stringname() default “xxx”;
特殊属性value：如果注解中有一个名称value的属性，那么使用注解时可以省略value=部分，如@MyAnnotation(“xxx")
特殊属性value[];
注解属性的类型可以是：
String类型
基本数据类型
Class类型
枚举类型
注解类型
以上类型的一维数组
案例演示1 创建和使用注解
public @interface MyAnnocation {
String name();
int num() default 10;
MyAnnocation2 anno();
}
public @interface MyAnnocation2 {
String value();
}
public class Demo1 {
@MyAnnocation(name="哈哈",num=50,anno=@MyAnnocation2(value = "xxx"))
public void show() {
System.out.println("xxxxxxx");
}
}
2.2 JDK的元 Annotation
元 Annotation指修饰Annotation的Annotation。
@Retention: 只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 可以保留的域, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 通过这个变量指定域。
RetentionPolicy.CLASS: 编译器将把注解记录在 class文件中. 当运行 Java 程序时, JVM 不会保留注解. 这是默认值
RetentionPolicy.RUNTIME:编译器将把注解记录在 class文件中. 当运行 Java 程序时, JVM 会保留注解. 程序可以通过反射获取该注释
RetentionPolicy.SOURCE: 编译器直接丢弃这种策略的注释
@Target：指定注解用于修饰类的哪个成员.@Target 包含了一个名为value，类型为ElementType的成员变量。
@Documented:用于指定被该元 Annotation 修饰的Annotation类将被 javadoc 工具提取成文档。
@Inherited:被它修饰的 Annotation 将具有继承性.如果某个类使用了被 @Inherited 修饰的Annotation,则其子类将自动具有该注解。
案例演示2 使用反射获取注解信息
@Retention(RetentionPolicy.RUNTIME)
public @interface PersonInfo {
String name();
int age() default 20;
String gender();
}
public class PersonOpe {
@PersonInfo(name="李四",age=20,gender="男")
public void show(String name,int age,String gen) {
System.out.println(name);
System.out.println(age);
System.out.println(gen);
}
}
public class Demo2 {
public static void main(String[] args) throws Exception{
PersonOpe ope=new PersonOpe();
Class<?> class1=PersonOpe.class;
Method method = class1.getMethod("show", String.class,int.class,String.class);
PersonInfo annotation = method.getAnnotation(PersonInfo.class);
String name=annotation.name();
int age=annotation.age();
String gender=annotation.gender();
method.invoke(ope, name,age,gender);
}
}
第三节：类加载器
Java类加载器（Java Classloader）是Java运行时环境（Java Runtime Environment）的一部分，负责动态加载Java类到Java虚拟机的内存空间中。
类通常是按需加载，即第一次使用该类时才加载。由于有了类加载器，Java运行时系统不需要知道文件与文件系统。
JVM中有3个默认的类加载器：
-
引导（Bootstrap）类加载器。由原生代码（如C语言）编写，不继承自java.lang.ClassLoader。负责加载核心Java库，存储在
/jre/lib目录中。 -
扩展（Extensions）类加载器。用来在
/jre/lib/ext,或java.ext.dirs中指明的目录中加载 Java的扩展库。Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。该类由sun.misc.Launcher$ExtClassLoader实现。 -
Apps类加载器（也称系统类加载器）。根据 Java应用程序的类路径（java.class.path或CLASSPATH环境变量）来加载 Java 类。一般来说，Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()来获取它。该类由sun.misc.Launcher$AppClassLoader实现。
这三个类装载器存在父子层级关系，即根装载器是ExtClassLoader的父装载器，ExtClassLoader是AppClassLoader的父装载器。默认情况下使用AppClassLoader装载应用程序的类。
public class Test{
Public static void main(String[] arg){
ClassLoader c = Test.class.getClassLoader(); //获取Test类的类加载器
System.out.println(c);
ClassLoader c1 = c.getParent(); //获取c这个类加载器的父类加载器
System.out.println(c1);
ClassLoader c2 = c1.getParent();//获取c1这个类加载器的父类加载器
System.out.println(c2);
}
}
3.1类加载过程
每个编写的”.java”拓展名类文件都存储着需要执行的程序逻辑，这些”.java”文件经过Java编译器编译成拓展名为”.class”的文件，”.class”文件中保存着Java代码经转换后的虚拟机指令，当需要使用某个类时，虚拟机将会加载它的”.class”文件，并创建对应的class对象，将class文件加载到虚拟机的内存，这个过程称为类加载，这里我们需要了解一下类加载的过程，如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SoNgkVA9-1575685440937)(图片\02.png)]
- 加载：类加载过程的一个阶段：通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象
- 验证：目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。
- 准备：为类变量(即static修饰的字段变量)分配内存并且设置该类变量的初始值即0(如static int i=5;这里只将i初始化为0，至于5的值将在初始化时赋值)，这里不包含用final修饰的static，因为final在编译的时候就会分配了，注意这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。
- 解析：主要将常量池中的符号引用替换为直接引用的过程。符号引用就是一组符号来描述目标，可以是任何字面量，而直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。有类或接口的解析，字段解析，类方法解析，接口方法解析(这里涉及到字节码变量的引用，如需更详细了解，可参考《深入Java虚拟机》)。
- 初始化：类加载最后阶段，若该类具有超类，则对其进行初始化，执行静态初始化器和静态初始化成员变量(如前面只初始化了默认值的static变量将会在这个阶段赋值，成员变量也将被初始化)。
3.2 双亲委托模式
Java装载类使用“全盘负责委托机制”。“全盘负责”是指当一个ClassLoder装载一个类时，除非显示的使用另外一个ClassLoder，该类所依赖及引用的类也由这个ClassLoder载入；“委托机制”是指先委托父类装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。这一点是从安全方面考虑的，试想如果一个人写了一个恶意的基础类（如java.lang.String）并加载到JVM将会引起严重的后果，但有了全盘负责制，java.lang.String永远是由根装载器来装载，避免以上情况发生 除了JVM默认的三个ClassLoder以外，第三方可以编写自己的类装载器，以实现一些特殊的需求。
为什么要使用这种双亲委托模式呢？
因为这样可以避免重复加载，当父亲已经加载了该类的时候，就没有必要子ClassLoader再加载一次。
考虑到安全因素，我们试想一下，如果不使用这种委托模式，那我们就可以随时使用自定义的String来动态替代java核心api中定义类型，这样会存在非常大的安全隐患，而双亲委托的方式，就可以避免这种情况，因为String已经在启动时被加载，所以用户自定义类是无法被加载。
演示错误
创建java.lang包并创建String类。
双亲委派模式工作原理
双亲委派模式要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器，请注意双亲委派模式中的父子关系并非通常所说的类继承关系，而是采用组合关系来复用父类加载器的相关代码，类加载器间的关系如下。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TBburOWz-1575685440938)(图片\01.png)]
双亲委派模式是在Java 1.2后引入的，其工作原理的是，如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成，这不就是传说中的实力坑爹啊。
3.3 使用类加载器加载属性文件
使用类加载器加载属性文件。
案例1：Properties加载属性文件
InputStream is = Test.class.getClassLoader().getResourceAsStream("user.properties");
Properties properties=new Properties();
properties.load(new InputStreamReader(is, "utf-8"));
properties.list(System.out);
案例2：使用ResourceBundle加载属性文件
//不用带扩展名
ResourceBundle bundle = ResourceBundle.getBundle("com.qf.day19.user");
//解决中文乱码问题
System.out.println(new String(bundle.getString("name").getBytes("iso-8859-1"),"utf-8"));
System.out.println(bundle.getString("age"));
System.out.println(new String(bundle.getString("gender").getBytes("iso-8859-1"),"utf-8"));
注意：属性文件默认编码为ISO-88590-1,如果修改为utf-8需要代码中处理乱码问题。