【Java基础】Java 反射知识及实战

1、获取 Class 对象：通过 Class.forName() 方法获取要反射的类的 Class 对象。
2、获取 Method 对象：通过getMethod() 等方法获取要调用的方法的 Method 对象。
3、调用方法：method.invoke() 方法调用该方法（最终是由jvm执行invoke0()执行），可获取返回值。
4、获取 Field 对象：通过getField() 等方法获取要访问的属性的 Field 对象。
5、设置属性值：通过 Field.setAccessible(true) 方法将属性设置为可访问。然后可以通过 Field.get(object) 方法获取该属性的值。

Class clz = String.class;
//类的全路径名
Class clz = Class.forName("java.lang.String");
//使用类对象的 getClass() 方法
String str = new String("Hello");
Class clz = str.getClass();

package com.test.reflect;
public class User {
    private String userName = "无名氏";
    public int age;
    public String tag = "善";
    private ThingsAttribute attribute;
    public User() {
        attribute = new ThingsAttribute();
    }
    public User(String userName) {
        this.userName = userName;
    }
    public User(int age) {
        this.age = age;
        attribute = new ThingsAttribute();
    }
    public User(int age, String userName) {
        super();
        this.userName = userName;
        this.age = age;
        attribute = new ThingsAttribute();
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    private String getTag() {
        return tag;
    }
    public void setTag(String tag) {
        this.tag = tag;
    }
    public void draw(int count, String name) {
        System.out.println("draw " + name + ",count=" + count);
    }
    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                ", tag='" + tag + '\'' +
                ", attribute=" + attribute +
                '}';
    }
}

Class clz = String.class;
//类的全路径名
Class clz = Class.forName("java.lang.String");
//使用类对象的 getClass() 方法
String str = new String("Hello");
Class clz = str.getClass();

/**
         * 2、通过反射创建类对象
         *  无参数构造方法
         */
        //第一种方法，通过 Class 对象的 newInstance() 方法，
        //  Class 对象则只能使用默认的无参数构造方法
        User user = (User) clazz.newInstance();
        user.setAge(20);
        user.setUserName("盐蠢，30岁");
        System.out.println(user);
        //第二种：通过 Constructor 对象的 newInstance() 方法
        Constructor cs2 = clazz.getConstructor();
        user = (User) cs2.newInstance();
        user.setAge(30);
        System.out.println(user);
        /**
         * 2、通过反射创建类对象
         *    带参数构造方法
         *    通过 Constructor
         */
        // 获取带String参数的public构造函数
        Constructor cs1 = clazz.getConstructor(String.class);
        //创建User
        user= (User) cs1.newInstance("盐蠢");
        user.setAge(22);
        System.out.println("user1:"+user);

/**
         * 3、获取构造方法
         */
        // 获取带String参数的public构造函数
        cs1 =clazz.getConstructor(String.class);
        // 取得指定带int和String参数构造函数,该方法是私有构造private
        cs1=clazz.getDeclaredConstructor(int.class, String.class);
        // 获取所有构造包含private
        Constructor<?> cons[] = clazz.getDeclaredConstructors();
        // 获取所有public构造
        cons = clazz.getConstructors();

/**
         * 4、获取方法 及 方法执行
         */
        //根据参数获取public的Method,包含继承自父类的方法
        Method method = clazz.getMethod("draw", int.class, String.class);
        //获取所有public的方法:
        Method[] methods =clazz.getMethods();
        //获取当前类的方法包含private,
        Method method1 = clazz.getDeclaredMethod("getTag");
        //获取当前类的所有方法包含private,不 包含父类的方法
        Method[] methods1=clazz.getDeclaredMethods();
        /*
         * 通过Method对象的invoke(Object obj,Object... args)方法调用
         */
        method.invoke(user, 1, "x");
        //修改私有方法的访问标识
        method1.setAccessible(true);
        String result = (String) method1.invoke(user);
        System.out.println(result);

