深入理解Java反射

写在前面

今天在需求评审的时候，遇到了挺有意思的要求。需求是什么样子就不说了。总之完成这个需求需要一个调用系统api的操作。然而这个api因为并不稳定的原因。被谷歌hide掉了。
这个时候我们最直接的方式就是去通过反射去调用这个系统api。（当然这种方式治标不治本，因为既然被hide，就说明这个api很不稳定。所以这个版本可以用，有可能下个版本就没了）
不过这里我们不考虑这个问题，因为如题所说，这次主角是反射。
之前在用反射的时候，其实并没有去思考反射所带来的东西。而这次在用反射的时候，开始去思考为什么要这么用，它和Java的运行机制有什么关系。
我们在看JVM的时候：多少都能了解到Java的类加载机制，那就是我们在new一个对象的时候，JVM会先使用双亲委派机制去加载这个class文件，class文件的代码结构会被封装成Class对象唯一的出现在方法区中。然后才是我们的实例对象创建到堆中。
之前我去上述的理解没有任何概念，仅仅是当做文字给记了下来。直到我今天在使用反射的时候，突然对上述的概念有了实质性的认识。
不过不着急，让我们一点点的深入….

进入正文

声明一个类

首先我们先声明一个class，内部包含了另一个对象，并且写了一些私有/公有/静态的变量及方法，一会将针对这个class进行反射的操作：

这里的日志使用了Log是Android里的打印输出，而非Java中的System.out.print。

public class ReflectModel {
    private ReflectBean mReflectBean;
    private String mContent = "A";
    public int mNum = 1;
    public static int sNum = 666;

    public ReflectModel() {
        LogUtils.d(TAG, "ReflectModel()，无参构造方法执行");
    }

    public ReflectModel(String content) {
        LogUtils.d(TAG, "ReflectModel(String content)，一个String参数的构造方法执行");
        mContent = content;
    }

    private ReflectModel(String content, int num) {
        LogUtils.d(TAG, "ReflectModel(String content,int num)，俩个参数的私有构造方法执行");
        mContent = content;
        mNum = num;
    }

    public void fun() {
        LogUtils.d(TAG, "我就是一个方法，在本例子中。我是被反射生成的对象调用的->mContent:" + mContent + "-mNum:" + mNum);
    }

    private void printContent() {
        LogUtils.d(TAG, "我就是私有的打印方法->mContent:" + mContent + "-mNum:" + mNum);
    }

    private void setContent(String content) {
        LogUtils.d(TAG, "我就是一个带有一个String参数的私有方法->setContent:" + content);
        mContent = content;
    }

    public void printBean() {
        LogUtils.d(TAG, "我是ReflectBean的打印方法->mName:" + mReflectBean.getName());
    }

    public static void staticFun() {
        LogUtils.d(TAG, "我是静态方法staticFun");
    }
}

内部的ReflectBean类

public class ReflectBean {
    private String mName = "a";

    public ReflectBean(String name) {
        mName = name;
    }

    public String getName() {
        return mName;
    }
}

获取拥有真正对象代码结构的Class：

