反射笔记

一、反射

1.1 框架

半成品软件。可以在框架的基础上进行软件开发，简化编码。学习框架并不需要了解反射，但是要是想自己写一个框架，那么就要对反射机制有很深入的了解。

1.2 反射

反射机制：将类的各个组成部分封装为其他对象，这就是反射机制。

反射的好处：

• 1.可以在程序运行过程中，操作这些对象。
• 2.可以解耦，提高程序的可扩展性。

 

Java代码在计算机中经历的三个阶段

• （1）Source源代码阶段：*.java被编译成*.class字节码文件。
• （2）Class类对象阶段：*.class字节码文件被类加载器加载进内存，并将其封装成Class对象（用于在内存中描述字节码文件），Class对象将原字节码文件中的成员变量抽取出来封装成数组Field[],将原字节码文件中的构造函数抽取出来封装成数组Construction[]，在将成员方法封装成Method[]。当然Class类内不止这三个，还封装了很多，我们常用的就这三个。
• （3）RunTime运行时阶段：创建对象的过程new。

二、获取Class对象的方式

 

2.1 获取Class对象的三种方式对应着java代码在计算机中的三个阶段

（1）【Source源代码阶段】 Class.forName("全类名")：将字节码文件加载进内存，返回Class对象 * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类。

（2）【Class类对象阶段】 类名.class：通过类名的属性class获取 * 多用于参数的传递

（3）【Runtime运行时阶段】对象.getClass()：getClass()方法是定义在Objec类中的方法 * 多用于对象的获取字节码的方式 结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。

public void reflect1() throws ClassNotFoundException {
    //方式一：Class.forName("全类名");
    Class cls1 = Class.forName("com.test.domain.Person");   //Person自定义实体类
    System.out.println("cls1 = " + cls1);

    //方式二：类名.class
    Class cls2 = Person.class;
    System.out.println("cls2 = " + cls2);

    //方式三：对象.getClass();
    Person person = new Person();        
    Class cls3 = person.getClass();
    System.out.println("cls3 = " + cls3);

    // == 比较三个对象
    System.out.println("cls1 == cls2 : " + (cls1 == cls2));    //true
    System.out.println("cls1 == cls3 : " + (cls1 == cls3));    //true
    //结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。
}

 

三、 Class对象功能

3.1 获取功能

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

（1）获取成员变量们

Field[] getFields() ：获取所有public修饰的成员变量
Field getField(String name)   获取指定名称的 public修饰的成员变量

Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
Field getDeclaredField(String name) 

（2）获取构造方法们

Constructor<?>[] getConstructors()  
Constructor<T> getConstructor(类<?>... parameterTypes)  

Constructor<?>[] getDeclaredConstructors()  
Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  

（3）获取成员方法们：

Method[] getMethods()  
Method getMethod(String name, 类<?>... parameterTypes)  

Method[] getDeclaredMethods()  
Method getDeclaredMethod(String name, 类<?>... parameterTypes)

（4）获取全类名

String getName() 

3.2 Field：成员变量

• （1）设置值 void set(Object obj, Object value)
• （2）获取值 get(Object obj)
• （3）忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

3.3 Constructor:构造方法

创建对象：T newInstance(Object... initargs)

注意：如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

3.3.1 对于getDeclaredConstructor方法和getDeclaredConstructors方法

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

关于为什么要使用private访问权限的构造器，使用这个构造器不就不能外部访问了嘛，不也就无法进行实例化对象了吗？无法在类的外部实例化对象正是私有构造器的意义所在，在单例模式下经常使用，整个项目只有一个对象，外部无法实例化对象，可以在类内的进行实例化并通过静态方法返回（由于实例化的对象是静态的，故只有一个对象，也就是单例的）。网上说这就是单例模式中的饿汉模式，不管是否调用，都创建一个对象。

3.4 Method：方法对象

• 执行方法：Object invoke(Object obj, Object... args)
• 获取方法名称：String getName();

四、案例

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类

package com.test.domain;

public class Person {

    //无参方法
    public void eat(){
        System.out.println("eat...");
    }
}

（2）Student类

package com.test.domain;

public class Student {

    public void study(){
        System.out.println("student's job is to learn...");
    }
}

4.2.2 编写配置文件

以后我们在配置文件内看见全类名，就应该想到可能使用到了反射

className = com.test.domain.Person
methodName = eat

4.2.3 编写测试方法（模拟框架）

package com.test.junit;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

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

4.2.4 运行结果

 

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

#将配置文件内的信息修改为Student类及类内的方法
className = com.test.domain.Student
methodName = study

 

4.3 好处

我们这样做有什么好处呢，对于框架来说，是人家封装好的，我们拿来直接用就可以了，而不能去修改框架内的代码。但如果我们使用传统的new形式来实例化，那么当类名更改时我们就要修改Java代码，这是很繁琐的。修改Java代码以后我们还要进行测试，重新编译、发布等等一系列的操作。而如果我们仅仅只是修改配置文件，就来的简单的多，配置文件就是一个实实在在的物理文件。

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