关于java:JavaSE第24篇反射注解单元测试

外围概述：在前面的JavaWeb篇幅中，咱们将会学习到Web相干的框架，若想要更好的从底层了解框架，那么咱们不得不深刻学习Java的反射机制，本篇咱们将学习反射、注解、单元测试以及lombok插件的应用。

第一章：类的加载器

1.1-类的加载器介绍（理解）

什么是类加载器

类加载器（class loader）用来加载 Java 类到 Java 虚拟机。

类的加载器机会

创立类的实例。
类的动态变量，或者为动态变量赋值。
类的静态方法。
应用反射形式来强制创立某个类或接口对应的java.lang.Class对象。
初始化某个类的子类。
间接应用java.exe命令来运行某个主类。

以上6个状况，只有有1个呈现，那么类的加载器就会将这个类的class文件加载到内存中，咱们就能够应用这个类了。java.lang.ClassLoader：是类的加载器的父类。

加载器的品种

疏导类加载器BootstrapClassLoader。
扩大类加载器ExtClassLoader
利用类加载器AppClassLoader

1.2-疏导类加载器（理解）

疏导类加载器BootstrapClassLoader：是C++语言编写，负责加载JDK外围类库，外围类库地位jdkjrelib下的jar包。

因为疏导类加载器器在JVM外部，开发人员是不能间接操作的。

ClassLoader loader = String.class.getClassLoader();

程序的输入后果是null，C++编写的加载器，基本就不是Java中的类。

1.3-扩大类加载器（理解）

扩大类加载器ExtClassLoader：Java语言编写的类加载器，负责加载JDK扩大类库，类库地位jdklibext下的jar包。

ClassLoader loader = DNSNameService.class.getClassLoader();System.out.println(loader);

程序的输入后果是：sun.misc.Launcher$ExtClassLoader@45ee12a7，ExtClassLoader类继承URLClassLoader，URLClassLoader继承SecureClassLoader，SecureClassLoader继承ClassLoader。

1.4-利用类加载器（理解）

利用类加载器AppClassLoader：Java语言编写的类加载器，负责加载咱们定义的类和第三方jar包中的类。

ClassLoader loader = Test.class.getClassLoader();System.out.println(loader);

程序的输入后果是：sun.misc.Launcher$AppClassLoader@18b4aac2，AppClassLoader继承URLClassLoader，URLClassLoader继承SecureClassLoader，SecureClassLoader继承ClassLoader。

1.5-类加载器的双亲委派（理解）

ClassLoader类定义了办法 ClassLoader getParent()：返回父类加载器。

//获取本人定义类的加载器，后果为AppClassLoaderClassLoader loader = Test.class.getClassLoader();//获取AppClassLoader的父类加载器，后果为ExtClassLoaderSystem.out.println(loader.getParent());//获取ExtClassLoader的父类加载器，后果为nullSystem.out.println(loader.getParent().getParent());

论断： AppClassLoader的父类加载器是ExtClassLoader，ExtClassLoader的父类加载器是Bootstrap。

留神：ExtClassLoader是AppClassLoader的父加载器，并不是父类，他们没有继承关系。

谁用谁加载：当A类中应用了B类，那么负责加载A类的加载器要去加载B类。

双亲委派机制：当AppClassLoader收到一个加载类的申请时，会先让他的父类加载器ExtClassLoader尝试加载，ExtClassLoader也会让他的父类加载器Bootstrap尝试加载，如果Bootstrap能加载，就加载该类。如果Bootstrap不能加载，则ExtClassLoader会进行加载，如果也不能加载，AppClassLoader会进行加载。

1.6-Class对象的创立（理解）

当一个类的class文件被类加载器加载到内存后，类的加载器会创立出此class文件的对象。class文件的对象是Class类的对象，是反射技术的基石。

第二章：反射

2.1-什么是反射（理解）

Java反射机制指的是在Java程序运行状态中，对于任何一个类，都能够取得这个类的所有属性和办法；对于给定的一个对象，都可能调用它的任意一个属性和办法。这种动静获取类的内容以及动静调用对象的办法称为反射机制。

Java的反射机制容许编程人员在对类未知的状况下，获取类相干信息的形式变得更加多样灵便，调用类中相应办法，是Java减少其灵活性与动态性的一种机制。

2.2-获取Class对象的形式（重要）

获取形式

