hook控制浏览器的方法_Java-Hook技术-入门实践+反射、动态代理、热修复再看看

延续之前的MonkeyLei：Android-模块化、组件化、插件化、热修复-插件化-起个头，我们复习下里面的关于反射和动态代理点的知识。然后尝试简单了解下Hook...

看之前文章，记得多复习下反射代理，比如使用这些....：

  public class Proxy
extends Object
implements Serializable
Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

To create a proxy for some interface Foo:

     InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });
 
or more simply:
     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

多多实践。之后我们尝试建一个Android工程，但是先用Java main方法来做相关Hook测试。后面再尝试结合Hook Android的东西.SO..开始吧...

Then，看下Hook基本介绍吧...

一、什么是 Hook 技术
  Hook 技术又叫做钩子函数，在系统没有调用该函数之前，钩子程序就先捕获该消息，钩子函数先得到控制权，这时钩子函数既可以加工处理（改变）该函数的执行行为，还可以强制结束消息的传递。简单来说，就是把系统的程序拉出来变成我们自己执行代码片段。
  要实现钩子函数，有两个步骤：
  1. 利用系统内部提供的接口，通过实现该接口，然后注入进系统（特定场景下使用）
  2.动态代理（使用所有场景）

二、Hook 技术实现的步骤
  Hook 技术实现的步骤也分为两步
  1.找到 hook 点（Java 层），该 hook 点必须满足以下的条件：需要 hook 的方法，所属的对象必须是静态的，因为我们是通过反射来获取对象的，我们获取的是系统的对象，所以不能够 new 一个新的对象，必须用系统创建的那个对象，所以只有静态的才能保证和系统的对象一致。
  2.将 hook 方法放到系统之外执行（放入我们自己的逻辑）

我就以我觉得的比较简单的方式来理解一下Hook，我要实现的功能是：

1. 继承某个可以继承的对象，然后重写某个方法，添加中间处理，比如验证等。完事了既可以用super调用父类的方法.

2. 然后用这个新的对象变量替换掉原有的变量，实现对象变量的动态替换

3. 重点也就是Field、Proxy的基本使用

直接看测试代码 - HookTestMain.java

package com.skl.hooktest;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class HookTestMain {

    private static class MyView{
        // 通过反射替换对象的该对象变量
        private MyTestView myTestView; // = new MyTestView();

        static class MyTestView{
            public void test(){
                System.out.println("啊啊啊");
            }
        }

        // 通过Proxy生成代理对象，然后替换该变量
        private ProcInterface other2;
    }

    /**
     * 重写旧有的某个方法，作为新的对象注入替换掉MyView的myTestView变量
     */
    private static class Other extends MyView.MyTestView{
        @Override
        public void test(){
            System.out.println("BBBBB");
            super.test();
        }
    }


    /**
     * Proxy生成代理对象必须是某个接口
     */
    private interface ProcInterface{
        void test();
    }

    public static void main(String[] args){
        try {
            // 创建一个对象 - 我们即将替换这个对象的某个变量，达到替换方法的效果；
            // --我是不是可以想象一下，如果要做方法热修复，是不是也可以呢？
            // --但是这个是限于我们有该对象的前提，如果是其他情况，可能就需要你去找到某个对象 它的某个方法，进而实现替换？
            MyView myView = new MyView();
            // myView.myTestView.test();

            // 这是内部静态类类的表示方法
            Field field = MyVie