Java的反射(reflection)机制是指在程序的运行状态中,可以构造任意一个类的对象,可以了解任意一个对象所属的类,可以了解任意一个类的成员变量和方法,可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。
.java文件经过虚拟机编译成.class文件,也叫字节码文件。对于一个字节码文件.class,虽然表面上我们对该字节码文件一无所知,但该文件本身却记录了许多信息。Java在将.class字节码文件载入时,JVM将产生一个java.lang.Class对象代表该.class字节码文件,从该Class对象中可以获得类的许多基本信息,这就是反射机制。
反射机制所需的类主要有java.lang包中的Class类和java.lang.reflect包中的Constructor类、Field类、Method类和Parameter类。Class类是一个比较特殊的类,它是反射机制的基础,Class类的对象表示正在运行的Java程序中的类或接口,也就是任何一个类被加载时,即将类的.class文件(字节码文件)读入内存的同时,都自动为之创建一个java.lang.Class对象。
(1)创建一个实体类Teacher,里面的方法和变量都是私有的。
package com.fenght.jnitest;
public class Teacher {
private static String testStr;
private int age;
private String name;
private String adress;
private Teacher(int age, String name, String adress) {
this.age = age;
this.name = name;
this.adress = adress;
testStr = "测试静态方法";
}
private int getAge() {
return age;
}
private void setAge(int age) {
this.age = age;
}
private String getName() {
return name;
}
private void setName(String name) {
this.name = name;
}
private String getAdress() {
return adress;
}
private void setAdress(String adress) {
this.adress = adress;
}
private static String getTestStr(){
return testStr;
}
}
(2)通过反射去获取私有变量和调用私有的方法。
public static void main(String[] args) throws Exception{
Class<?> clazz = Class.forName("com.fenght.jnitest.Teacher");
Constructor constructor = clazz.getDeclaredConstructor(int.class,String.class,String.class);
constructor.setAccessible(true); //设置通道可用
//利用构造器生成对象
Object teacher = constructor.newInstance(25,"老夫子","月球");
System.out.println(teacher.toString());
//获取隐藏的int属性
Field ageField = clazz.getDeclaredField("name");
ageField.setAccessible(true);
String name = (String) ageField.get(teacher);
System.out.println("名字为:" + name);
//调用隐藏方法
Method method = clazz.getDeclaredMethod("getAge");
method.setAccessible(true);
int age = (int) method.invoke(teacher);
System.out.println("年龄为:" + age);
//调用静态方法
Method method1 = clazz.getDeclaredMethod("getTestStr");
method1.setAccessible(true);
String test = (String) method1.invoke(null);
System.out.println("调用静态方法:" + test);
}
(3)方法解释:
设置访问权限:setAccessible()
获取所有的构造方法:getDeclaredConstructor()
获取特定的构造方法:getDeclaredConstructor(参数类型.class,…)
获取成员变量:getDeclaredField()
获取特定的方法:getDeclaredMethod()
如果你想在Activity创建的时候做些监控或者进行操作等,你可以通过反射方法实现。
先看一下Android在进行页面跳转时候是如何创建Activity的。
Activity activity = null;
try {
java.lang.ClassLoader cl = appContext.getClassLoader();
activity = mInstrumentation.newActivity(
cl, component.getClassName(), r.intent);
StrictMode.incrementExpectedActivityCount(activity.getClass());
r.intent.setExtrasClassLoader(cl);
r.intent.prepareToEnterProcess();
if (r.state != null) {
r.state.setClassLoader(cl);
}
} catch (Exception e) {
if (!mInstrumentation.onException(activity, e)) {
throw new RuntimeException(
"Unable to instantiate activity " + component
+ ": " + e.toString(), e);
}
}
由上面ActivityThread源码可以看出,Activity是由mInstrumentation.newActivity()
返回的,那我们在看一下newActivity()方法。
public Activity newActivity(ClassLoader cl, String className,
Intent intent)
throws InstantiationException, IllegalAccessException,
ClassNotFoundException {
String pkg = intent != null && intent.getComponent() != null
? intent.getComponent().getPackageName() : null;
return getFactory(pkg).instantiateActivity(cl, className, intent);
}
在这个方法还是看不出Activity是怎么创建,只知道是getFactory(pkg).instantiateActivity()方法返回的,接着看下去:
public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
@Nullable Intent intent)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Activity) cl.loadClass(className).newInstance();
}
通过上面的方法就可以看出Activity是通过反射加载类文件实例化的。
因为的mInstrumentation.newActivity()
方法内部创建了Activity,那么我们可以通过反射将mInstrumentation替换成我们的Instrumentation,再重写newActivity()方法,这样就可以在Activity创建之前进行自己的操作。
我们先创建自己的Instrumentation类:
package com.fenght.jnitest.hook;
import android.app.Activity;
import android.app.Instrumentation;
import android.content.Intent;
import android.util.Log;
public class MyInstrumentation extends Instrumentation {
private Instrumentation base;
public MyInstrumentation(Instrumentation base) {
this.base = base;
}
//重写创建Activity的方法
@Override
public Activity newActivity(ClassLoader cl, String className, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
Log.e("fht","这是你自己的MyInstrumentation");
Log.e("fht","跳转的Activity = "+className+" intent="+intent);
return super.newActivity(cl, className, intent);
}
}
接着,通过反射去进行替换:
Class<?> activityThread=Class.forName("android.app.ActivityThread");
Method currentActivityThread=activityThread.getDeclaredMethod("currentActivityThread");
currentActivityThread.setAccessible(true);
//获取主线程对象
Object activityThreadObject=currentActivityThread.invoke(null);
//获取Instrumentation字段
Field mInstrumentation=activityThread.getDeclaredField("mInstrumentation");
//设置访问权限
mInstrumentation.setAccessible(true);
//获取Instrumentation实例
Instrumentation instrumentation= (Instrumentation) mInstrumentation.get(activityThreadObject);
MyInstrumentation myInstrumentation =new MyInstrumentation(instrumentation);
//替换掉原来的,就是把系统的instrumentation替换为自己的Instrumentation对象
mInstrumentation.set(activityThreadObject, myInstrumentation);
Log.e("fht","反射调用成功");
运行结果如下:
将方法写到Alication中就可以对Activity的创建进行监控了。