反射与注解
一、Junit单元测试
测试分类
- 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值
- 白盒测试：需要写代码的。关注程序具体的执行流程
- Junit使用白盒测试
测试步骤
-
定义一个测试类(测试用例)
- 测试类名：
被测试的类名Test如CalculatorTest - 包名：
xxx.xxx.xx.test
- 测试类名：
-
定义测试方法：可以独立运行（下为建议）
- 方法名：
test测试的方法名 - 返回值：void
- 参数列表：空参
- 方法名：
-
给方法加
@Test- 注意导入junit
-
结果：
- 红色：失败
- 绿色：成功
- 一般我们会使用断言操作来处理结果
- Assert.assertEquals(期望的结果,运算的结果);
-
补充：
- @Before:
- 修饰的方法会在测试方法之前被自动执行
- @After:
- 修饰的方法会在测试方法执行之后自动被执行
- @Before:
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;
}
}
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);
}
}
二、反射
反射是框架设计的灵魂
反射是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
Class c = Class.forName("java.lang.String")
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，因此我们形象的称之为：反射
1. 使用的前提条件
必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）
2. 概述
JAVA反射机制
- 是在运行状态中，对于任意一个类都能够知道这个类的所有属性和方法；
- 对于任意一个对象，都能够调用它的任意一个方法和属性；
- 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
可以这样理解：
- 框架：被称为半成品软件。可以在框架的基础上进行软件开发，简化编码
- 反射：反射就是把java类中的各种成分映射成一个个的Java对象
- 例如：一个类有成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象
- 优点：
- 可以在程序运行过程中，操作这些对象
- 可以解耦，提高程序的可扩展性
- 缺点：
- 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的 java 代码要慢很多
- 安全问题：让我们可以动态操作改变类的属性同时也增加了类的安全隐患
- Java反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
- .............
- 反射相关的主要API
- java.lang.Class : 代表一个类
- java.lang.reflect.Method : 代表类的方法
- java.lang.reflect.Field : 代表类的成员变量
- java.lang.reflect.Constructor : 代表类的构造器
2. Class类
Java的Class类是java反射机制的基础，通过Class类我们可以获得关于一个类的相关信息
Java.lang.Class是一个比较特殊的类，它用于封装被装入到JVM中的类（包括类和接口）的信息。当一个类或接口被装入的JVM时便会产生一个与之关联的java.lang.Class对象，可以通过这个Class对象对被装入类的详细信息进行访问。
虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。
一个类被加载到内存并供我们使用需要经历如下三个阶段
- 加载，这是由类加载器（ClassLoader）执行的。通过一个类的全限定名来获取其定义的二进制字节流（Class字节码），将这个字节流所代表的静态存储结构转化为方法去的运行时数据接口，根据字节码在java堆中生成一个代表这个类的java.lang.Class对象
- 链接。在链接阶段将验证Class文件中的字节流包含的信息是否符合当前虚拟机的要求，为静态域分配存储空间并设置类变量的初始值（默认的零值），并且如果必需的话，将常量池中的符号引用转化为直接引用
- 初始化。到了此阶段，才真正开始执行类中定义的java程序代码。用于执行该类的静态初始器和静态初始块，如果该类有父类的话，则优先对其父类进行初始化
所有的类都是在对其第一次使用时，动态加载到JVM中的（懒加载）。当程序创建第一个对类的静态成员的引用时，就会加载这个类。使用new创建类对象的时候也会被当作对类的静态成员的引用。因此java程序程序在它开始运行之前并非被完全加载，其各个类都是在必需时才加载的。这一点与许多传统语言都不同。动态加载使能的行为，在诸如C++这样的静态加载语言中是很难或者根本不可能复制的
- 静态编译： 在编译时确定类型，绑定对象
- 动态编译： 运行时确定类型，绑定对象
在类加载阶段，类加载器首先检查这个类的Class对象是否已经被加载。如果尚未加载，默认的类加载器就会根据类的全限定名查找.class文件。在这个类的字节码被加载时，它们会接受验证，以确保其没有被破坏，并且不包含不良java代码。一旦某个类的Class对象被载入内存，我们就可以它来创建这个类的所有对象
3. 获取Class对象
如果我们动态获取到这些信息，则需要依靠 Class 对象。Class 类对象将一个类的方法、变量等信息告诉运行的程序
Class.forName("全类名")：将字节码文件加载进内存，返回Class对象- 一般是不知道具体类时，都是通过遍历包下面的类来获取 Class 对象【常用】
- 对应Source源代码阶段
- 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
类名.class：通过类名的属性class获取- 知道具体类的情况下可以使用
- 对应Class类阶段
- 多用于参数的传递
- 该方法最为安全可靠，程序性能最高
对象.getClass()：getClass()方法在Object类中定义着- 对应运行时候阶段
- 多用于对象的获取字节码的方式
- 对应运行时候阶段
三种方式常用第一种，一个字符串可以传入也可写在配置文件中等多种方法。第二种需要导入类的包，依赖太强，不导包就抛编译错误。第三种有对象可不用反射。
- 结论：
- 同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。
package cn.itcast.domain;
public class Person {
private String name;
private int age;
public String a;
protected String b;
String c;
private String d;
//省略getter、setter方法(name,age)，构造方法(name,age)，toString方法(所有)
public void eat(){
System.out.println("eat...");
}
public void eat(String food){
System.out.println("eat..."+food);
}
}
public class ReflectDemo1 {
/** 获取Class对象的方式：
1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
2. 类名.class：通过类名的属性class获取
3. 对象.getClass()：getClass()方法在Object类中定义着。*/
public static void main(String[] args) throws Exception {
//1.Class.forName("全类名")，即包名.类名
Class cls1 = Class.forName("cn.itcast.domain.Person");
System.out.println(cls1);
//2.类名.class
Class cls2 = Person.class;
System.out.println(cls2);
//3.对象.getClass()
Person p = new Person();
Class cls3 = p.getClass();
System.out.println(cls3);
//== 比较三个对象
System.out.println(cls1 == cls2);//true
System.out.println(cls1 == cls3);//true
Class c = Student.class;
System.out.println(c == cls1);
}
}
4. Class对象功能
获取功能
通过Class对象可以获取某个类中的构造方法、成员变量、成员方法；并访问成员
获取成员变量并调用
-
批量的
- Field[] getFields():获取所有的"公有字段"
- Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
-
获取单个的：
- public Field getField(String fieldName):获取某个"公有的"字段；
- public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
-
设置字段的值：
- Field --> public void set(Object obj,Object value):
-
参数说明：
- obj：要设置的字段所在的对象；
- value：要为字段设置的值；
-
Field：成员变量
- 操作：
- 设置值
void set(Object obj, Object value)
- 获取值
get(Object obj)
- 忽略访问权限修饰符的安全检查
setAccessible(true)：暴力反射
- 设置值
- 操作：
-
package cn.itcast.reflect; import cn.itcast.domain.Person; import java.lang.reflect.Field; public class ReflectDemo2 { /** Class对象功能： * 获取功能： 1. 获取成员变量们 * Field[] getFields() * Field getField(String name) * Field[] getDeclaredFields() * Field getDeclaredField(String name) 2. 获取构造方法们 * Constructor<?>[] getConstructors() * Constructor<T> getConstructor(类<?>... parameterTypes) * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) * Constructor<?>[] getDeclaredConstructors() 3. 获取成员方法们： * Method[] getMethods() * Method getMethod(String name, 类<?>... parameterTypes) * Method[] getDeclaredMethods() * Method getDeclaredMethod(String name, 类<?>... parameterTypes) 4. 获取类名 * String getName() */ public static void main(String[] args) throws Exception { //0.获取Person的Class对象 Class personClass = Person.class; //1. 获取成员变量们 //1.Field[] getFields()获取所有public修饰的成员变量 Field[] fields = personClass.getFields(); for (Field field : fields) { System.out.println(field); } System.out.println("------------"); //2.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("d"); //忽略访问权限修饰符的安全检查 d.setAccessible(true);//暴力反射 Object value2 = d.get(p); System.out.println(value2); } }
获取构造方法
-
批量的方法：-
public Constructor[] getConstructors()：所有"公有的"构造方法 -
public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)
-
-
获取单个的方法，并调用：-
public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法： -
public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；
-
-
调用构造方法：
-
Constructor-->newInstance(Object... initargs)
-
-
Constructor:构造方法
- 创建对象：
-
T newInstance(Object... initargs)
-
如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法
-
- 创建对象：
-
package cn.itcast.reflect; import cn.itcast.domain.Person; import java.lang.reflect.Constructor; import java.lang.reflect.Field; public class ReflectDemo3 { public static void main(String[] args) throws Exception { //0.获取Person的Class对象 Class personClass = Person.class; /* 2. 获取构造方法们 * Constructor<?>[] getConstructors() * Constructor<T> getConstructor(类<?>... parameterTypes) * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) * Constructor<?>[] getDeclaredConstructors() */ //Constructor<T> getConstructor(类<?>... parameterTypes) Constructor constructor = personClass.getConstructor(String.class, int.class); System.out.println(constructor); //创建对象 Object person = constructor.newInstance("张三", 23); System.out.println(person); System.out.println("----------"); Constructor constructor1 = personClass.getConstructor(); System.out.println(constructor1); //创建对象 Object person1 = constructor1.newInstance(); System.out.println(person1); Object o = personClass.newInstance(); System.out.println(o); //constructor1.setAccessible(true); } }
获取成员方法
-
批量的：
- public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）
- public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)
-
获取单个的：
- public Method getMethod(String name,Class<?>... parameterTypes):
- 参数：
- name : 方法名；
- Class ... : 形参的Class类型对象
- 参数：
- public Method getDeclaredMethod(String name,Class<?>... parameterTypes)
- public Method getMethod(String name,Class<?>... parameterTypes):
-
调用方法：
- Method --> public Object invoke(Object obj,Object... args):
-
参数说明：
- obj ：要调用方法的对象；
- args：调用方式时所传递的实参；
-
Method：方法对象
-
执行方法：
- Object invoke(Object obj, Object... args)
-
获取方法名称：
- String getName:获取方法名
-
-
package cn.itcast.reflect; import cn.itcast.domain.Person; import java.lang.reflect.Constructor; import java.lang.reflect.Method; public class ReflectDemo4 { public static void main(String[] args) throws Exception { //0.获取Person的Class对象 Class personClass = Person.class; /* 3. 获取成员方法们： * Method[] getMethods() * Method getMethod(String name, 类<?>... parameterTypes) * Method[] getDeclaredMethods() * Method getDeclaredMethod(String name, 类<?>... 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) { System.out.println(method); String name = method.getName(); System.out.println(name); //method.setAccessible(true); } //获取类名 String className = personClass.getName(); System.out.println(className);//cn.itcast.domain.Person } }
获取全类名
- String getName()
三、案例
需求
- 写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
实现
- 配置文件
- 反射
步骤
- 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
- 在程序中加载读取配置文件
- 使用反射技术来加载类文件进内存
- 创建对象
- 执行方法
public class Student {
public void sleep(){
System.out.println("sleep...");
}
}
配置文件：新建一个file文件pro.properties
className =itcast.domain.Person //包名.类名
methodName = eat
import cn.itcast.domain.Person;
import cn.itcast.domain.Student;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* 框架类
*/
public class ReflectTest {
public static void main(String[] args) throws Exception {
//可以创建任意类的对象，可以执行任意方法
/*
前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
*/
/* Person p = new Person();
p.eat();*/
/*
Student stu = new Student();
stu.sleep();*/
//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.newInstance();
//5.获取方法对象
Method method = cls.getMethod(methodName);
//6.执行方法
method.invoke(obj);
}
}
四、注解
概念
- 注解：说明程序，给计算机看的
- 不是程序本身 , 可以对程序作出解释(这一点同注释 )
- 可以被其他程序(比如:编译器等)读取
- 注释：用文字描述程序，给程序员看的
定义
- 注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。
- 概念描述：
- JDK1.5之后的新特性
- 说明程序的
- 使用注解：注解是以"@注释名"在代码中存在的
- 还可以添加一些参数值 , 如:@SuppressWarnings(value="unchecked")
- 在哪里使用
- 可以附加在package , class , method , field 等上面 , 相当于给他们添加了额外的辅助信息
- 我们可以通过反射机制实现对这些元数据的访问
- 作用分类：
①编写文档：通过代码里标识的注解生成文档【生成文档doc文档】
②代码分析：通过代码里标识的注解对代码进行分析【使用反射】
③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
基本内置注解
@Override：检测被该注解标注的方法是否是继承自父类(接口)的- 定义在 java.lang.Override 中 , 此注释只适用于修饰方法
@Deprecated：该注解标注的内容，表示已过时- 定义在java.lang.Deprecated中 , 此注释可以用于修饰方法 , 属性 , 类
- 表示不鼓励程序员使用这样的元素 , 通常是因为它很危险或者存在更好的选择
@SuppressWarnings：压制警告- 定义在java.lang.SuppressWarnings中，用来抑制编译时的警告信息
- 与前两个注释有所不同，需要添加一个参数才能正确使用，参数已经定义好了的，只需要选择性的使用，如：
- @SuppressWarnings("all") 压制所有警告
- @SuppressWarnings("unchecked")
- @SuppressWarnings(value={"unchecked","deprecation"})
- 一般传递参数all @SuppressWarnings("all")
//测试内置注解
import java.util.ArrayList;
import java.util.List;
//所有类默认继承Object类
public class Test1 extends Object {
//@Override 表示方法重写
@Override
public String toString() {
return super.toString();
}
//方法过时了, 不建议使用,可能存在问题,并不是不能使用
@Deprecated
public static void stop(){
System.out.println("测试 @Deprecated");
}
//@SuppressWarnings 抑制警告 , 可以传参数
@SuppressWarnings("all")
public void sw(){
List list = new ArrayList();
}
public static void main(String[] args) {
stop();
}
}
元注解
-
元注解就是负责注解其他注解 。Java定义了4个标准的注解类型，他们被用来提供对其他注解类型作说明
-
格式：
-
public @interface 注解名称{ 属性列表; } -
使用：@注解名称
-
-
这些类型和所支持的类在java.lang.annotation包中可以找到 ( @Target , @Retention ,@Documented , @Inherited )
- @Target：用于描述注解的使用范围(被描述的注解可以用在什么地方)
- ElementType取值：
- TYPE：可以作用于类上
- METHOD：可以作用于方法上
- FIELD：可以作用于成员变量上
- @Retention：表示需要在什么级别保存该注释信息 ， 用于描述注解的生命周期
- (SOURCE < CLASS < RUNTIME)
- @Retention(RetentionPolicy.RUNTIME)：当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
- @Documented：描述注解是否被抽取到api文档中
- @Inherited：描述注解是否被子类继承
- @Target：用于描述注解的使用范围(被描述的注解可以用在什么地方)
自定义注解
- 注解本质上就是一个接口，该接口默认继承java.lang.annotation.Annotation接口
- 分析 :
- @ interface用来声明一个注解 ,
- 格式 : public @ interface 注解名
- 其中的每一个方法实际上是声明了一个配置参数.
- 返回值类型就是参数的类型 ( 返回值只能是基本类型,Class , String , enum ).
- 注解元素必须要有值 , 我们定义注解元素时 , 经常使用空字符串,0作为默认值
- @ interface用来声明一个注解 ,
- 属性：接口中的抽象方法
- 要求：
- 方法的名称就是参数的名称
- 返回值类型就是参数的类型 ( 返回值只能是基本数据类型、Class ,、String , 枚举【emun】、注解和以上类型的数组)
- 定义了属性，在使用时需要给属性赋值
- 如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
- 如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可。
- 数组赋值时，值使用{}包裹。如果数组中只有一个值，则{}可以省略
- 要求：
在程序使用(解析)注解
-
在程序使用(解析)注解：获取注解中定义的属性值
-
获取注解定义的位置的对象 （Class，Method,Field）
-
获取指定的注解
-
getAnnotation(Class)
//其实就是在内存中生成了一个该注解接口的子类实现对象public class ProImpl implements Pro{ public String className(){ return "cn.itcast.annotation.Demo1"; } public String methodName(){ return "show"; } }
-
-
调用注解中的抽象方法获取配置的属性值
-
参考博客：https://blog.csdn.net/sinat_38259539/java/article/details/71799078
浙公网安备 33010602011771号