不知道各位小伙伴们有没有思考过，为什么我们new一个类的时候这么方便，反而到了反射的时候会如此的麻烦？

    //第一种方式获取Class对象：产生一个Student对象的实例，以及一个唯一的Class对象。
    ReflectModel model1 = new ReflectModel();
    //获取Class对象：这种方式没什么意义，既然有了对象的实例，何必再去反射
    Class modelClass = model1.getClass();

    //第二种方式获取Class对象：需要我们导包，但是有些时候这个类是隐藏的（比如很多系统不稳定的类，@Hide）
    Class modelClass2 = ReflectModel.class;

    Class modelClass3 = null;
    try {
        //第三种方式获取Class对象：类的全路径
        modelClass3 = Class.forName("com.example.mbenben.studydemo.basenote.reflect.ReflectModel");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

将Class实例化

//开始进行具体内部操作，此时我们仅仅是拿到了ReflectModel的class这个对象，而非是这个ReflectModel对象的实例
if (modelClass3 != null) {
     //获取ReflectModel.class对应的所有构造方法(public的)
     Constructor[] constructors = modelClass3.getConstructors();
     for (Constructor constructor : constructors) {
         LogUtils.d(TAG, "当前获取的构造方法：" + constructor.getName());
     }
     LogUtils.d(TAG, "----以上是public的----");
     //所有构造方法(包括：私有、受保护、默认、公有)
     constructors = modelClass3.getDeclaredConstructors();
     for (Constructor constructor : constructors) {
         LogUtils.d(TAG, "当前获取的构造方法：" + constructor);
     }

     Object object = null;
     // 获取共有无参构造函数
     Constructor con = modelClass3.getConstructor(null);
     // 调用此无参构造方法，那么此时我们就会获取到Reflect的实例对象了(默认返回object)
     ReflectModel reflectModel = (ReflectModel) con.newInstance();
     // 有了ReflectModel对象实例，我们就可以正常使用了
     /**
      * 但是此时我们知道，我们强制类型转成了我们想要的类型，但是我们上文中提到，有些类是hide的。
      * 因此我们很多情况下，我们被限制只能得到object对象。
     */
     reflectModel.fun();
     // 获取私有的含有String和int参数的构造方法
     con = modelClass3.getDeclaredConstructor(new Class[]{String.class, int.class});
     // 此时我们获取到了这个private的含参构造方法对象，但是因为private权限原因，我们没办法直接调用newInstance()
     // 我们需要调用下面的方法，无视private修饰符（调用后，我们就可以执行private的构造方法）
     con.setAccessible(true);
     //调用私有俩参构造方法
     object = con.newInstance("B", 2);
}

---

反射调用方法

     //上述提到，如果我们反射的类是hide，此时我们肯定没办法把Object转成ReflectModel类型。
     //因此，我们拿到这个实例后想要调用其方法，还需要使用反射的方式private方法应该使用getDeclaredMethod()去获取
     Method printContent = modelClass3.getDeclaredMethod("printContent", new Class[]{});
     //同样因为private的原因，我们在执行方法时，要先清除权限问题
     printContent.setAccessible(true);
     //使用object实例对象，调用printContent方法，因为没有参数，所以传null
     printContent.invoke(object, null);
     //生成名为setContent的含有一个String参数的方法对象
     Method setContent = modelClass3.getDeclaredMethod("setContent", new Class[]{String.class});
     setContent.setAccessible(true);
     //调用setContent方法，去改变mContent的值
     setContent.invoke(object, "C");
     //再次执行打印操作
     printContent.invoke(object, null);

     //调用静态方法
     Method staticMethod = modelClass3.getMethod("staticFun", new Class[]{});
     //因为静态方法属于类，所以我们不需要传实例对象，因为它在class被加载的时候，就已经被创建了。
     staticMethod.invoke(null, null);

反射调用变量/static

    /**
     * 反射调用变量
     */
    //获取所有public变量封装的Field对象
    Field[] fields = modelClass3.getFields();
    //获取所有变量封装的Field对象
    fields = modelClass3.getDeclaredFields();

    //获取private的mContent的变量
    Field content = modelClass3.getDeclaredField("mContent");
    content.setAccessible(true);
    Field num = modelClass3.getField("mNum");
    num.set(object, 3);
    //获取static变量
    Field sNum = modelClass3.getField("sNum");
    LogUtils.d(TAG, "mNum在object实例对象中的值:" + num.get(object) + "-static变量sNum的值:" + sNum.get(null));
    //将object实例的mContent对象，设置为D
    content.set(object, "D");
    printContent.invoke(object, null);

    Field reflectBean = modelClass3.getDeclaredField("mReflectBean");
    Class reflectBeanClass = Class.forName("com.example.mbenben.studydemo.basenote.reflect.ReflectBean");
    Constructor beanCon = reflectBeanClass.getConstructor(new Class[]{String.class});
    Object beanObject = beanCon.newInstance("b");
    //给mReflectBean赋值
    reflectBean.setAccessible(true);
    reflectBean.set(object, beanObject);
    Method printBean = modelClass3.getMethod("printBean", new Class[]{});
    printBean.invoke(object, null);

继续理解

我们知道JVM在使用一个类的时候，会先去加载这个类。也就是生成唯一的Class对象。这个Class对象拥有我们的java代码的变量，方法结构。但是它并不是一个实例。因此我们在反射的时候，要先获取构造方法对象，也就是Class返回给我们的Constructor。此时我们运行这个对象的newInstance，我们就初始化了这个Class，获取了这个Class的实例。（这也就是为什么我们反射操作会如此的麻烦）

实例化了这个对象之后，虽然只是一个Object对象，但是它和我们真正new的对象没有任何区别，那么此时我们就可以正常的调用方法了。

我们知道，static是属于类，在类被加载的时候就已经出现了。那么此时，反射也侧面证实了这个问题：
在我们反射调用static的变量和方法时，set或者invoke的参数传的是null，也就是说我们没有传递任何对象实例，所以此时我们使用的是这个在类被加载时就被创建的Class对象中的变量和方法，而非操作的实例对象。因此，对static是不是有了一个更为深刻的理解呢？

尾声

时隔很久都还没有写博客了，是因为自己的确不知道该写些写什么，唉，迷茫，好菜…

---

我是一个应届生，最近和朋友们维护了一个公众号，内容是我们在从应届生过渡到开发这一路所踩过的坑，已经我们一步步学习的记录，如果感兴趣的朋友可以关注一下，一同加油~