面试官:反射都不会,还敢说自己会 Java?

发布于: 15 小时前

文末有惊喜

一、反射机制

1.1 框架

在学习Java的路上,相信你一定使用过各种各样的框架。所谓的框架就是一个半成品软件,已经对基础的代码进行了封装并提供相应的API。在框架的基础上进行软件开发,可以简化编码。学习使用框架并不需要了解反射,但是如果想要自己写一个框架,那么就需要对反射机制有很深入的了解。

1.2 什么是反射机制?

在程序运行状态中,对于任意一个类或对象,都能够获取到这个类的所有属性和方法(包括私有属性和方法),这种动态获取信息以及动态调用对象方法的功能就称为反射机制。简单来讲,通过反射,类对我们是完全透明的,想要获取任何东西都可以。

1.3 反射的优点

可以在程序运行过程中,操作这些对象;

可以解耦,提高程序的可扩展性。

在学习反射以前,我们先来了解一下Java代码在计算机中所经历的三个阶段:

Source源代码阶段:.java被编译成*.class字节码文件。

Class类对象阶段:.class字节码文件被类加载器加载进内存,并将其封装成Class对象(用于在内存中描述字节码文件),Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[],将成员方法封装成数组Method[]。当然Class类内不止这三个,还封装了很多,我们常用的就这三个。

RunTime运行时阶段:使用new创建对象的过程。

二、获取Class对象

2.1 获取Class对象的三种方式

【Source源代码阶段】 Class.forName(“全类名”):将字节码文件加载进内存,返回Class对象;

多用于配置文件,将类名定义在配置文件中,通过读取配置文件加载类。

【Class类对象阶段】 类名.class:通过类名的属性class获取;

多用于参数的传递

【Runtime运行时阶段】对象.getClass():此方法是定义在Objec类中的方法,因此所有的类都会继承此方法。

多用于对象获取字节码的方式

2.2 方法演示

public class getClass {

public static void main(String[] args) throws Exception {

//方式一:Class.forName("全类名");

Class class1 = Class.forName("zzuli.edu.cn.Person"); //Person自定义实体类

System.out.println("class1 = " + class1);

//方式二:类名.class

Class class2 = Person.class;

System.out.println("class2 = " + class2);

//方式三:对象.getClass();

Person person = new Person();

Class class3 = person.getClass();

System.out.println("class3 = " + class3);

//比较三个对象

System.out.println(class1 == class2); //true

System.out.println(class1 == class3); //true

}

}

运行结果:

通过上述比较三个对象的结果可以得出一个结论:同一个字节码文件(*.class)在一次程序运行过程中,只会被加载一次,无论通过哪一种方式获取的Class对象都是同一个。(文末有惊喜)

三、 Class对象的功能

3.1 获取功能

这里只写出一些常用的,具体可以参看jdk的帮助文档。

获取成员变量

Field[] getFields() //获取所有public修饰的成员变量

Field getField(String name) //获取指定名称的public修饰的成员变量

Field[] getDeclaredFields() //获取所有的成员变量,不考虑修饰符

Field getDeclaredField(String name) //获取指定的成员变量,不考虑修饰符

获取构造方法

Constructor<?>[] getConstructors() //获取所有public修饰的构造函数

Constructor<T> getConstructor(类<?>... parameterTypes) //获取指定的public修饰的构造函数

Constructor<?>[] getDeclaredConstructors() //获取所有的构造函数,不考虑修饰符

Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) //获取指定的构造函数,不考虑修饰符

3. 获取成员方法

Method[] getMethods() //获取所有public修饰的成员方法

Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法

Method[] getDeclaredMethods() //获取所有的成员方法,不考虑修饰符

Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法,不考虑修饰符

获取全类名

String getName()

3.2 Field:成员变量

(1)设置值 void set(Object obj, Object value)

(2)获取值 get(Object obj)

(3)忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

3.2.1 测试的实体类

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Setter

@Getter

@ToString

public class Person {

public String a; //最大范围public

protected String b; //受保护类型

String c; //默认的访问权限

private String d; //私有类型

}

3.2.2 测试getFields和getField(String name)方法

/**

* 获取成员变量

* * Field[] getFields()

* * Field getField(String name)

* @throws Exception

*/

public class reflectDemo1{

public static void main(String[] args) throws Exception {

//获取Person的Class对象

Class personClass = Person.class;

//1、Field[] getFields()获取所有public修饰的成员变量

Field[] fields = personClass.getFields();

for(Field field : fields){

System.out.println(field);

}

System.out.println("=============================");

//2.Field getField(String name) 获取指定名称的public修饰的成员变量

Field a = personClass.getField("a");

//获取成员变量a的值 [也只能获取公有的,获取私有的或者不存在的字符会抛出异常]

Person p = new Person();

Object value = a.get(p);

System.out.println("value = " + value);//因为在Person类中a没有赋值,所以为null

//设置成员变量a的属性值

a.set(p,"张三");

System.out.println(p);

}

}

