Java中的反射机制

Java

发布日期: 2021-01-15

更新日期: 2022-07-31

文章字数: 5.1k

阅读时长: 20 分

阅读次数:

引言：

Reflect（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

一、反射机制概述

Reflect（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就会产生一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射。

1、动态语言 vs 静态语言

动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

2、反射机制所提供的功能

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

3、反射相关的主要 API

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

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

    public Person() {
        System.out.println("Person()");
    }

    private Person(String name) {
        this.name = name;
    }

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

    public void show(){
        System.out.println("你好，我是一个人");
    }

    private String showNation(String nation){
        System.out.println("我的国籍是：" + nation);
        return nation;
    }

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

public class ReflectTest {
    //反射前，对于Person的操作
    @Test
    public void test1(){
        //1.创建Person类的对象
        Person p1 = new Person("Tom", 12);

        //2.通过对象调用其内部的属性、方法
        p1.age = 10;
        p1.show();
        System.out.println(p1.toString());

        /*在Person类外部，不可以通过Person类的对象调用私有的结构*/
        //比如：name，showNation()以及私有的构造器
    }

    //使用反射
    @Test
    public void test2() throws Exception {
        //通过反射，创建Person类的对象
        Class clazz = Person.class;
        Constructor cons = clazz.getConstructor(String.class, int.class);
        Object obj = cons.newInstance("Tom", 12);
        Person p = (Person) obj;
        System.out.println(p);
        //通过反射，调用对象指定的属性、方法
        //调属性
        Field age = clazz.getDeclaredField("age");
        age.set(p, 10);
        System.out.println(p);
        //调方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        //反射的强大之处，调用私有的属性和方法
        //通过反射，可以调用Person类私有结构。比如：私有的构造器、属性、方法

        // 调用私有构造器
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p1 = (Person) cons1.newInstance("Jerry");
        System.out.println(p1);

        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p1, "HanMeimei");
        System.out.println(p1);

        //调用私有的方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String) showNation.invoke(p1, "中国");//相当于String nation = p1.showNation("中国");
        System.out.println(nation);
    }
}

二、Class类的理解

1、Class类

在Object类中定义了以下的方法，此方法将被所有的子类继承：public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
通过反射可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留了一个不变的Class类型的对象。一个Class对象包含了特定某个结构（class/interface/enum/annotation/primitive type/void/[]）的有关信息。
- Class 本身也是一个类
- Class 对象只能由系统建立对象
- 一个加载的类在JVM中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的 Class对象

2、Class类的常用方法

static Class forName(String name)：返回指定类名的Class对象
Object newInstance()：调用缺省构造器，返回该Class对象的一个实例
getName()：返回此Class对象所表示的实体（类，接口，数组，基本类型或void）名称
Class[] getInterfaces()：获取当前Class对象的接口
ClassLoader getClassLoader()：返回该类的类加载器
Class getSuperclass()：返回表示此Class所表示的实体的超类的Class
Constructor[] getConstructors()：返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()：返回Field对象的一个数组
Method getMethod(String name, Class<?>… parameterTypes)：返回一个Method对象，此对象的形参类型为paramType

3、获取Class类的实例（四种方法）

前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

实例：Class cls = String.class;
前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象

实例：Class cls = “yczlab.gitee.io”.getClass();
前提：已知一个类的全类名，且该类在路径下，可通过Class类的静态方法 forName() 获取，可能抛出 ClassNotFoundException

实例：Class cls = Class.forName(“java.lang.String”);
其他方法

ClassLoader cl = this.getClass().getClassLoader();
Class cls = cl.loadClass(“类的全类名”);

public class ReflectionTest {
    @Test
    public void test1() throws ClassNotFoundException {
        //方式一：调用运行时类的属性：.class
        Class clazz1 = Person.class;
        System.out.println(clazz1);
        //方式二：通过运行时类的对象，调用getClass()
        Person p1 = new Person();
        Class clazz2 = p1.getClass();
        System.out.println(clazz2);

        //方式三：调用Class的静态方法：forName(String classPath)
        Class clazz3 = Class.forName("Person");
        //clazz3 = Class.forName("java.lang.String");
        System.out.println(clazz3);

        System.out.println(clazz1 == clazz2);//true
        System.out.println(clazz1 == clazz3);//true

        //方式四：使用类的加载器：ClassLoader  (了解)
        //ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class clazz4 = classLoader.loadClass("Person");
        System.out.println(clazz4);
        System.out.println(clazz1 == clazz4);//true
    }
}

4、哪些类型可以有Class对象

class：外部类、成员内部类、静态内部类、局部内部类、匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

