1. Java反射机制概述

1.1 概述

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

动态语言&静态语言

• 动态语言：是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。如：Object-C、C#、JavaScript、PHP、Python、ErLang
• 静态语言：与动态语言相对应，运行时不可以改变自身的语言就是静态语言。如：Java、C、C++

1.2 Java反射机制的研究及应用

• Java反射机制提供的功能

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

• 反射相关的主要API

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

@Test
public void test2() throws Exception {
    // 3. 通过反射创建对象
    Class clazz = Person.class;
    Constructor constructor = clazz.getConstructor(String.class, int.class);
    Object obj = constructor.newInstance("Tom", 12);
    Person p = (Person) obj;
    System.out.println(p.toString());
    // 2. 通过反射调用指定的属性和方法
    // 调用属性
    Field age = clazz.getDeclaredField("age");
    age.set(p, 10);
    System.out.println(p.toString());
    // 调用方法
    Method show = clazz.getDeclaredMethod("show");
    show.invoke(p);
    // 3. 调用私有结构
    // 私有构造器
    Constructor con1 = clazz.getDeclaredConstructor(String.class);
    con1.setAccessible(true);
    Person p1 = (Person) con1.newInstance("Jerry");
    System.out.println(p1);
    // 私有属性
    Field name = clazz.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p1, "hxuanyu");
    System.out.println(p1);
    // 私有方法
    Method showNation = clazz.getDeclaredMethod("showNation", String.class);
    showNation.setAccessible(true);
    showNation.invoke(p1, "中国");
}

运行结果：

Person{name='Tom', age=12}
Person{name='Tom', age=10}
我是一个人
Person{name='Jerry', age=0}
Person{name='hxuanyu', age=0}
我的国籍是中国

2. 理解Class类并获取Class类实例*

2.1 CLass类

在Object类中定义了以下的方法，此方法将被所有子类继承

• public final Class getClass()：方法的返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

• 对象反射后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构的有关信息。

  • Class本身也是一个类
  • Class对象只能由系统创建
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的是一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何想动态加载、运行的类，唯有先获得相应的Class对象

2.2 获取Class类的实例

• 类名.class

  • 前提：前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
  • 实例：Class clazz = String.class;

• 实例.getClass()

  • 前提：一直某个类的实例，调用该实例的getClass()方法获取Class对象
  • 实例：Class calzz = "hello".getClass();

• Class.forName("全类名")

  • 前提：一直一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException异常
  • 实例：Class clazz = Class.forName("java.lang.String");

• 其他方式：

  • ClassLoader cl = this.getClass().getClassLoader();
  • Class clazz = cl.loadClass("java.lang.String");

2.3 拥有Class对象的类

• class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
• interface：接口
• []：数组，只要数组类型与维度一样，就是同一个Class
• enum：枚举
• annoation：注解
• primitive：基本数据类型
• void

3. 类的加载与ClassLoader的理解

3.1 类的加载过程

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

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

• 类的链接（Link）：将类的二进制数据合并到JRE中。

  • 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
  • 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配
  • 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

• 类的初始化（initialize）：JVM负责对类进行初始化

  • 执行类构造器方法的过程。类构造器是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）
  • 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
  • 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步

什么时候会发生类的初始化？

• 类的主动引用（一定会发生类的初始化）

  • 当虚拟机启动，先初始化main方法所在的类
  • new一个类的对象
  • 调用类的静态成员（除了final常量）和静态方法
  • 使用java.lang.reflect包的方法对类进行反射调用
  • 当初始化一个类，如果其父类没有被初始化，则会先初始化它的父类

• 类的被动引用（不会发生类的初始化）

  • 当访问一个类的静态域时，只有真正声明这个域的类才会被初始化，当通过子类引用父类的静态变量，不会导致子类初始化
  • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中）

类加载器的作用：

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

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

