第15章 Java反射机制

发表于 2022-02-11 分类于程序设计， Java 阅读次数：本文字数： 14k 阅读时长 ≈ 13 分钟

第15章、Java反射机制

一、java 反射机制概述
二、理解 Class 类并获取 Class 实例 (掌握)
三、类的加载与 ClassLoader 的理解 (了解)
四、创建运行时类的对象 (掌握)
五、获取运行时类的完整结构 (了解)
六、调用运行时类的指定结构 (掌握)
七、反射的应用：动态代理 (此处了解，框架部分会细讲)
每日一考
总结

一、java反射机制概述

(一)、概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
- 运行时取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
- 动态语言：编译过程不能确定要实现什么类的对象，需要运行时确定
  - 动态语言
    是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
    主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
  - 静态语言与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、 C++。
  - Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活！
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

(二)、Java反射机制研究及应用

Java反射机制提供的功能

Java反射机制提供的功能
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理

(三)、反射相关的主要API

java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
… …

二、理解Class类并获取Class实例(掌握)

(一)、Class类的理解

类的加载过程

程序经过javac.exe命令后，会生成一个或多个字节码文件(.class结尾)。
接着我们使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程就称为类的加载。
加载到内存中的类称为运行时类，此运行时类就作为Class的一个实例
Class的实例就对应着一个运行时类。
加载到内存中的运行时类，会缓存一定的时间。在此时间内，我们可以通过不同的方式来获取此运行时类

(二)、获取Class实例

方式一：调用运行时类的属性—— .class
1
Class clazz = Person.class;

方式二：通过运行类的对象

1 2	Person p = new Person(); Class pClass = p.getClass();

方式三：调用Class的静态方法：forName(String classPath)【使用较多】
1
Class forName = Class.forName("com.atguigu.reflection.Person");

方式四：使用类的加载器：ClassLoader

1 2	ClassLoader classLoader = ReflectionTest.class.getClassLoader(); Class loadClass = classLoader.loadClass("com.atguigu.reflection.Person");

获取运行时类，而不是创建运行时类

(三)、具有Class对象的类型

class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
interface：接口
[]：数组
- 只要数组元素类型与维度一样，就是同一个Class实例
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

(四)、Class类的常用方法

三、类的加载与ClassLoader的理解(了解)

(一)、类的加载

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
链接：将Java类的二进制代码合并到JVM的运行状态之中的过程。
- 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
- 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
初始化：
- 执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
- 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

(二)、类加载器

类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

(三)、ClassLoader

类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。

获取类加载器

对于自定义类，使用系统类加载器进行加载
调用系统类加载器的getParent()，获取扩展类加载器
调用扩展类加载器的getParent()，无法获得引导类加载器
引导类加载器，主要负责Java的核心类库的加载，无法加载自定义类

//1.获取一个系统类加载器
ClassLoader classloader = ClassLoader.getSystemClassLoader();
System.out.println(classloader);
//2.获取系统类加载器的父类加载器，即扩展类加载器
classloader = classloader.getParent();
System.out.println(classloader);
//3.获取扩展类加载器的父类加载器，即引导类加载器
classloader = classloader.getParent();
System.out.println(classloader);
//4.测试当前类由哪个类加载器进行加载
classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
System.out.println(classloader);
//5.测试JDK提供的Object类由哪个类加载器加载
classloader =
Class.forName("java.lang.Object").getClassLoader();
System.out.println(classloader);
//*6.关于类加载器的一个主要方法：getResourceAsStream(String str):获取类路径下的指定文件的输入流
InputStream in = null;
in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");
System.out.println(in);

getResourceAsStream(String str):获取类路径下的指定文件的输入流。【需掌握】

使用此方法获取的文件输入流的文件默认路径为当前module的src下

@Test
public void testProperties() throws IOException {
    Properties properties = new Properties();
    // 读取配置文件的方式一：
    // 此种方式的文件默认在当前的Module下
    //        FileInputStream fileInputStream = new FileInputStream("ClassLoaderTest.properties");
    //        properties.load(fileInputStream);

    // 读取配置文件的方式二：使用ClassLoader
    // 配置文件默认识别为：当前Module的src下
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    InputStream resourceAsStream = classLoader.getResourceAsStream("ClassLoaderTest-1.properties");
    properties.load(resourceAsStream);

    String username = properties.getProperty("username");
    String password = properties.getProperty("password");
    System.out.println("username = " + username + ", password = " + password);

    //        fileInputStream.close();
}

四、创建运行时类的对象(掌握)

调用运行时类的newInstance()方法：创建对应的运行时类对象。内部实际上调用了运行时类的空参构造器
1
2
3
Class clazz = Class.forName("com.atguigu.reflection.Person");
Object p = clazz.newInstance();
System.out.println(p);
- 要想此方法正常的创建运行时类的对象，要求：
  - 运行时类必须提供空参的构造器（通常95%场景会通过反射调用空参构造器，且javabean中要求提供一个public的空参构造器）
  - 空参构造器的访问权限要够：通常设置为public
