Java高级之注解、反射

刘兆贤

已于 2024-10-15 11:20:45 修改

阅读量2.5k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Java高级文章标签： java servlet 开发语言

于 2017-07-12 16:14:56 首次发布

本文链接：https://blog.csdn.net/reboot123/article/details/75021286

Java高级专栏收录该内容

26 篇文章

订阅专栏

本文探讨Java注解和反射的应用，包括它们在动态代理、代码注入和元编程中的角色。讲解了注解的保留策略，以及如何利用反射进行类、方法和变量的动态操作。文中以Android点击事件hook为例，展示了反射在实战中的应用，同时提及ASM库在字节码级别的操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文来自刘兆贤的博客_CSDN博客-Java高级,Android旅行,Android基础领域博主，引用必须注明出处！

Java的注解、反射等机制的产生，让动态代理成为可能，一般通过全限定名+类名，找到类，可以invoke它的构造方法以及其他方法，可以获取它的参数（Field）名称和值。

注解一般用在代码的注释上、代码审查上（有没有按标准写，比如inspect）、代码注入（hook，asbectj），需要考虑的是，在何时注入（编译期还运行期）

基础反射：获取类的变量名和变量值

    public static Map<String, Object> toMap(Object obj) {
        Map<String, Object> reMap = new HashMap<>();
        Class<?> clz = obj.getClass();//获取此对象运行期的Class对象
        while (clz != null) {
            Field[] fields = clz.getDeclaredFields();//获得类里声明的变量
            for (Field field : fields) {
                try {
                    String fieldName = field.getName();//获得变量名称
                    if (!extraParam(fieldName)) {
                        Field f = clz.getDeclaredField(fieldName);
                        f.setAccessible(true);
                        Object o = f.get(obj);//获得变量值
                        reMap.put(fieldName, o);
                    }
                } catch (NoSuchFieldException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            clz = clz.getSuperclass();//获得父类的Class对象，继续递归
        }
        return reMap;
    }

    private static boolean extraParam(String fieldName) {
        //以下三种变量，通常不需要写入
        return fieldName.equals("serialVersionUID")//用于根据变量产生，在恢复本地文件时，如果id不同，则类不同，就不需要再恢复（说明缓存已经过期）
                || fieldName.equals("shadow$_klass_")//API20以后出现，运行期对象的Class变量
                || fieldName.equals("shadow$_monitor_");//API20以后出现
    }

反射一般用在动态将json和Object互相转化，执行相关底层代码，比如设置某个类的Accessible为false，防止别人hook修改

例：阿里的FastJson解析：
@Override public <T> T json2Object(String json, Class<T> clazz) {

return JSON.parseObject(json, clazz);

}

@Override public String object2Json(Object instance) {

return JSON.toJSONString(instance);

}

例Java的默认注解策略：

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.

	默认，编译时被抛弃
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.

	默认被编译器保解释，但在运行时抛弃
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *

       被编译时解释，运行时仍保存，可以直接被使用
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

1、RetentionPolicy.SOURCE：注解只保留在源文件，当Java文件编译成class文件的时候，注解被遗弃(如Override，用于代码格式检查)；

2、RetentionPolicy.CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期（如RequiresApi，指在固定API以上版本可用，用作提醒）；

3、RetentionPolicy.RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在（如EventBus的Subscribe订阅事件，当成正常代码使用）；

使用范围：

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

例Hook：

hook一事看似神秘，其实并不是那么难，希望各位看官看过本文之后能有所收获。

本次是hook Android的点击事件，也就是OnClickListener，hook的意义在于你能在调用setOnClickListener后做些其他的事，其他一些你想和所有点击事件一起处理的事，那么在这里，我就以埋点为例吧。

先来展示下效果：

public void onClick(View view) {
    Map map = new HashMap();
    switch (view.getId()) {
      case R.id.btn_hook1:
        map.put("巴", "掌");
        map.put("菜", "比");
        break;
      case R.id.btn_hook2:
        map.put("TF-Boys", "嘿嘿嘿");
        map.put("id", "111");
        break;
    }
    view.setTag(R.id.id_hook, map);
}

我在onClick内干了三件事：

1、new HashMap

2、map塞你想埋点的数据

3、把数据传到对应的view里

然后点击按钮会弹出一个Toast

那么有意思的地方来了，我们并没有在点击事件里弹Toast，那这个Toast哪来的呢？嘿嘿嘿，当然是hook的啦。

Hook

下面开始hook过程：

整个过程浓缩下来就是四个字--移花接木！

分析源代码

首先来看看android.view.View中的这块代码，mOnClickListener变量静静的在这里(这里还有别的事件哦，比如OnLongClickListener等，大家学完之后可以试着hook下别的)，我们需要做的就是移花接木，把自己的花替换掉这个木，mOnClickListener是ListenerInfo这个类的成员变量，那继续看看ListenerInfo在View的哪里被初始化了，因为我们最开始拿到的只有View这一个对象。

没错，找到了，getListenerInfo()干了这件事，我们从这个方法入手先把ListenerInfo拿下，然后再移花接木。

技术方案已经有了，那么就开始着手撸码。

实现

hook的过程就是充分利用java反射机制的过程，几行代码搞定，我们来看看：

//先拿下View的Class对象
Class clazzView = Class.forName("android.view.View");
//再把getListenerInfo拿到
Method method = clazzView.getDeclaredMethod("getListenerInfo");
//由于getListenerInfo并不是pulic方法，所以需要修改为可访问
method.setAccessible(true);
//继续拿下ListenerInfo内部类的Class对象
Class clazzInfo = Class.forName("android.view.View$ListenerInfo");
//拿到主角mOnClickListener成员变量
Field field = clazzInfo.getDeclaredField("mOnClickListener");
//截止到这，我们已经完成了百分之95了，只剩最后一步，那就是把我们的木接进来
//那么这里先暂时停留下，我们把木给创建好。
//挖个坑 --> 待会填

由于移花接木有个本质不能忘，那就是尊重原有类型，因此，我们的木也得实现View.OnClickListener接口：

public static class HookListener implements View.OnClickListener {

    private View.OnClickListener mOriginalListener;

    //直接在构造函数中传进来原来的OnClickListener
    public HookListener(View.OnClickListener originalListener) {
      mOriginalListener = originalListener;
    }

    @Override public void onClick(View v) {
      if (mOriginalListener != null) {
        mOriginalListener.onClick(v);
      }
      StringBuilder sb = new StringBuilder();
      sb.append("hook succeed.\n");
      //拿到之前传递的参数
      Object obj = v.getTag(R.id.id_hook);
      //下面的操作可以猥琐欲为了
      if (obj != null && obj instanceof HashMap && !((Map) obj).isEmpty()) {
        for (Map.Entry<String, String> entry : ((Map<String, String>) obj).entrySet()) {
          sb.append("key => ")
              .append(entry.getKey())
              .append(" ")
              .append("value => ")
              .append(entry.getValue())
              .append("\n");
        }
      } else {
        sb.append("params => null\n");
      }

      Toast.makeText(v.getContext(), sb.toString(), Toast.LENGTH_LONG).show();
    }
}

以上代码就是我们的木，为了看起来更简单，我直接通过构造函数把原来的花（OnClickListener）给传过来了，然后在新的HookListener的onClick()里把原来的事件继续完成，并加上自己想猥琐欲为的一些事情。

那么继续填上之前埋的坑：

field.set(listenerInfo, new HookListener((View.OnClickListener) field.get(listenerInfo)));

接木的过程干了两件事，一个是把原有的OnClickListener传给HookListener，二是把新的HookListener替换进ListenerInfo，perfect。

至此，移花接木就完成了，简单吧。

合适的调用hook

我们把hook方法都写好了，最后就是调用你需要hook的View了，在大多数情况下，你可以把hook这件事交给Base去做，遍历当前rootView所有的View，然后每个都调用hook，本文的重点不是这，我就不赘述了。

小结

本文仅仅以埋点为例，= = 其实我觉得埋点这个栗子并不太好，妹的都传了这么多参数过来了，还在乎在这里调用一下自己的tracker？不管了，没有栗子会让本次hook感觉很无力，希望各位同学看过后能对hook不再懵逼，其实和自定义View一样简单的啦。

ASM：

跳过源码，直接修改字节码，用于增加或修改类的属性、方法等。

方式：向源代码中，直接注入特定代码，称为字节码插桩。

使用场景：热修复、事件监听、埋点框架等。

参考：

GitHub - JeasonWong/ClickTracker: easy to hook onClick event.

https://www.runoob.com/w3cnote/java-annotation.html