@Test
public void test1() {
    ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    System.out.println(classLoader);// AppClassLoader

    ClassLoader classLoader1 = classLoader.getParent();
    System.out.println(classLoader1);// ExtClassLoader

    ClassLoader classLoader2 = classLoader1.getParent();
    System.out.println(classLoader2);// null

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

3.2 使用ClasLoader加载Java配置文件

@Test
public void test2() {
    Properties pros = new Properties();
    InputStream is = null;
    try {

        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        // 读取的文件在src文件夹下
        is = classLoader.getResourceAsStream("jdbc.properties");
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");

        System.out.println("user = " + user + "\npassword = " + password);

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (is != null) {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

配置文件默认识别为当前module的src下，与使用FileInputString直接读取不同

4. 创建运行时类的对象*

有了Class对象，能做什么？

创建类的对象：调用Class对象的newInstance()方法，要求：

• 类必须有一个无参构造器
• 类的构造器的访问权限要足够

没有无参构造器如何创建对象？

只要在操作的时候明确调用类的构造器，并将参数传递进去之后，才可以实例化操作。步骤如下：

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

@Test
public void test1() throws InstantiationException, IllegalAccessException {
    Class<Person> clazz = Person.class;
    // newInstance(): 调用此方法创建对应运行时类的对象，默认调用空参构造器
    Person person = clazz.newInstance();
    System.out.println(person);
}

5. 获取运行时类的完整结构

5.1 实现的全部接口

public Class<?>[] getInterfaces()，确定此对象所表示的类或接口实现的接口

@Test
public void test3() {
    Class clazz = Person.class;
    Class[] interfaces = clazz.getInterfaces();
    System.out.println(Arrays.toString(interfaces));
    System.out.println("***********");
    // 获取运行时类父类实现的接口
    Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
    System.out.println(Arrays.toString(interfaces1));
}

5.2 所继承的父类

public Class<? Super T> getSuperClass()，返回表示此Class所表示的实体（类、接口、基本类型）的父类的Class

@Test
public void test2() {
    Class clazz = Person.class;
    Class superclass = clazz.getSuperclass();
    System.out.println(superclass);
}

5.3 全部的构造器：

• public Constructor<T>[] getConstractors()：返回此Class对象所表示的类的所有public构造方法
• public Constructor<T>[] getDeclaredConstructors()：返回此Class对象表示的类声明的所有构造方法

• Constructor类中：

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

@Test
public void test1() {
    Class clazz = Person.class;

    Constructor[] constructors = clazz.getConstructors();
    for (Constructor constructor : constructors) {
        System.out.println(constructor);
    }
    System.out.println("************");
    Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    for (Constructor c : declaredConstructors) {
        System.out.println(c);
    }
}

5.4 全部的方法：

• public Method[] getDeclaredMethods()：返回此Class对象所表示的类或接口的全部方法
• public Method[] getMethods()：返回此Class对象所表示的类或接口及其父类的public方法

• Method类中：

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

public class MethodTest {
    @Test
    public void test1() {
        Class clazz = Person.class;
        // 获取方法结构
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("******************");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
    }

    /**
     * 获取权限修饰符、返回值类型、方法名、参数列表、异常信息、注解及注解的值
     */
    @Test
    public void test2() {
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m : declaredMethods) {
            // 1. 获取注解
            Annotation[] annotations = m.getAnnotations();
            System.out.println("注解：" + Arrays.toString(annotations));
            // 2. 权限修饰符
            System.out.println("修饰符：" + Modifier.toString(m.getModifiers()));
            // 3. 返回值类型
            Class<?> returnType = m.getReturnType();
            System.out.println("返回值类型：" + returnType.getName());
            // 4. 方法名
            System.out.println("方法名：" + m.getName());
            // 5. 参数列表
            Class<?>[] parameterTypes = m.getParameterTypes();
            System.out.println("参数列表：" + Arrays.toString(parameterTypes));
            // 6. 异常信息
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            System.out.println("异常信息：" + Arrays.toString(exceptionTypes));

            System.out.println("******************************");
        }
    }
}

5.5 全部的Field

• public Field[] getFields()：返回此Class对象所表示的类或接口的public的Field，包括父类
• public Field[] getDeclaredFields()：返回此Class对象所表示的类或接口的全部Field，不包括父类

• Field类中：

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

public class FieldTest {
    /**
     * 获取类的属性
     */
    @Test
    public void test1() {
        Class clazz = Person.class;
        // 获取属性结构
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("*************");
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
    }

    /**
     * 获取权限修饰符
     */
    @Test
    public void test2() {
        Class clazz = Person.class;

        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            // 1. 权限修饰符
            System.out.print(Modifier.toString(declaredField.getModifiers()) + "\t");
            // 2. 数据类型
            System.out.print(declaredField.getType().getName() + "\t");
            // 3. 变量名
            System.out.println(declaredField.getName());
        }
    }

}

5.5 Annotation相关

• getAnnotation(CLass<T> annotationClass)
• getDeclaredAnnotations()

@Test
public void test5() {
    Class clazz = Person.class;
    Annotation[] annotations = clazz.getAnnotations();
    System.out.println(Arrays.toString(annotations));
}

5.6 泛型相关

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

5.7 类所在的包

Package getPackage()

@Test
public void test4() {
    Class clazz = Person.class;
    Package aPackage = clazz.getPackage();
    System.out.println(aPackage);
}

• 在实际操作中，取得类的信息的操作代码，并不会经常开发
• 一定要熟悉java.lang.reflect包的作用，反射机制
• 如何取得属性、方法、构造器的名称、修饰符等

6. 调用运行时类的指定结构*

6.1 调用指定方法

通过反射，调用类中的方法，通过Method类完成。步骤：

• 通过Class类的getMethod(String name, Class... parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
• 之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息

说明：

• Object对应原方法的返回值，若原方法无返回值，此时返回null
• 若原方法为静态方法，此时形参Object[] obj可为null
• 若原方法形参列表为空，则Object[] args为null
• 若原方法声明为private，则需要在调用此invoke()方法前，显示调用方法对象的setAccessible(true)方法，将可访问private的方法

@Test
public void testMethod() throws Exception {
    Class clazz = Person.class;
    Person p = (Person) clazz.newInstance();

    // 调用方法
    Method show = clazz.getDeclaredMethod("show", String.class);
    show.setAccessible(true);
    Object invoke = show.invoke(p, "中国");
    System.out.println(invoke);
    System.out.println("****************");
    // 调用静态方法
    Method showDesc = clazz.getDeclaredMethod("showDesc");
    showDesc.setAccessible(true);
    Object invoke1 = showDesc.invoke(Person.class);
    System.out.println(invoke1);
}

6.2 调用指定属性

在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作

• public Feld 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的属性内容

@Test
public void testField() throws NoSuchFieldException, InstantiationException, IllegalAccessException {
    Class clazz = Person.class;
    // 创建运行时类的对象
    Person p = (Person) clazz.newInstance();

    // 设置指定的属性
    Field id = clazz.getDeclaredField("id");
    id.set(p, 1001);
    Field name = clazz.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p, "Tom");
    Field age = clazz.getDeclaredField("age");
    age.set(p, 20);

    // 获取指定的属性
    int pId = (int) id.get(p);
    System.out.println("pId: " + pId);
    String pName = (String) name.get(p);
    System.out.println("pName: " + pName);
    int pAge = (int) age.get(p);
    System.out.println("pAge: " + pAge);
  
    System.out.println(p);
}

关于setAccessible方法的使用

• Method和Field、Constructor对象都有setAccessible()方法
• setAccessible()启动和禁用访问安全检查的开关

• 参数值为true则指示反射的对象在使用时应取消Java语言访问检查。

  • 提高反射的效率。如果代码中必须使用反射，而该句代码需要频繁被调用，则应设置为true
  • 是的原本无法访问的私有成员也可以访问
• 参数值为false则指示反射的对象应该实施Java语言访问检查