1.反射：框架设计的灵魂

1.1框架

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

1.2反射

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

反射的好处：

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

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

（1）Source源代码阶段：*.java被编译成*.class字节码文件。

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

（3）RunTime运行时阶段：创建对象的过程new。

2.获取Class对象的方式

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

1. 【Source源代码阶段】 Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
* 多用于配置文件，将类名定义在配置文件中。读取文件，加载类。
2. 【Class类对象阶段】 类名.class：通过类名的属性class获取
* 多用于参数的传递
3. 【Runtime运行时阶段】对象.getClass()：getClass()方法是定义在Objec类中的方法
* 多用于对象的获取字节码的方式

结论：同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。

2.2 测试三种获取方法

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

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

    //方式三：对象.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)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个。

3. 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 对获取功能进行演示

3.2.1 Field:获取成员变量

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

3.2.2.1被测试的类：

@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)，get和set方法

/**
 * 1. 获取成员变量们
 *     * Field[] getFields()
 *     * Field getField(String name)
 * @throws Exception
 */
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        //0.获取Person的Class类
        Class<Person> 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)
        Field a = personClass.getField("a");
        //获取到成员变量a之后要干什么呢？一般只有获取值和赋值两种用途
        //Field类中存在set和get两种方法
        //获取成员变量a 的值 [也只能获取公有的，获取私有的或者不存在的字符会抛出异常]
        Person p = new Person();
        Object value = a.get(p);
        System.out.println("value = " + value);

        //设置属性a的值
        a.set(p,"张三");
        System.out.println(p);

    }
}

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

/**
 *     Field[] getDeclaredFields()
 *     Field getDeclaredField(String name)
 * @throws Exception
 */
@Test
public void reflect3() throws Exception {
    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);    //会抛出异常
    //System.out.println("value1 = " + value1);    //对于私有变量虽然能会获取到，但不能直接set和get

    //忽略访问权限修饰符的安全检查
    d.setAccessible(true);//暴力反射
    Object value2 = d.get(p);
    System.out.println("value2 = " + value2);
}

没有忽略访问修饰符直接访问抛出的异常：

暴力反射运行结果：

3.2.2 Constructor:获取构造方法

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

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

3.2.2.1 修改测试的实体类

@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.2 测试方法（注释很重要）

/**
 * 2. 获取构造方法们
 *    Constructor<?>[] getConstructors()
 *    Constructor<T> getConstructor(类<?>... parameterTypes)
 */
@Test
public void reflect4() throws Exception {
    Class personClass = Person.class;

    //Constructor<?>[] getConstructors()  多个构造器
    Constructor[] constructors = personClass.getConstructors();
    for(Constructor constructor : constructors){   //Constructor 对象reflect包下的 import java.lang.reflect.Constructor;
        System.out.println(constructor);
    }

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

    //获取无参构造函数   注意：Person类中必须要有无参的构造函数，不然抛出异常
    Constructor constructor1 = personClass.getConstructor();
    System.out.println("constructor1 = " + constructor1);
    //获取到构造函数后可以用于创建对象
    Object person1 = constructor1.newInstance();//Constructor类内提供了初始化方法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("张三", 23);   //获取的是有参的构造方法，就必须要给参数
    System.out.println(person2);

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

    //对于一般的无参构造函数，我们实际上不需要先获取无参构造器之后在进行初始化。而是直接调用Class类内的newInstance()方法
    Object person3 = personClass.newInstance();
    System.out.println("person3 = " + person3);
    //我们之前使用的 Class.forName("").newInstance; 其本质上就是调用了类内的无参构造函数来完成实例化的
    //故可以得出结论 我们以后在使用  Class.forName("").newInstance; 反射创建对象时，一定要保证类内有无参构造函数
}

3.3.2.3 关于getDeclaredConstructor方法和getDeclaredConstructors方法

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

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

class SingletonDemo{
    	//私有化构造方法
    	private SingletonDemo(){
         
     }
     
    	//创建一个对象  类内实例化（静态的对象）
    	private static SingletonDemo singleton = new SingletonDemo();
     
    //提供public方法供外部访问，返回这个创建的对象
    public static SingletonDemo getInstance(){
    	return singleton;
    }
}
public class Singleton {
	public static void main(String[] args) {
		SingletonDemo s1 = SingletonDemo.getInstance();
		//输出对象的地址，如果有地址存在，则说明对象创建成功并获取到
		System.out.println(s1);
  
        SingletonDemo s2 = SingletonDemo.getInstance();
		//如果结果为true，则说明是同一个对象
		System.out.println(s1==s2);    //输出结果为true
	}
}

3.2.3 Method：方法对象

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

3.2.3.1 修改测试的实体类

public class Person {
    private String name;
    private int age;

    public String a;        //最大范围public
    protected String b;     //受保护类型
    String c;               //默认的访问权限
    private String d;       //私有类型

    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }

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

    //重载有参方法
    public void eat(String food){
        System.out.println("eat..."+food);
    }

3.2.3.2 获取所有方法名：

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        //0.获取Person的Class类
        Class<Person> personClass = Person.class;
        System.out.println(method.getName());
        Method[] methods = personClass.getMethods();
        for(Method method:methods){
            System.out.println(method);
            
        }

    }
}

获取方法的作用无非就是，为了执行这个方法：

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        //0.获取Person的Class类
        Class<Person> personClass = Person.class;
        
        //获取指定名称的方法
        Method eat_method1 = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method1.invoke(p);

        Method eat_method2 = personClass.getMethod("eat", String.class);
        //执行方法
        eat_method2.invoke(p, "大餐");

    }
}

3.2.3.3 关于获取成员方法们的另外两个方法

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

method.setAccessible(true);   //暴力反射

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

综上说述：对于反射机制来说，在反射面前没有公有私有，都可以通过暴力反射解决。

4. 案例

4.1 需求

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

4.2 实现思路

（1）配置文件（2）反射

4.3步骤

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

（2）在程序中加载读取配置文件

（3）使用反射技术来加载类文件进内存

（4）创建对象

（5）执行方法

4.4 代码实现

4.4.1 需要的实体类

（1）Person类

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=cn.other.reflect.Person
methodName=eat

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

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.3 好处

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

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

zzu_seu

发布了169 篇原创文章 · 获赞 101 · 访问量 7万+

私信关注

【Java学习记录】三十五反射

1.反射：框架设计的灵魂

1.1框架

1.2反射

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

2.获取Class对象的方式

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

2.2 测试三种获取方法

3. Class对象功能

3.1 获取功能

3.2 对获取功能进行演示

3.2.1 Field:获取成员变量

3.2.2 Constructor:获取构造方法

3.2.3 Method：方法对象

4. 案例

4.1 需求

4.2 实现思路

4.3步骤

4.4 代码实现

猜你喜欢

【Java学习记录】三十五 反射

1.反射：框架设计的灵魂

1.1框架

1.2反射

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

2.获取Class对象的方式

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

2.2 测试三种获取方法

3. Class对象功能

3.1 获取功能

3.2 对获取功能进行演示

3.2.1 Field:获取成员变量

3.2.2 Constructor:获取构造方法

3.2.3 Method：方法对象

4. 案例

4.1 需求

4.2 实现思路

4.3步骤

4.4 代码实现

猜你喜欢

【Java学习记录】三十五反射