有一段时间没有接触反射了，Java Web学的越深，深刻认识到反射的重要性，所以今天抽空来复习一下反射，记录如下。
类加载器
类的加载
当程序要使用某个类时，如果该类还未被加载到内存中，则系统(JVM)会通过加载，连接，初始化三步来实现对这个类进行初始化，也即一个类的加载步骤。
- 加载
就是指将class文件读入内存，并为之创建一个Class类型的对象。任何类被使用时系统(JVM)都会建立一个Class类型的对象。 - 连接
- 验证：验证加载进来的文件是否有正确的内部结构，并和其他类协调一致。
- 准备：负责为类的静态成员分配内存，并设置默认初始化值。
- 解析：将类的二进制数据中的符号引用替换为直接引用。(说的是啥意思？？？)
- 初始化
这是我们所做的事情，也即我们以前讲过的初始化步骤。
类加载的时机(类什么时候加载到内存中去)
- 创建某个类的实例(new 对象)
- 调用类的静态成员变量或者为静态成员变量赋值
- 调用类的静态方法
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 创建子类对象也会把父类加载到内存
- 直接使用java.exe命令来运行某个主类
类加载器
类加载器的作用是负责将class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。下面来粗略讲解一下类加载器的组成。
- Bootstrap ClassLoader
根类加载器，也被称为引导类加载器，负责Java核心类库(rt.jar)的加载，比如System、String等，Java核心类库——rt.jar在JRE的lib目录下，如下图：
- Extension ClassLoader
扩展类加载器，其负责JRE的扩展目录中jar包的加载，即加载JRE下面的ext文件夹下面的jar包，如下图：
- System ClassLoader
系统类加载器，其负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。用大白话来说就是系统类加载器加载我们自己写的类。
通过这些描述就可以知道我们常用的类，都是由谁来加载完成的。到目前为止我们已经知道把class文件加载到内存了，那么，如果我们仅仅站在这些class文件的角度，我们如何来使用这些class文件中的内容呢？这就是我们要研究的内容——反射了。
反射
Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性，这种动态获取类的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
从以上的这段话中，我们可以抽取出这样两个结论：
- 反射定义
能够在运行时期获得和调用类或者对象的成员变量，成员方法以及构造方法。 - 反射条件
一定是在运行时期。
所以，要想解剖一个类，必须先要获取到该类的字节码文件对象，而解剖使用的就是Class类中的方法，故先要获取到每一个字节码文件对应的Class类型的对象。
Class类
阅读API的Class类得知，Class没有公共构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。
获取一个类的class文件对象有三种方式，下面我们分别来讲解。在讲解之前，我们要事先做好准备，可以创建好这样一个Java类——Person.java：
public class Person {
public String name;
private int age;
public Person(){
}
public Person(String name, int age){
this.name = name;
this.age = age;
}
private Person(int age,String name){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println("人吃饭");
}
public void sleep(String s, int a,double d){
System.out.println("人在睡觉"+s+"....."+a+"....."+d);
}
private void playGame(){
System.out.println("人在打游戏");
}
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}获取一个类的class文件对象的第一种方式：通过该类的对象的getClass()方法获得。例如：
Person p = new Person();
// 调用Person类的父类的方法getClass()
Class c = p.getClass();第二种方式：通过类名.class获取到字节码文件对象（任意数据类型都具备一个class静态属性，看上去要比第一种方式简单）。例如：
// 每个类型包括基本的和引用的，都会赋予这个类型一个静态的属性，属性名字就叫class
Class c1 = Person.class;第三种方式：通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName即可）。例如：
// Class类的静态方法获取 forName(字符串类名) 字符串类名：包名.类名(类全名)
Class c2 = Class.forName("cn.itcast.demo1.Person");注意：第三种和前两种的区别：
- 前两种你必须明确是Person类型。
- 第三种是指定这种类型的字符串就行。这种扩展性更强，我不需要知道你的类，我只提供字符串，按照配置文件加载就可以了。
通过反射获取构造方法并使用
在反射机制中，把类中的成员（构造方法、成员方法、成员变量）都封装成了对应的类进行表示。其中，构造方法使用类Constructor表示，可通过Class类中提供的方法获取构造方法：
- 返回一个构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)
获取public修饰，指定参数类型所对应的构造方法。public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
获取指定参数类型所对应的构造方法(包含私有的)。
- 返回多个构造方法
public Constructor<?>[] getConstructors()
获取所有的public修饰的构造方法。public Constructor<?>[] getDeclaredConstructors()
获取所有的构造方法(包含私有的)。
获取构造方法的代码演示：
public class ReflectDemo1 {
public static void main(String[] args) throws Exception {
// 获取Class类型的对象
Class c = Class.forName("cn.itcast.demo1.Person");
// 使用class文件对象，获取类中所有的构造方法(包括私有的)
Constructor[] cons = c.getDeclaredConstructors();
for (Constructor con : cons) {
System.out.println(con);
}
System.out.println("--------------------------------------------");
// 获取一个指定的构造方法，即空参数的构造方法
// public Person() {}
Constructor con1 = c.getConstructor();
System.out.println(con1);
// 获取String、int参数的构造方法：public Person(String name, int age) {}
// Constructor<T> getConstructor(Class<?>... parameterTypes)
// Class<?>... parameterTypes：传递要获取的构造方法的参数列表
Constructor con2 = c.getConstructor(String.class, int.class);
System.out.println(con2);
// Constructor getDeclaredConstructor(Class... c)：获取到指定参数列表的构造方法(包括私有的)
Constructor con3 = c.getDeclaredConstructor(int.class, String.class);
System.out.println(con3);
}
}通过反射方式，获取构造方法，创建对象
获取构造方法，步骤如下：
- 获取到Class对象
- 获取指定的构造方法
- 通过构造方法类Constructor中的方法——
public T newInstance(Object... initargs)，创建对象
代码示例演示：
通过反射获取class文件中的空参数构造方法，并运行该空参数构造方法
public class ConstructorDemo { public static void main(String[] args) throws Exception { Class c = Class.forName("cn.itcast.demo1.Person"); // 获取一个指定的构造方法，即空参数的构造方法 Constructor con = c.getConstructor(); // 运行空参数的构造方法， // Constructor类中的方法newInstance运行获取到的构造方法 Object obj = con.newInstance(); System.out.println(obj.toString()); } }提示：通过反射获取class文件中的空参数构造方法并运行，还有一个快捷的方式，但使用此方式有两个前提：
- 被反射的类，必须具有空参数的构造方法。
- 构造方法权限必须是public的。
代码示例演示如下：
public class ConstructorDemo { public static void main(String[] args) throws Exception { Class c = Class.forName("cn.itcast.demo1.Person"); // Class类中定义了一个方法：public T newInstance()，直接创建被反射类的对象实例 Object obj = c.newInstance(); System.out.println(obj); } }通过反射获取有参数的构造方法并运行
public class ConstructorDemo1 { public static void main(String[] args) throws Exception { Class c = Class.forName("cn.itcast.demo1.Person"); // 获取String、int参数的构造方法 // Constructor<T> getConstructor(Class<?>... parameterTypes) // Class<?>... parameterTypes：传递要获取的构造方法的参数列表 Constructor con = c.getConstructor(String.class, int.class); // 运行构造方法 // T newInstance(Object... initargs) // Object... initargs：运行构造方法后，传递的实际参数 Object obj = con.newInstance("张三", 20); System.out.println(obj); } }
通过反射方式，获取私有构造方法，创建对象
AccessibleObject类是Field、Method和Constructor对象的父类。它提供了将反射的对象标记为在使用时取消默认Java语言访问控制检查的能力。说了半天，其实我也不知这句话什么意思！反正写在这儿，以待后面探讨。
对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用Field、Method或Constructor对象来设置或获取字段、调用方法或者创建和初始化类的新实例的时候，会执行访问检查。常用方法如下：
- public void setAccessible(boolean flag) throws SecurityException
参数值为true，则指示反射的对象在使用时应该取消Java语言访问检查。参数值为false，则指示反射的对象应该实施Java语言访问检查。
获取私有构造方法，步骤如下：
- 获取到Class对象
- 获取指定的构造方法
- 暴力访问，通过setAccessible(boolean flag)方法
- 通过构造方法类Constructor中的方法——
public T newInstance(Object... initargs)，创建对象
代码示例演示如下：
public class ConstructorDemo2 {
public static void main(String[] args) throws Exception {
Class c = Class.forName("cn.itcast.demo1.Person");
// Constructor getDeclaredConstructor(Class... c)：获取到指定参数列表的构造方法(包括私有的)
Constructor con = c.getDeclaredConstructor(int.class, String.class);
// Constructor类有一个父类AccessibleObject，父类中定义了一个方法：void setAccessible(boolean flag)
con.setAccessible(true); // 暴力反射
Object obj = con.newInstance(20, "李四");
System.out.println(obj);
}
}这就是通常所说的暴力反射，不过我们一般不推荐这么做，因为它破坏了程序的封装性和安全性。
通过反射获取成员变量并使用
在反射机制中，把类中的成员变量使用类Field表示。可通过Class类中提供的方法获取成员变量：
- 返回一个成员变量
public Field getField(String name)
获取指定的public修饰的变量。public Field getDeclaredField(String name)
获取指定的任意变量。
- 返回多个成员变量
public Field[] getFields()
获取所有public修饰的变量。public Field[] getDeclaredFields()
获取所有的变量(包含私有)。
获取成员变量的代码演示：
public class FieldDemo {
public static void main(String[] args) throws Exception {
Class c = Class.forName("cn.itcast.demo1.Person");
// 获得class文件中的所有的成员变量
Field[] fields = c.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("----------------------------------");
// 获取指定的成员变量String name
// Class类的方法：Field getField(传递字符串类型的变量名)，获取指定的成员变量
Field nameField = c.getField("name");
System.out.println(nameField);
}
}通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作
获取成员变量，步骤如下：
- 获取Class对象
- 获取构造方法
- 通过构造方法，创建对象
- 获取指定的成员变量（私有成员变量，通过setAccessible(boolean flag)方法暴力访问）
- 通过方法，给指定对象的指定成员变量赋值或者获取值
public void set(Object obj, Object value)
在指定对象obj中，将此Field对象表示的成员变量设置为指定的新值。public Object get(Object obj)
返回指定对象obj中，此Field对象表示的成员变量的值。
示例代码演示：
/**
* 通过反射获取成员变量，并修改值
* Person类中的成员String name
* @author 李阿昀
*
*/
public class FieldDemo1 {
public static void main(String[] args) throws Exception {
Class c = Class.forName("cn.itcast.demo1.Person");
Object obj = c.newInstance();
// 获取指定的成员变量String name
// Class类的方法：Field getField(传递字符串类型的变量名) 获取指定的成员变量
Field field = c.getField("name");
// Field类的方法： void set(Object obj, Object value)可以修改成员变量的值
// Object obj：必须有对象的支持；Object value：修改后的值
field.set(obj, "王五");
System.out.println(obj);
}
}通过反射获取成员方法并使用
在反射机制中，把类中的成员方法使用类Method表示。可通过Class类中提供的方法获取成员方法：
- 返回获取一个方法
public Method getMethod(String name, Class<?>... parameterTypes)
获取public修饰的方法。public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
获取任意的方法，包含私有的。
参数1：name，即要查找的方法名称；参数2：parameterTypes，即该方法的参数类型。
- 返回获取多个方法
public Method[] getMethods()
获取本类与父类中所有public修饰的方法。public Method[] getDeclaredMethods()
获取本类中所有的方法(包含私有的)。
获取成员方法的代码演示：
public class MethodDemo {
public static void main(String[] args) throws Exception {
Class c = Class.forName("cn.itcast.demo1.Person");
// 获取class文件中的所有成员方法，包括继承的
Method[] methods = c.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("--------------------------");
// 获取指定的方法eat
// Method getMethod(String methodName, Class... c)
// String methodName：你想要获取的方法名；Class... c：方法的参数列表
Method method = c.getMethod("eat");
System.out.println(method);
}
}通过反射，创建对象，调用指定的方法
获取成员方法，步骤如下：
- 获取Class对象
- 获取构造方法
- 通过构造方法，创建对象
- 获取指定的方法
- 执行找到的方法
public Object invoke(Object obj, Object... args)
执行指定对象obj中，当前Method对象所代表的方法，方法要传入的参数通过args指定。
示例代码演示如下：
/**
* 反射获取有参数的成员方法并运行
* public void sleep(String s, int a, double d) {}
* @author 李阿昀
*
*/
public class MethodDemo1 {
public static void main(String[] args) throws Exception {
Class c = Class.forName("cn.itcast.demo1.Person");
Object obj = c.newInstance();
// 调用Class类的方法getMethod()获取指定的方法sleep
Method method = c.getMethod("sleep", String.class, int.class, double.class);
// 调用Method类的invoke方法运行sleep方法
method.invoke(obj, "休眠", 100, 888.99);
}
}反射练习
泛型擦除
现在夜已深了，而我却还在做笔记，哎！好了，来思考这样一个问题：向已存在的ArrayList<String>集合中添加一个Ingeter类型的数据，如何实现呢？如果还是按照之前那样写代码，肯定是不行的，这用屁股想就可以了，而现在我们学了反射技术，想都不用想，就该知道要使用到反射这门技术了。
我来告诉大家，其实程序编译后产生的.class文件中是没有泛型约束的，这种现象我们称为泛型的擦除。那么，我们可以通过反射技术，来完成向有泛型约束的集合中，添加任意类型的元素。例如：
public class ReflectTest {
public static void main(String[] args) throws Exception {
ArrayList<String> array = new ArrayList<String>();
array.add("a");
// array.add(1);
// 反射的方式，获取出集合ArrayList类的class文件对象
Class c = array.getClass();
// 获取ArrayList.class文件中的方法add
Method method = c.getMethod("add", Object.class);
// System.out.println(method);
// 使用invoke运行ArrayList方法add
method.invoke(array, 150);
method.invoke(array, 1500);
method.invoke(array, 15000);
System.out.println(array);
}
}通过以上案例，我们可以更好地理解反射。
反射配置文件
假设此刻我们拥有如下三个Java类：
Person.java
public class Person { public void eat() { System.out.println("人在吃饭"); } }Student.java
public class Student { public void study() { System.out.println("学生在学习"); } }Worker.java
public class Worker { public void job() { System.out.println("上班族在工作"); } }
现在我们有如下一个测试类——Test.java：
public class Test {
public static void main(String[] args) throws Exception {
...
}
}在以上测试类中我们有时需要调用Person对象的方法，有时需要调用Student对象的方法，也有时需要调用Work对象的方法。类不清楚，方法也不清楚，并且项目一旦完工，交付客户之后，我们是无法再去修改测试类中的源码的。此时我们可
反射配置文件，运行配置文件中指定类的对应方法。
读取config.properties文件中的数据，通过反射技术，来完成Person对象的创建。config.properties文件的内容如下：#className=cn.itcast.demo3.Student #methodName=study className=cn.itcast.demo3.Person methodName=eat #className=cn.itcast.demo3.Worker #methodName=job读取配置文件，调用指定类中的对应方法
public class Test { public static void main(String[] args) throws Exception { // Person p = new Person(); // p.eat(); // IO流读取配置文件 FileReader r = new FileReader("config.properties"); // 创建集合对象 Properties pro = new Properties(); // 调用集合方法load，传递流对象 pro.load(r); r.close(); // 通过键获取值 String className = pro.getProperty("className"); String methodName = pro.getProperty("methodName"); // 反射获取指定类的class文件对象 Class c = Class.forName(className); Object obj = c.newInstance(); // 获取指定的方法名 Method method = c.getMethod(methodName); method.invoke(obj); } }
扫一扫
1169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