@Test
public void test(){
    Class c1 = Object.class;
    Class c2 = Comparable.class;
    Class c3 = String[].class;
    Class c4 = int[][].class;
    Class c5 = ElementType.class;
    Class c6 = Override.class;
    Class c7 = int.class;
    Class c8 = void.class;
    Class c9 = Class.class;

    int[] a = new int[10];
    int[] b = new int[100];
    Class c10 = a.getClass();
    Class c11 = b.getClass();
    // 只要数组的元素类型与维度一样，就是同一个Class
    System.out.println(c10 == c11);
}

三、类的加载与ClassLoader

1、类的加载过程

程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。(可以理解为类本身也是一个对象，是一个Class类型的对象)当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

加载

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

链接

将Java类的二进制代码合并到JVM的运行状态之中的过程。

验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题

准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。

解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化

执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。

当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。

虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。

2、类的初始化

类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如，当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

3、类加载器的作用

类加载的作用：

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存：

标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

public class ClassLoaderTest {
    @Test
    public void test1(){
        //对于自定义类，使用系统类加载器进行加载
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);
        //调用系统类加载器的getParent()：获取扩展类加载器
        ClassLoader classLoader1 = classLoader.getParent();
        System.out.println(classLoader1);
        //调用扩展类加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);//null

        ClassLoader classLoader3 = String.class.getClassLoader();
        System.out.println(classLoader3);//null
    }

    @Test
    public void test2() throws Exception {
        //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);//null

        //4.测试当前类由哪个类加载器进行加载
        classLoader = Class.forName("ClassLoaderTest").getClassLoader();
        System.out.println(classLoader);

        //5.测试JDK提供的Object类由哪个类加载器加载
        classLoader = Class.forName("java.lang.Object").getClassLoader();
        System.out.println(classLoader);//null

        //6. 关于类加载器的一个主要方法：getResourceAsStream(String str)：获取类路径下的指定文件的输入流
        InputStream in = null;
        in = this.getClass().getClassLoader().getResourceAsStream("jdbc.properties");
        System.out.println(in);
    }

    /*
    Properties：用来读取配置文件。
     */
    @Test
    public void test3() throws Exception {

        Properties pros =  new Properties();
        //此时的文件默认在当前的module下。
        //读取配置文件的方式一：
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
//        pros.load(fis);

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

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ",password = " + password);
    }
}

四、创建运行时类的对象

创建类的对象：调用Class对象的newInstance()方法（相当于调用类的无参构造器来造对象）

类必须有一个无参的构造器
类的构造器的访问权限需要足够
也可以在反射中使用其他的构造器来造对象
- 通过Class类的getDeclaredConstructor(Class<?> … parameterTypes)取得本类的指定形参类型的构造器
- 向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需要的的各个参数
- 通过Constructor实例化对象

public class NewInstanceTest {
public class NewInstanceTest {
    @Test
    public void test1() throws IllegalAccessException, InstantiationException {
        /**
         * newInstance()：调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
         * 要想此方法正常的创建运行时类的对象，要求：
         * 1. 运行时类必须提供空参的构造器
         * 2. 空参的构造器的访问权限得够。通常，设置为public。
         *
         * 在javabean中要求提供一个public的空参构造器。原因：
         * 1. 便于通过反射，创建运行时类的对象
         * 2. 便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
         */
        Class<Person> clazz = Person.class;
        Person p = clazz.newInstance();
        System.out.println(p);
    }

    @Test
    public void test2() throws Exception {
        //获取公共构造器，造对象
        Class<Person> cls = Person.class;
        Constructor<Person> cons = cls.getConstructor(String.class, int.class);
        Person p1 = cons.newInstance("Tom", 12);
        System.out.println(p1);

        //获取私有构造器，造对象
        Constructor<Person> cons1 = cls.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        Person p2 = cons1.newInstance("Jerry");
        System.out.println(p2);
    }