/**
         * 5、获取属性
         */
        //获取public 修饰的 指定字段名称的Field类，包含父类字段
        Field field = clazz.getField("age");
        //获取指定字段名称的Field类,（包括private）,注意 不 包含父类的字段
        Field field2 = clazz.getDeclaredField("userName");
        //获取所有修饰符为public的字段,包含父类字段
        Field fields[] = clazz.getFields();
        //获取当前类所字段(包含private字段),注意 不 包含父类的字段
        Field fields2[] = clazz.getDeclaredFields();
        /**
         * 6、修改属性值，或者说给内部属性赋值（替换）
         * set(Object obj, Object value)，用于设置字段的值，
         * get(Object obj)则是获取字段的值
         * 被final关键字修饰的Field字段是安全的，在运行时可以接收任何修改，但最终其实际值是不会发生改变的。
         */
        field.set(user, 34);
        // 因为是私有属性，必须设置其可访问性
        field2.setAccessible(true);
        field2.set(user, "盐蠢");
        //获取public 修饰的 指定字段名称的Field类，包含父类字段
        Field field3 = clazz.getField("tag");
        field3.set(user, "小白眼、gameover");
        //获取public 修饰的 指定字段名称的Field类，包含父类字段
        Field field4 = clazz.getDeclaredField("attribute");
        ThingsAttribute attribute = new ThingsAttribute();
        attribute.addAttribute("变坏了");
        attribute.addAttribute("因果轮回");
        /**
         * 替换内部变量
         */
        // 因为是私有属性，必须设置其可访问性
        field4.setAccessible(true);
        field4.set(user, attribute);
        System.out.println("after setField: "+user);

private static void hook(Toast toast) {
        if (Build.VERSION.SDK_INT != Build.VERSION_CODES.N_MR1) {
            return;
        }
        try {
            // 1、获取Class对象的引用
            Class<?> cls = Class.forName("android.widget.Toast");
            // 2、获取全局变量属性
            Field sField_N = cls.getDeclaredField("mTN");
            sField_N.setAccessible(true);
            // 3、获取mTN全局变量内部属性
            Field sField_TN_Handler = sField_N.getType().getDeclaredField("mHandler");
            sField_TN_Handler.setAccessible(true);
            // 4、返回指定对象上此 Field 表示的字段的值， 即 tn
            Object tn = sField_N.get(toast);
            // 5、返回指定对象上此 Field 表示的字段的值， 即 tn内部handler
            Handler handler = (Handler) sField_TN_Handler.get(tn);
            // 6、给handler赋一个新的值，用来处理 handler报错
            sField_TN_Handler.set(tn, new ReplaceHandler(handler));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static class ReplaceHandler extends Handler {
        private Handler tnHandler;
        public ReplaceHandler(Handler handler) {
            this.tnHandler = handler;
        }
        @Override
        public void handleMessage(Message msg) {
            try{
                tnHandler.handleMessage(msg);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

当原先的handler在执行 dispatchMessage时，会判断callback是否为空，不为空，则执行callback的handleMessage方法，也即我们新定义的callback，在这个callback内部，在继续原来的handler消息执行。
    /**
     * Handle system messages here.
     */
    public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

// class
                Class<?> aClass = Class.forName("android.app.ActivityThread");
                // 获取currentActivityThread 方法
                Method declaredMethod = aClass.getDeclaredMethod("currentActivityThread");
                declaredMethod.setAccessible(true);
                // 获取ActivityThread对象
                Object activityThread = declaredMethod.invoke(null);
                // 获取 currentActivityThread 对象中的mH 属性，即 Handler
                Field mH = aClass.getDeclaredField("mH");
                mH.setAccessible(true);
                // 原始ActivityThread mH对象
                Handler mHandler = (Handler) (mH.get(activityThread));
                // 获取原始callBack字段
                Field callbackField = Handler.class.getDeclaredField("mCallback");
                callbackField.setAccessible(true);
                // 由于 activity 生命周期都是通过主线程的 handler进行消息处理，
                // 所以，我们可以通过反射替换掉主线程 handler中的callback，（ActivityThread.mH.mCallback）
                // 然后，在callback的回调中 进行try catch, 同时调用原来handler的 handlemessage方法继续执行。
                callbackField.set(mHandler, new Callback() {
                    @Override
                    public boolean handleMessage(@NonNull Message msg) {
                        try {
                            // 捕获 Exception
                            mHandler.handleMessage(msg);
                        } catch (Exception e) {
                        }
                        return true;
                    }
                });