Java反射以及简单应用

Java反射以及简单应用

1.什么是反射机制？

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

2.什么是字节码文件？

.java文件经过虚拟机编译成.class文件，也叫字节码文件。对于一个字节码文件.class，虽然表面上我们对该字节码文件一无所知，但该文件本身却记录了许多信息。Java在将.class字节码文件载入时，JVM将产生一个java.lang.Class对象代表该.class字节码文件，从该Class对象中可以获得类的许多基本信息，这就是反射机制。

3.反射机制所需的类？

反射机制所需的类主要有java.lang包中的Class类和java.lang.reflect包中的Constructor类、Field类、Method类和Parameter类。Class类是一个比较特殊的类，它是反射机制的基础，Class类的对象表示正在运行的Java程序中的类或接口，也就是任何一个类被加载时，即将类的.class文件（字节码文件）读入内存的同时，都自动为之创建一个java.lang.Class对象。

4.反射的简单使用

（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()

（4）运行main方法的结果如下：

5.实例运用

如果你想在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的创建进行监控了。

感谢阅读！