写在前面
今天在需求评审的时候，遇到了挺有意思的要求。需求是什么样子就不说了。总之完成这个需求需要一个调用系统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一个类的时候这么方便，反而到了反射的时候会如此的麻烦？
public void fun() {
//第一种方式获取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;
try {
// 获取共有无参构造函数
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);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
继续理解
我们知道JVM在使用一个类的时候，会先去加载这个类。也就是生成唯一的Class对象。这个Class对象拥有我们的java代码的变量，方法结构。但是它并不是一个实例。因此我们在反射的时候，要先获取构造方法对象，也就是Class返回给我们的Constructor。此时我们运行这个对象的newInstance，我们就初始化了这个Class，获取了这个Class的实例。（这也就是为什么我们反射操作会如此的麻烦）
实例化了这个对象之后，虽然只是一个Object对象，但是它和我们真正new的对象没有任何区别，那么此时我们就可以正常的调用方法了。
我们知道，static是属于类，在类被加载的时候就已经出现了。那么此时，反射也侧面证实了这个问题：
在我们反射调用static的变量和方法时，set或者invoke的参数传的是null，也就是说我们没有传递任何对象实例，所以此时我们使用的是这个在类被加载时就被创建的Class对象中的变量和方法，而非操作的实例对象。因此，对static是不是有了一个更为深刻的理解呢？
尾声
时隔很久都还没有写博客了，是因为自己的确不知道该写些写什么，唉，迷茫，好菜...
希望可以对各位看官有所帮助吧。
我是一个应届生，最近和朋友们维护了一个公众号，内容是我们在从应届生过渡到开发这一路所踩过的坑，已经我们一步步学习的记录，如果感兴趣的朋友可以关注一下，一同加油~
个人公众号：IT面试填坑小分队