    /* 体会反射的动态性 */
    @Test
    public void test3() {
        for (int i = 0; i < 100; i++) {
            int num = new Random().nextInt(3);//0,1,2
            String classPath = "";
            switch (num) {
                case 0:
                    classPath = "java.util.Date";
                    break;
                case 1:
                    classPath = "java.lang.Object";
                    break;
                case 2:
                    classPath = "Person";
                    break;
            }
            try {
                Object obj = getInstance(classPath);
                System.out.println(obj);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /*创建一个指定类的对象*/
    public Object getInstance(String classPath) throws Exception{
        Class cls = Class.forName(classPath);
        return cls.newInstance();
    }
}

五、获取运行时类的完整结构

实现的全部接口

public Class<?>[] getInterfaces()：获取该Class对象所表示的类或接口所实现的接口。（不包括其父类所实现的接口）
所继承的父类

public Class<? Super T> getSuperclass()：返回表示此Class所表示的实体（类、接口、基本类型）的父类的Class
全部的构造器
- public Constructor<T>[] getConstructors()：返回此Class对象所表示的类的所有的public构造方法
- public Constructor<T>[] getDeclaredConstructors()：返回此 Class 对象表示的类声明的所有构造方法。
- public Constructor<T> getConstructor(Class<?>… parameterTypes)：按照指定的形参类型，返回此 Class 对象表示的类中所声明的带有指定形参列表的public构造器
- public Constructor<T> getDeclaredConstructor(Class<?>… parameterTypes)：按照指定的形参类型，返回此 Class 对象表示的类中所声明的带有指定形参列表的构造器（包括私有的构造器也能被获取）
  Constructor类中：
  - 取得修饰符：public int getModifiers()
  - 取得方法名称：public String getName()
  - 取得参数类型：public Class<?>[] getParameterTypes()
全部的方法
- public Method[] getDeclaredMethods()：返回此Class对象所表示的类或接口中声明的所有方法。（不包括父类中声明的方法）
- public Method[] getMethods()：返回Class对象所表示类或接口中声明为public的方法。（包括父类中声明为public的方法）
  Method类中：
  - 取得全部的返回值：public Class<?> getReturnType()
  - 取得全部的参数：public Class<?>[] getParameterTypes()
  - 取得修饰符：public int getModifiers()
  - 取得异常信息：public Class<?>[] getExceptionTypes()
全部的Field
- public Field getFields()：返回此Class对象所表示的类或接口中声明为public的Field。(包括父类中声明为public的属性)
- public Field getDeclaredFields()：返回此Class对象所表示的类或接口中声明的全部Field。（不包括父类中声明的属性）
  Field类中：
  - 以整数形式返回此Field的修饰符：public int getModifiers()
  - 得到Field的属性类型：public Class<?> getType()
  - 返回Field的名称：public String getName()
相关注解 Annotation
- getAnnotation(Class<T> annotationClass)
- getDeclaredAnnotations()
相关泛型
- 获取带有泛型的父类类型：Type getGenericSuperclass()
- 泛型类型：ParameterizedType
- 获取实际的泛型类型参数数组：Type[] getActualTypeArguments()
类所在的包

Packge getPackage()

六、获取运行时类的指定结构

调用指定方法
通过反射，调用类中的方法，通过Method类完成。步骤：
1. 通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
2. 之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
Object invoke(Object obj, Object … args)
- Object 对应原方法的返回值，若原方法无返回值，此时返回null
- 若原方法若为静态方法，此时形参Object obj可为null
- 若原方法形参列表为空，则Object[] args为null
- 若原方法声明为private，则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
调用指定属性
在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。
- public Field getField(String name) 返回此Class对象表示的类或接口的指定为public的Field。
- public Field getDeclaredField(String name) 返回此Class对象表示的类或接口的指定的Field。
在Field中：
- public Object get(Object obj) 取得指定对象obj上此Field的属性内容
- public void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容
获取指定的构造器
- public Constructor<T> getConstructor(Class<?>… parameterTypes)：按照指定的形参类型，返回此 Class 对象表示的类中所声明的带有指定形参列表的public构造器
- public Constructor<T> getDeclaredConstructor(Class<?>… parameterTypes)：按照指定的形参类型，返回此 Class 对象表示的类中所声明的带有指定形参列表的构造器（包括私有的构造器也能被获取）
使用得到的构造器
- 调用所得到的Constructor中的newInstance()方法，并传入指定的形参列表即可创建对应的实例。
关于 setAccessible 方法的使用
- Method和Field、Constructor对象都有setAccessible()方法。
- setAccessible启动和禁用访问安全检查的开关。
- 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
  - 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
  - 使得原本无法访问的私有成员也可以访问
- 参数值为false则指示反射的对象应该实施Java语言访问检查。

YangChongZhi

http://yczlab.top/posts/7ef4d58a.html

本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 YangChongZhi !

Java

Java中的动态代理(反射的应用)

引言：代理设计模式的原理：使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。对于静态代理，代理类和目标对象的类都是在编译期间确定下

2021-01-15 Java

Java

Java中的IO流

引言： I/O是Input/Output的缩写，I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。Java程序中，对于数据的输入/输出操作以“流(str

2021-01-14 Java

Java

引言：

一、反射机制概述

1、动态语言 vs 静态语言

2、反射机制所提供的功能

3、反射相关的主要 API

二、Class类的理解

1、Class类

2、Class类的常用方法

3、获取Class类的实例（四种方法）

4、哪些类型可以有Class对象

三、类的加载与ClassLoader

1、类的加载过程

2、类的初始化

3、类加载器的作用

四、创建运行时类的对象

五、获取运行时类的完整结构

六、获取运行时类的指定结构

你的赏识是我前进的动力