浅谈Java的反射机制

---

反射

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

---

Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！

一、反射的动态性

1.解释

所谓动态性就是在运行时代码可以根据某些条件改变自身结构，在编译的时候不确定要new谁，不确定到底要造哪一个类的对象，只有在运行的时候根据选择才确定new的对象。
就比如浏览器访问后台时，用户可能是选择登录，也可能选择注册，在用户选择登录的时候，后台就会根据产生登录类的对象，从而进行登录的一些操作，注册则也是一样的。

2.举例

如下代码来体现反射的动态性，根据0-2的随机数去创建对象，你会发现对于其对象的创建并不是在编译的时候就创建好的，而是在运行的时候创建的。

package com.atguigu.java;

import org.junit.Test;

import java.util.Random;

public class NewInstanceTest {
    //体会反射的动态性
    @Test
    public void test() throws Exception {

        for (int i = 0; i < 100; 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.java.Person";
                    break;
            }
			//创建类的对象实例
            Object obj = getInstance(classPath);
            System.out.println(obj);
        }

    }

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

运行结果:

二、理解Class类并获取Class的实例

1.Class类的介绍

在Object类中定义了以下的方法，此方法将被所有子类继承：
● public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。
对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构的有关信息(class/interface/enum/annotation/primitive type/void/[])。
从而反推，也就是说可以通过Class可以完整地得到一个类中的所有被加载的结构。
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象。

2.作为举例的Javabean代码

下面为之后作为举例的Javabean代码:

package com.atguigu.java;

public class Person {

    private String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

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

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

    private static void showDesc(){
        System.out.println("我是一个静态方法");
    }
}

3.获取Class类的实例(四种方法)

3.1 通过类的class属性获取

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

Class clazz1 = Person.class;

3.2 getClass()方法获取Class对象

已知某个类的实例，调用该实例的getClass()方法获取Class对象

Person p1 = new Person();
Class clazz2 = p1.getClass();

3.3 forName()获取Class对象

已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

//类的具体位置
Class clazz3 = Class.forName("com.atguigu.java.Person");

3.4 使用类的加载器:ClassLoader(了解)

ClassLoader classLoader = ReflectionTest.class.getClassLoader();
 Class clazz4 = classLoader.loadClass("com.atguigu.java.Person");

4.Class类的地址值

你可能会寻思，用这四种方式所获得的Class对象所对应的是一个对象吗？答案是，是。

System.out.println(clazz1 == clazz2);
System.out.println(clazz1 == clazz3);
System.out.println(clazz1 == clazz4);

将通过四种方式所得到的4种Class类对象进行对比输出之后，发现，全都为 true。也就是说，四种方法所对得到的Class类对象为同一个。

5.关于java.lang.Class类的理解

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

三、类的加载与ClassLoader的理解

1.类的加载过程

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

1.1加载

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

1.2链接

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

1.3初始化

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

2.举例

3.类加载器

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

4.类加载器的获取和用类加载器读取配置文件

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

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

    /*
    Properties:用来读取配置文件
     */
    @Test
    public void test2() throws Exception {
        Properties pros = new Properties();
        //此时的文件默认在当前的module下
        //读取配置文件的方式1:
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        pros.load(fis);

        //读取配置文件方式2:使用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);
    }
}

四、调用运行时类的指定结构

用反射去运行类中指定结构，不同于我们平时new一个对象去用点号调用类中的结构，后者受到了权限标识符的限制，比如私有的结构外部无法调用。
而反射只需要用 setAccessible(true)修改权限，外部就可以调用。

1.获取运行时类中的指定属性

@Test
    public void testField() throws Exception {
        Class<Person> clazz = Person.class;

        //1.创建运行时类的对象
        Person person = clazz.newInstance();

        //2.getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");

        //3.保证当前属性是可访问的
        name.setAccessible(true);

        //4.获取、设置指定对象的此属性值
        name.set(person,"Tom");

        String n = (String) name.get(person);

        System.out.println(n);

    }

2.获取运行时类中的指定方法

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

        //创建运行时类的对象
        Person p = clazz.newInstance();

        /*
        1.获取指定的某个方法
        getDeclaredMethod():参数1:指明获取的方法的名称  参数2:指明获取方法的形参列表
        */
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);

        //2.保证当前方法可访问
        showNation.setAccessible(true);

        /*
        3.调用方法的invoke()：参数1：方法的调用者 参数2：给方法形参赋值的实参
        invoke()的返回值即为对应类中调用方法的返回值
         */
        String chn = (String) showNation.invoke(p, "CHN");
        System.out.println(chn);

        System.out.println("*********如何调用静态的方法***********");

        //private static void showDesc()

        Method showDesc = clazz.getDeclaredMethod("showDesc");
        showDesc.setAccessible(true);
        //如果调用的运行类中的方法没有返回值，则此invoke()返回null
        Object returnVal = showDesc.invoke(Person.class);
        System.out.println(returnVal);//null


    }

3.获取运行时类中的指定构造器

@Test
    public void testConstruction() throws Exception {
        Class<Person> clazz = Person.class;

        //private Person(String name)
        /*
        1.获取指定的构造器
        getDeclaredConstructor():参数：指明构造器的参数列表
        */
        Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);

        //2.保证此构造器时可访问的
        constructor.setAccessible(true);

        //3.调用此构造器创建运行时类的对象
        Person per = constructor.newInstance("Tom");
        System.out.println(per);
    }

五、疑问

学完反射可能会有的两个疑问

疑问1：

通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用哪一个?
建议:直接new的方式(代码量少，简单直接)
什么时候用反射的方式:反射的动态性，在编译的时候不确定要new谁，不确定到底要造哪一个类的对象，比如浏览器访问后台时，用户可能是选择登录，也可能选择注册，在用户选择登录的时候，后台就会根据产生登录类的对象，从而进行登录的一些操作，注册则也是一样的

疑问2：

反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术?
答：不矛盾，封装性更多的是建议你去调用公共的结构，而不要去调用私有的结构，公共的结构更好，起到一个提醒的作用，比如说单例模式已经把对象提供给你了，没有必要去造其他对象，直接拿这个对象，就能完成你项目的需求，如果非要去调用其私有的构造器，和直接使用提供的现成的对象没有什么区别,没有必要。封装性表述的就是建议你去调什么，公共的去调用，私有的就不要去调了。而反射解决的是能不能去调的问题，就比如，交通规则提醒你不要去闯红灯过马路，红灯亮起的时候就提醒你不要过马路了，当然你仍然选择过马路，不过后果得自负。封装性和这红灯一样只是起到一个警示的作用，建议你最好的选择，而反射就像你的意识一样，可以做你想做的事，但不一定是最佳的。所以，不矛盾。

---