- javabean中要求提供一个public的空参构造器。原因：
  - 便于通过反射，创建运行时类的对象
  - 便于子类继承此运行时类时，子类构造器默认调用super()时，需保证父类有此构造器，否则需要显式调用父类的带参构造器

没有无参的构造器的类也可创建对象

通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
通过Constructor实例化对象。

//1.根据全类名获取对应的Class对象
String name = “atguigu.java.Person";
Class clazz = null;
clazz = Class.forName(name);
//2.调用指定参数结构的构造器，生成Constructor的实例
Constructor con = clazz.getConstructor(String.class,Integer.class); //3.通过Constructor的实例创建对应类的对象，并初始化类属性Person p2 = (Person) con.newInstance("Peter",20);
System.out.println(p2);

java反射的动态性体现

@Test
public void testDynamizationOfReflection(){
    for (int i = 0; i < 20; i++) {
        int num = new Random().nextInt(3);
        String classPath = "";
        switch (num) {
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.atguigu.reflection.Person";
                break;
        }
        Object instance = null;
        try {
            instance = getInstance(classPath);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(instance);
    }
}

public static Object getInstance(String classPath) throws Exception {
    Class clazz = Class.forName(classPath);
    Object o = clazz.newInstance();
    return o;
}

五、获取运行时类的完整结构(了解)

Field、Method、Constructor、Superclass、Interface、Annotation

实现的全部接口
1
public Class<?>[] getInterfaces()
确定此对象所表示的类或接口实现的接口。
所继承的父类
1
2
public Class<? Super T> getSuperclass()
getGenericSuperClass() //获取带泛型的父类
返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的Class。

全部的构造器

1
2
3

public Constructor<T>[] getConstructors()
获取当前运行时类中声明为public的构造方法。（不包括父类构造器）
public Constructor<T>[] getDeclaredConstructors()获取当前运行时类中声明的所有构造方法。

Constructor类中：

1
2
3

取得修饰符: public int getModifiers();
取得方法名称: public String getName();
取得参数的类型：public Class<?>[] getParameterTypes();

全部的方法

public Method[] getDeclaredMethods()
获取当前运行时类中声明的全部方法(不包含父类中声明的方法)
public Method[] getMethods()
获取当前运行时类及其所有父类中声明为public权限的方法

Method类中：

public Class<?> getReturnType()取得全部的返回值类型
public Class<?>[] getParameterTypes()取得全部的参数
public int getModifiers()取得修饰符
public Class<?>[] getExceptionTypes()取得异常信息

全部的Field

public Field[] getFields()
获取当前运行时类及其所有父类中声明为public权限的Field。
public Field[] getDeclaredFields()
获取当前运行时类中声明的全部Field(不包含父类中声明的属性)。

Field类中：

1
2
3

public int getModifiers()  以整数形式返回此Field的修饰符(权限修饰符)
public Class<?> getType()  得到Field的属性类型（数据类型）
public String getName()  返回Field的名称。

Annotation相关

1
2
3

getAnnotation(Class<T> annotationClass)
getAnnotations()
getDeclaredAnnotations()

泛型相关

1
2
3

获取带泛型类型的父类：Type getGenericSuperclass()
泛型类型：ParameterizedType
获取实际的泛型类型参数数组：getActualTypeArguments()

类所在的包
1
Package getPackage()

六、调用运行时类的指定结构(掌握)

重点：属性、方法、构造器

调用对象的属性、方法、构造器，因此需要先获得运行时类，通过运行时类获得对象

(一)、调用指定的属性

获取指定的属性

getField(String name)
要求运行时类中属性声明为public【通常不采用】
getDeclaredField(String name)
【开发中常用】
配合 setAccessible(true);使用，禁用访问安全检查的开关，可以访问private等权限属性

1
2

public Field getField(String name) 返回此Class对象表示的类或接口的指定的public的Field。
public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field。

设置当前属性的值

set(): 参数1-指明设置那个对象的属性；参数2-将此属性值设置为多少

1 2	public Object get(Object obj) 取得指定对象obj上此Field的属性内容 public void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容

(二)、调用指定的方法

获取指定的方法

1
2

1. getDeclaredMethod(): 参数1-指明获取的方法名；参数2-指明获取的方法的形参列表
2. 通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

保证当前方法是可访问的：setAccessible(true);
之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。参数1-方法的调用者；参数2-给方法形参赋值的实参 invoke()的返回值即为对应类中调用方法的返回值 1). Object 对应原方法的返回值，若原方法无返回值，此时返回null 2). 若原方法若为静态方法，此时形参Object obj可为null 3). 若原方法形参列表为空，则Object[] args为null 4). 若原方法声明为private,则需要在调用此invoke()方法前，显式调用
若需调用静态方法
以上步骤相同，只有invoke()方法的参数一指定为运行时类或null

(三)、调用指定的构造器

获取指定的构造器

1	getDeclaredConstructor(): 参数需要指明构造器参数列表

保证此构造器是可访问的
1
setAccessible(true)

调用此构造器创建运行时类的对象

1	获得的构造器调用newInstance(参数列表)

七、反射的应用：动态代理(此处了解，框架部分会细讲)

(一)、代理设计模式的原理

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

静态代理举例

interface ClothFactory{
    void produceCloth();
}