示例

Student类

public class Student {    private String name;    private int age;    public Student(){    }    public Student(String name,int age) {        this.name = name;        this.age = age;    }    public void study(){        System.out.println("学生在学习");    }    public void eat(String s,double d){        System.out.println("带参数办法:"+s+"::"+d);    }    public String toString() {        return "Student{" +                "name='" + name + '\'' +                ", age=" + age +                '}';    }}

获取Student类的class文件对象：

public static void main(String[] args)throws Exception{    Student student = new Student();     Class c1 = student.getClass();    System.out.println(c1);    Class c2 = Student.class;    System.out.println(c2);    Class c3 = Class.forName("com.it.communication.Student");    System.out.println(c3);}

2.3-反射获取构造方法（重要）

获取Constructor类的形式

形式1：Constructor[] getConstructors(),获取所有的public润饰的构造方法。

形式2：Constructor getConstructor(Class... parameterTypes) ，依据参数类型获取构造方法对象，只能取得public润饰的构造方法。如果不存在对应的构造方法，则会抛出 java.lang.NoSuchMethodException 异样。参数是可变参数,调用此办法时,能够不写参数,获取的空参结构。比方：

参数 String name,int age调用此办法: String.class,int.class

Constructor类罕用办法

T newInstance(Object... initargs) ，依据指定参数创建对象。
T newInstance()，空参构造方法创建对象。

获取无参数的构造方法