运行结果:

3.2.3 测试 getDeclaredFields 和 getDeclaredField(String name)方法

/**

* Field[] getDeclaredFields()

* Field getDeclaredField(String name)

* @throws Exception

*/

public class reflectDemo2 {

public static void main(String[] args) throws Exception {

//获取Person的Class对象

Class personClass = Person.class;

//Field[] getDeclaredFields():获取所有的成员变量,不考虑修饰符

Field[] declaredFields = personClass.getDeclaredFields();

for(Field filed : declaredFields){

System.out.println(filed);

}

System.out.println("===================================");

//Field getDeclaredField(String name) //获取指定的成员变量,不考虑修饰符

Field d = personClass.getDeclaredField("d"); //private String d;

Person p = new Person();

//Object value1 = d.get(p); //如果直接获取会抛出异常,因为对于私有变量虽然能会获取到,但不能直接set和get,必须忽略访问权限修饰符的安全检查后才可以

//System.out.println("value1 = " + value1);

//忽略访问权限修饰符的安全检查,又称为暴力反射

d.setAccessible(true);

Object value2 = d.get(p);

System.out.println("value2 = " + value2);

}

}

运行结果

注意:如果没有忽略访问修饰符直接访问会抛出如下所示的异常

3.3 Constructor:构造方法

创建对象:T newInstance(Object… initargs)注意:如果使用空参数构造方法创建对象,操作可以简化:直接使用Class对象的newInstance方法。

3.3.1 修改测试的实体类

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Setter

@Getter

@ToString

public class Person {

private String name;

private Integer age;

//无参构造函数

public Person() {

}

//单个参数的构造函数,且为私有构造方法

private Person(String name){

}

//有参构造函数

public Person(String name, Integer age) {

this.name = name;

this.age = age;

}

}

3.3.2 测试获取构造函数的方法

/**

* 获取构造方法

* Constructor<?>[] getConstructors()

* Constructor<T> getConstructor(类<?>... parameterTypes)

*/

public class reflectDemo3 {

public static void main(String[] args) throws Exception {

//获取Person的Class对象

Class personClass = Person.class;

//Constructor<?>[] getConstructors() //获取所有public修饰的构造函数

Constructor[] constructors = personClass.getConstructors();

for(Constructor constructor : constructors){

System.out.println(constructor);

}

System.out.println("==========================================");

//获取无参构造函数 注意:Person类中必须要有无参的构造函数,不然抛出异常

Constructor constructor1 = personClass.getConstructor();

System.out.println("constructor1 = " + constructor1);

//使用获取到的无参构造函数创建对象

Object person1 = constructor1.newInstance();

System.out.println("person1 = " + person1);

System.out.println("==========================================");

//获取有参的构造函数 //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致,且参数类型为字节码文件类型

Constructor constructor2 = personClass.getConstructor(String.class,Integer.class);

System.out.println("constructor2 = " + constructor2);

//使用获取到的有参构造函数创建对象

Object person2 = constructor2.newInstance("zhangsan", 22); //获取的是有参的构造方法,就必须要指定参数

System.out.println(person2);

System.out.println("=========================================");

//对于一般的无参构造函数,我们都不会先获取无参构造器之后在进行初始化,而是直接调用Class类内的newInstance()方法

Object person3 = personClass.newInstance();

System.out.println("person3 = " + person3);

}

}

运行结果:

java学习交流群:925895158,欢迎各小白和大佬进群交流

总结:如果使用无参构造方法创建对象,操作可以进行简化:直接使用Class对象的newInstance方法创建即可。

对于多出个Declared关键词的两个方法,与不带这个词的两个方法的对比,与之前3.2叙述的一样,getDeclaredConstructor方法可以获取到任何访问权限的构造器,而getConstructor方法只能获取public修饰的构造器,具体不再测试。此外在构造器的对象内也有setAccessible(true)方法,把它设置成true就可以操作了。

3.4 Method:方法对象

执行方法:Object invoke(Object obj, Object… args)

3.4.1 修改测试的实体类

import lombok.Getter;

import lombok.Setter;

import lombok.ToString;

@Setter

@Getter

@ToString

public class Person {

private String name;

private Integer age;

//无参构造函数

public Person() {

}

//有参构造函数

public Person(String name, Integer age) {

this.name = name;

this.age = age;

}

//无参方法

public void eat(){

System.out.println("eat...");

}

//重载有参方法

public void eat(String food){

System.out.println("eat..."+food);

}

}

3.4.2 测试获取成员方法的方法

/**

* 获取成员方法

* * Method[] getMethods()

* * Method getMethod(String name, 类<?>... parameterTypes)

*/