class ProxyClothFactory implements ClothFactory{

    private ClothFactory clothFactory; // 用被代理类对象进行实例化

    public ProxyClothFactory(ClothFactory clothFactory){
        this.clothFactory = clothFactory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做一些准备工作");
        clothFactory.produceCloth();
        System.out.println("代理工厂做一些后续收尾工作");

    }
}

class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike生产一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        // 1. 创建被代理类对象
        NikeClothFactory nike = new NikeClothFactory();
        // 2. 创建代理类对象
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);

        proxyClothFactory.produceCloth();
    }
}

特点：代理类和被代理类在编译期间就被确定下来

(二)、动态代理

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理使用场合:
- 调试
- 远程方法调用
动态代理相比于静态代理的优点：
- 抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

(三)、动态代理步骤

根据内存中的被代理类实现的接口，动态生成代理类

实现动态代理需要解决的问题：

如何根据加载到内存中的被代理类，动态创建一个代理类及其对象
- getProxyInstance()
当通过代理类的对象调用方法时，如何动态的调用被代理类中的同名方法
- 使用invocationHandler

// 接口
interface Human{
    String getBelief();

    void eat(String food);
}

// 被代理类
class SuperMan implements Human{

    @Override
    public String getBelief() {
        return "I believe I can fly";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}

// 生成代理类对象的代理类，通过调用静态方法获取代理类对象
class ProxyFactory{

    // 通过调用此方法返回一个代理类对象。
    public static Object getProxyInstance(Object obj){
        // obj: 被代理类对象

        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj); // 传入handler被代理类对象，以实现动态调用

        Object proxyInstance = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
        return proxyInstance;
    }
}

class MyInvocationHandler implements InvocationHandler{

    private Object obj;

    public void bind(Object obj){
        this.obj = obj;
    }

    // 当我们通过代理类的对象，调用方法a时，就会自动调用如下方法：invoke()
    // 将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // method: 即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        // obj:被代理类对象
        Object returnValue = method.invoke(obj, args);
        // 上述方法的返回值就作为当前类的invoke()返回值
        return returnValue;
    }
}

public class DynamicProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        // proxyInstance: 代理类对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        // 当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        System.out.println(proxyInstance.getBelief());
        proxyInstance.eat("火锅");

        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory nikeProxy = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        nikeProxy.produceCloth();
    }
}

(四)、动态代理与AOP(Aspect Orient Programming)

前面介绍的Proxy和InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机制

改进后的说明：代码段1、代码段2、代码段3和深色代码段分离开了，但代码段1、2、3又和一个特定的方法A耦合了！最理想的效果是：代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用深色代码的方法

使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理
这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理

每日一考

写出获取Class实例的三种常见方式

1
2
3

1. 调用运行时类的属性：类.class
2. 通过对象方法获取：对象.getClass()
3. Class类的静态方法：Class.forName()

谈谈你对Class类的理解

1	Class类的实例对应着加载到内存中的一个运行时类。通过运行时类即可调用运行时类中的结构

创建Class对应运行时类的对象的通用方法，代码实现。以及这样操作，需要对应的运行时类构造器方面满足的要求

// 创建对应运行时类的对象：
newInstance();
// 要求:
// 必须有空参构造器
// 空参构造器的权限要够，通常设置为public

在工程或Module的src下有名为"jdbc.properties"的配置文件，文件内容为：name=Tom。如何在程序中通过代码获取Tom这个变量

// 使用Properties类读取配置文件
Properties p = new Properties();
// 方式一：使用FileInputStream获取输入文件流
// 方式二：使用ClassLoader获取输入流

如何调用方法show()

// 类声明如下
package com.atguigu.java;
class user{
    public void show(){
        sout("我是一个中国人");
    }
}

方式一：直接new一个user对象，通过对象调用show()方法
方式二：通过反射调用方法

总结

创建类的对象的方式

new + 构造器
要创建Xxx类的对象，可考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有静态方法存在。可以调用其静态方法创建Xxx对象
通过反射

如何看待反射和封装性两个技术

通过直接new的方式或反射的方式都可以调用公共结构，开发中到底用哪个

建议：直接new的方式
什么时候会使用反射：编译时不确定要实例化哪个类的对象时。
- 例如，当前端访问...，因为后端代码是已经运行起来的，因此需要提供login类的对象；而当前端访问...，则需要提供register类的对象

反射机制与面向对象中的封装性是不是矛盾的？如何看待两个技术

反射可以操作private等权限的属性或方法与new出的对象不能操作private等权限的属性或方法矛盾吗？

不矛盾
原因：
- 封装性：封装性表示的是private等权限的属性、方法都已经提供了相应的public权限的方法来操作，且这些已经封装好的public方法能更好的控制边界、使代码更健壮等，因此这些private权限的属性、方法在类外用不到，就不再暴露到类外，且建议调用已经封装好的public权限的属性或方法
- 反射：反射只是可以（能力上能够）访问、操作private等权限的属性、方法，但同样不建议访问或操作private等权限的属性或方法
- 封装性给出的是建议调用的问题；而反射给出的是能不能调的问题

Hunt's Blog