public static void main(String[] args)throws Exception{    Class cla = Class.forName("com.it.communication.Student");    //获取无参数构造方法    Constructor constructor = cla.getConstructor();    //运行构造方法    Object object =  constructor.newInstance();    System.out.println(object);}

获取有参构造方法

public static void main(String[] args)throws Throwable{    Class cla = Class.forName("com.it.communication.Student");    //获取有参数构造方法    Constructor constructor = cla.getConstructor(String.class, int.class);    //运行构造方法，传递理论参数    Object object = constructor.newInstance("张三",20);    System.out.println(object);}

反射获取构造方法的简略形式

Class类中定义了办法 T newInstance()，能够间接运行获取到的构造方法。

要求：被反射的类中必须有public权限的无参数构造方法。

public static void main(String[] args)throws Throwable{    Class cla = Class.forName("com.it.communication.Student");    Object object = cla.newInstance();    System.out.println(object);}

2.4-反射获取成员办法（重要）

获取Method的形式

形式1： Method[] getMethods()，获取所有的public润饰的成员办法，包含父类中的办法。

形式2：Method getMethod("办法名", 办法的参数类型... 类型) ，依据办法名和参数类型取得一个办法对象，只能是获取public润饰的

Method类中罕用办法

办法：Object invoke(Object obj, Object... args)

返回值Object，示意调用办法后，该办法的返回值
依据参数args调用对象obj的该成员办法
如果obj=null，则示意该办法是静态方法

反射获取无参数办法

public static void main(String[] args)throws Throwable{    Class cla = Class.forName("com.it.communication.Student");    Object object = cla.newInstance();    //获取study办法    Method method = cla.getMethod("study");    //执行办法，传递对象    method.invoke(object);}

反射获取有参数办法

public static void main(String[] args)throws Throwable{    Class cla = Class.forName("com.it.communication.Student");    Object object = cla.newInstance();    //获取有参数的办法eat    Method method = cla.getMethod("eat",String.class,double.class);    //调用eat办法，传递理论参数    method.invoke(object,"吃饭",9.9);}

2.5-反射案例（练习）

需要

本案例目标，体验反射的灵活性。

需要：写一个"框架"，不能扭转该类的任何代码的前提下，能够帮咱们创立任意类的对象，并且执行其中任意办法。

实现形式和步骤

实现形式：配置文件 + 反射

实现步骤：

将须要创立的对象的全类名和须要执行的办法定义在配置文件中
在程序中加载读取配置文件
应用反射技术来加载类文件进内存
创建对象
执行办法

留神：须要将配置文件放在src目录下，放在src目录下的任何文件，都会被编译到classes目录下，这样做的目标是为了让配置文件追随编译后的class文件一起，因为交付用户应用的是class文件，而不是源代码。

如何读取src目录下的文件：应用类的加载器ClassLoader类的办法 :InputStream getResourceAsStream(String name)

此办法返回输出流，该流从类目录下读取文件
参数传递文件名

配置文件

properties文件：pro.properties

className=com.it.domain.StudentmethodName=sleep

学生类

Student类

package com.it.domain;public class Student {    public void sleep(){        System.out.println("sleep...");    }}

反射测试类

RefectTest类

public static void main(String[] args)throws Throwable{    //获取RefectTest类的加载器    ClassLoader classLoader = RefectTest.class.getClassLoader();    //加载器获取输出流，读取pro.properties文件    InputStream inputStream = classLoader.getResourceAsStream("pro.properties");    Properties properties = new Properties();    //汇合IO关联    properties.load(inputStream);    //获取汇合中的键值对，类名    String className = properties.getProperty("className");    //获取汇合中的键值对，办法名    String methodName = properties.getProperty("methodName");    //反射获取指定类的class文件对象    Class cla = Class.forName(className);    Object object = cla.newInstance();    //获取指定的办法    Method method = cla.getMethod(methodName);    //运行办法    method.invoke(object);}

第三章：单元测试

3.1-测试分类（理解）

黑盒测试：不须要写代码，给输出值，看程序是否可能输入冀望的值。
白盒测试：须要写代码的。关注程序具体的执行流程。

3.2-Junit（理解）

概述

Junit是一个Java语言的单元测试框架，属于白盒测试，简略了解为能够用于取代java的main办法。Junit属于第三方工具，须要导入jar包后应用。

jar包下载

链接：https://pan.baidu.com/s/1XO4T...
提取码：cmcq

应用步骤

步骤：

编写测试类，简略了解Junit能够用于取代java的main办法。
在测试类办法上增加注解 @Test。
@Test润饰的办法要求：public void 办法名() {…} ，办法名自定义倡议test结尾，没有参数。
增加Junit库到lib文件夹中，而后进行jar包关联。

应用：点击办法左侧绿色箭头，执行以后办法（办法必须标记@Test）。执行后果红色：代表失败；执行后果绿色：代表胜利。

哪个办法想应用单元测试,就在办法上,增加注解: @Test

留神:

该办法的返回值类型,必须写为void
该办法必须没有参数列表

运行:

办法上右键运行,运行的是含有@Test注解的办法
类上右键运行,运行的是类当中含有@Test注解的所有办法
绿条: 失常运行
红条: 呈现问题,异样了

罕用注解

@Test，用于润饰须要执行的测试方法。
@Before，润饰的办法会在测试方法之前被主动执行。
@After，润饰的办法会在测试方法执行之后主动被执行。

第四章：注解

4.1-概述（理解）

什么是注解

注解（Annotation），也叫元数据。一种代码级别的阐明。它是JDK1.5及当前版本引入的一个个性，与类、接口、枚举是在同一个档次。它能够申明在包、类、字段、办法、局部变量、办法参数等的后面，用来对这些元素进行阐明，正文。

注解的作用

编写文档：通过代码里标识的注解生成文档【例如，生成文档doc文档】
代码剖析：通过代码里标识的注解对代码进行剖析【例如，注解的反射】
编译查看：通过代码里标识的注解让编译器可能实现根本的编译查看【例如，Override】

常见注解

@author：用来标识作者名
@version：用于标识对象的版本号，适用范围：文件、类、办法。
@Override ：用来润饰办法申明，通知编译器该办法是重写父类中的办法，如果父类不存在该办法，则编译失败。

4.2-自定义注解（重要）

定义格局

元注解

public @interface 注解名称{    属性列表;}

注解实质上就是一个接口，该接口默认继承Annotation接口。

public @interface MyAnno extends java.lang.annotation.Annotation {}

任何一个注解，都默认的继承Annotation接口。

注解的属性

属性的作用：能够让用户在应用注解时传递参数，让注解的性能更加弱小。

属性的格局：

格局1：数据类型属性名();
格局2：数据类型属性名() default 默认值;

示例

public @interface Student {  String name(); // 姓名  int age() default 18; // 年龄  String gender() default "男"; // 性别} // 该注解就有了三个属性：name，age，gender

属性实用的数据类型

八种根本数据类型（int,float,boolean,byte,double,char,long,short)。
String类型，Class类型，枚举类型，注解类型。
以上所有类型的一维数组。

4.3-应用自定义注解（重要）

在程序中应用(解析)注解的步骤（获取注解中定义的属性值)

获取注解定义的地位的对象（Class，Method,Field）
获取指定的注解 getAnnotation(Class)
调用注解中的形象办法获取配置的属性值

应用格局

@注解名(属性名=属性值,属性名=属性值,属性名=属性值...)

示例

首先，定义一个注解Book

蕴含属性：String value() 书名
蕴含属性：double price() 价格，默认值为 100
蕴含属性：String[] authors() 多位作者

代码实现

public @interface Book {    // 书名    String value();    // 价格    double price() default 100;    // 多位作者    String[] authors();}

应用注解

/** * @author itleilei * @version 1.0 */public class BookShelf {      @Book(value = "西游记",price = 998,authors = {"吴承恩","白求恩"})    public void showBook(){    }}

注意事项

如果属性有默认值，则应用注解的时候，这个属性能够不必赋值。
如果属性没有默认值，那么在应用注解时肯定要给属性赋值。

非凡属性Value

当注解中只有一个属性且名称是value，在应用注解时给value属性赋值能够间接给属性值，无论value是单值元素还是数组类型。

// 定义注解Bookpublic @interface Book {    // 书名    String value();}// 应用注解Bookpublic class BookShelf {    @Book("西游记")    public void showBook(){    }}或public class BookShelf {    @Book(value="西游记")    public void showBook(){    }}

如果注解中除了value属性还有其余属性，且至多有一个属性没有默认值，则在应用注解给属性赋值时，value属性名不能省略。

// 定义注解Bookpublic @interface Book {    // 书名    String value();    // 价格    double price() default 100;    // 多位作者    String[] authors();}// 应用Book注解：正确形式@Book(value="红楼梦",authors = "曹雪芹")public class BookShelf {  // 应用Book注解：正确形式    @Book(value="西游记",authors = {"吴承恩","白求恩"})    public void showBook(){    }}// 应用Book注解：谬误形式public class BookShelf {    @Book("西游记",authors = {"吴承恩","白求恩"})    public void showBook(){    }}// 此时value属性名不能省略了。

4.4-注解之元注解（重要）

概述

默认状况下，注解能够用在任何中央，比方类，成员办法，构造方法，成员变量等中央。如果要限度注解的应用地位怎么办？那就要学习一个新的知识点：元注解。

@Target
@Retention

元注解之@Target

作用：指明此注解用在哪个地位，如果不写默认是任何中央都能够应用。

可选的参数值在枚举类ElemenetType中包含：

 TYPE： 用在类,接口上 FIELD：用在成员变量上 METHOD： 用在办法上 PARAMETER：用在参数上 CONSTRUCTOR：用在构造方法上 LOCAL_VARIABLE：用在局部变量上

元注解之@Retention

作用：定义该注解的生命周期(无效范畴)。

可选的参数值在枚举类型RetentionPolicy中包含

SOURCE：注解只存在于Java源代码中，编译生成的字节码文件中就不存在了。CLASS：注解存在于Java源代码、编译当前的字节码文件中，运行的时候内存中没有，默认值。RUNTIME：注解存在于Java源代码中、编译当前的字节码文件中、运行时内存中，程序能够通过反射获取该注解。

4.5-注解解析（重要）

通过Java技术获取注解数据的过程则称为注解解析。

与注解解析相干的接口

Anontation：所有注解类型的公共接口，相似所有类的父类是Object。
AnnotatedElement：定义了与注解解析相干的办法，罕用办法以下四个：

boolean isAnnotationPresent(Class annotationClass); 判断以后对象是否有指定的注解，有则返回true，否则返回false。T getAnnotation(Class<T> annotationClass);  取得以后对象上指定的注解对象。Annotation[] getAnnotations(); 取得以后对象及其从父类上继承的所有的注解对象。Annotation[] getDeclaredAnnotations();取得以后对象上所有的注解对象，不包含父类的。

获取注解数据的原理

注解作用在那个成员上，就通过反射取得该成员的对象来失去它的注解。

如注解作用在办法上，就通过办法(Method)对象失去它的注解。

 // 失去办法对象 Method method = clazz.getDeclaredMethod("办法名");  // 依据注解名失去办法上的注解对象 Book book = method.getAnnotation(Book.class);

如注解作用在类上，就通过Class对象失去它的注解。

// 取得Class对象Class c = 类名.class;// 依据注解的Class取得应用在类上的注解对象Book book = c.getAnnotation(Book.class);

应用反射获取注解的数据

需要阐明：

定义注解Book，要求如下：
- 蕴含属性：String value() 书名
- 蕴含属性：double price() 价格，默认值为 100
- 蕴含属性：String[] authors() 多位作者
- 限度注解应用的地位：类和成员办法上
- 指定注解的无效范畴：RUNTIME
定义BookStore类，在类和成员办法上应用Book注解
定义TestAnnotation测试类获取Book注解上的数据

代码实现：

注解Book

@Target({ElementType.METHOD,ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)public @interface Book {    // 书名    String value();    // 价格    double price() default 100;    // 作者    String[] authors();}

BookStore类

@Book(value = "红楼梦",authors = "曹雪芹",price = 998)public class BookStore {}

测试类TestAnnotation类

public class TestAnnotation {    public static void main(String[] args)  throws Exception{        System.out.println("---------获取类上注解的数据----------");        test();    }    /**     * 获取BookStore类上应用的Book注解数据     */    public static void test(){        // 取得BookStore类对应的Class对象        Class c = BookStore.class;        // 判断BookStore类是否应用了Book注解        if(c.isAnnotationPresent(Book.class)) {            // 依据注解Class对象获取注解对象            Book book = (Book) c.getAnnotation(Book.class);            // 输入book注解属性值            System.out.println("书名：" + book.value());            System.out.println("价格：" + book.price());            System.out.println("作者：" + Arrays.toString(book.authors()));        }}

4.6-模仿Junit（重要）

案例剖析

模仿Junit测试的正文@Test，首先须要编写自定义注解@MyTest，并增加元注解，保障自定义注解只能润饰办法，且在运行时能够取得。
而后编写指标类（测试类），而后给指标办法（测试方法）应用 @MyTest注解，编写三个办法，其中两个加上@MyTest注解。
最初编写调用类，应用main办法调用指标类，模仿Junit的运行，只有有@MyTest正文的办法都会运行。

代码实现

注解MyTest

@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)public @interface MyTest {}

MyTestDemo

public class MyTestDemo {    @MyTest    public void test01(){        System.out.println("test01");    }    public void test02(){        System.out.println("test02");    }    @MyTest    public void test03(){        System.out.println("test03");    }}

测试类

public class TestMyTest {    public static void main(String[] args) throws  Exception{        // 取得MyTestDemo类Class对象        Class c = MyTestDemo.class;        // 取得所有的成员办法对象        Method[] methods = c.getMethods();        // 创立MyTestDemo类对象        Object obj = c.newInstance();        // 遍历数组        for (Method m:methods) {            // 判断办法m上是否应用注解MyTest            if(m.isAnnotationPresent(MyTest.class)){                // 执行办法m                m.invoke(obj);            }        }    }}

第五章：lombok

5.1-概述

Lombok通过减少一些“处理程序”，能够让java变得简洁、疾速。

Lombok能以注解模式来简化java代码，进步开发效率。开发中常常须要写的javabean，都须要花工夫去增加相应的getter/setter，兴许还要去写结构器、equals等办法，而且须要保护。

Lombok能通过注解的形式，在编译时主动为属性生成结构器、getter/setter、equals、hashcode、toString办法。呈现的神奇就是在源码中没有getter和setter办法，然而在编译生成的字节码文件中有getter和setter办法。这样就省去了手动重建这些代码的麻烦，使代码看起来更简洁些。

5.2-应用

增加lombox的jar包：lombok-1.18.8.jar

链接：https://pan.baidu.com/s/1b5-W...
提取码：ij77

IDE中装置lombox插件

搜寻

下载安装

重启IDE，并设置注解配置

5.3-lombok罕用注解

@Getter和@Setter

作用：生成成员变量的get和set办法。
写在成员变量上，指对以后成员变量无效。
写在类上，对所有成员变量无效。
留神：动态成员变量有效。

@toString

作用：生成toString()办法。
注解只能写在类上。

@NoArgsConstructor和@AllArgsConstructor

@NoArgsConstructor：无参数构造方法。
@AllArgsConstructor：满参数构造方法。
注解只能写在类上。

@EqualsAndHashCode

作用：生成hashCode()和equals()办法。
注解只能写在类上。

@Data

作用：生成get/set，toString，hashCode，equals，无参构造方法
注解只能写在类上。