public class reflectDemo4 {

public static void main(String[] args) throws Exception {

//获取Person的Class对象

Class personClass = Person.class;

//获取指定名称的方法

Method eat_method1 = personClass.getMethod("eat");

//执行方法

Person person = new Person();

Object rtValue = eat_method1.invoke(person);//如果方法有返回值类型可以获取到,没有就为null

//因为eat方法没有返回值,故输出null

System.out.println("rtValue = " + rtValue);

System.out.println("--------------------------------------------");

//获取有参的函数,有两个参数:第一个参数为方法名,第二个参数是获取方法的参数类型的字节码文件

Method eat_method2 = personClass.getMethod("eat", String.class);

//执行方法

eat_method2.invoke(person,"苹果");

System.out.println("============================================");

//获取方法列表

Method[] methods = personClass.getMethods();

for(Method method : methods){ //注意:获取到的方法不仅仅是Person类内自己的方法

System.out.println(method); //继承Object中的方法也会被获取到(当然前提是public修饰的)

}

}

}

运行结果

我们可以看出Person内的public方法都被打印出来了,此外Object中的public方法也都被打印出来了。

同之前的叙述一样,带有Declared关键字的方法这两个方法,可以获取到任意修饰符的方法。同样也提供了setAccessible(true)方法进行暴力反射。

综上所述:在反射面前没有公有私有,都可以通过暴力反射解决。

3.5 获取全类名

getName()方法获取的类名是全类名(带有路径)

public class getNameDemo {

public static void main(String[] args) throws Exception {

//获取Person的Class对象

Class personClass = Person.class;

//获取全类名

String className = personClass.getName();

System.out.println(className);

}

}

运行结果

四、反射机制的应用案例

4.1 案例分析

4.1.1 需求

写一个"框架",在不改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中的任意方法。

4.1.2 实现

(1)配置文件

(2)反射机制

4.1.3 步骤

(1)将需要创建的对象的全类名和需要执行的方法定义在配置文件中

(2)在程序中加载读取配置文件

(3)使用反射技术把类文件加载进内存

(4)创建对象

(5)执行方法

4.2 代码实现

4.2.1 需要的实体类

(1)Person类

public class Person {

//无参方法

public void eat(){

System.out.println("eat...");

}

}

(2)Student类

public class Student {

//无参方法

public void study(){

System.out.println("I am a Student");

}

}

4.2.2 编写配置文件

className = zzuli.edu.cn.Person

methodName = eat

4.2.3 实现框架

/**

* 前提:不能改变该类的任何代码。可以创建任意类的对象,可以执行任意方法

* 即:拒绝硬编码

*/

public class ReflectTest {

public static void main(String[] args) throws Exception {

//1.加载配置文件

//1.1创建Properties对象

Properties pro = new Properties();

//1.2加载配置文件

//1.2.1获取class目录下的配置文件(使用类加载器)

ClassLoader classLoader = ReflectTest.class.getClassLoader();

InputStream inputStream = classLoader.getResourceAsStream("pro.properties");

pro.load(inputStream);

//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);

}

}

4.2.4 运行结果

4.2.5 修改配置文件,再次运行

//将配置文件内的信息修改为Student类及类内的study方法

className = zzuli.edu.cn.Student

methodName = study

运行结果

优点:对于框架来说,已经对基础的代码进行了封装并提供相应的API。在框架的基础上进行软件开发,可以简化编码。但如果我们使用传统的new形式来实例化,那么当类更改时我们就要修改Java代码,这是很繁琐的。修改Java代码以后我们还要进行重新编译、测试、发布等一系列的操作。而如果我们仅仅只是修改配置文件,而不需要修改Java代码就简单的多。

此外使用反射还能达到解耦的效果,如果我们使用的是new这种形式进行对象的实例化。此时如果在项目的某一个小模块中我们的一个实例类丢失了,那么在编译期间就会报错,会导致整个项目无法启动。而对于反射创建对象Class.forName(“全类名”)这种形式,我们在编译期需要的仅仅只是一个字符串(全类名),在编译期不会报错,这样其他的模块就可以正常的运行,而不会因为一个模块的问题导致整个项目崩溃。

如果你认真看完了这篇文章,反射就应该掌握的差不多了,在接下来的几篇文章中,我会使用反射来实现热加载、反编译,并且使用反射来简单封装一个Spring框架和MyBatis框架。如果想要对反射机制有更深入的了解,可以看后续的文章。

小编最近整理出了最新的java零基础资料和进阶文档,快来扫一扫免费领取吧,名额有限哦

用户头像

码农月半

关注

还未添加个人签名 2020.07.02 加入

还未添加个人简介

评论

发布
暂无评论
面试官:反射都不会,还敢说自己会Java?