Java基于反射和动态代理实现Hook（钩子）功能

在Java中，可以通过反射和动态代理实现Hook（钩子）功能，使程序能够在特定的时间点插入自定义代码，以实现定制化的逻辑。Hook功能常用于AOP（面向切面编程）或拦截器等场景。

1、基于接口的JDKProxy实现

package com.lf.java.basic.hook;


//在Java中实现类似hook的功能可以通过使用Java的反射机制和动态代理来实现。下面是一些常见的方法：
//
// 1. 反射机制：Java的反射机制允许在运行时动态地获取和操作类的信息。通过反射，可以获取类的方法、字段和构造函数等，并在运行时调用它们。通过使用反射，您可以在不修改源代码的情况下，通过替换或修改方法的行为来实现hook的功能。
//
// 2. 动态代理：Java的动态代理机制允许在运行时创建代理对象，代理对象可以拦截对目标对象的方法调用，并在调用前后执行自定义的逻辑。通过使用动态代理，您可以在不修改原始类的情况下，对方法进行增强、拦截或修改。
//
// 下面是一个简单的示例，演示了如何使用动态代理来实现类似hook的功能：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Start {
    void start();
}

class ApplicationStart implements Start {

    @Override
    public void start() {
        System.out.println("应用启动了");
    }
}

class ApplicationStartInvocationHandler implements InvocationHandler {

    private Object target;

    public ApplicationStartInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("在" + method.getName() + "执行前植入hook逻辑链");
        // 调用原始方法
        Object invoke = method.invoke(target, args);
        System.out.println("在" + method.getName() + "执行完成后植入hook链");
        return invoke;
    }
}

public class StartHook {

    public static void main(String[] args) {
        // 创建目标类实例
        ApplicationStart applicationStart = new ApplicationStart();
        // 创建代理对象
        Start proxyInstance = (Start) Proxy.newProxyInstance(
                applicationStart.getClass().getClassLoader(),
                applicationStart.getClass().getInterfaces(),//或 new Class<?>[]{Start.class}
                new ApplicationStartInvocationHandler(applicationStart));
        // 调用代理对象的方法，实际调用会触发Hook逻辑
        proxyInstance.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

运行结果：

在start执行前植入hook逻辑链
应用启动了
在start执行完成后植入hook链
1
2
3

2、基于类的CGLIB实现

package com.lf.java.basic.hook;

//在Java中实现类似hook的功能可以通过使用Java的反射机制和动态代理来实现。下面是一些常见的方法：
//
// 1. 反射机制：Java的反射机制允许在运行时动态地获取和操作类的信息。通过反射，可以获取类的方法、字段和构造函数等，并在运行时调用它们。通过使用反射，您可以在不修改源代码的情况下，通过替换或修改方法的行为来实现hook的功能。
//
// 2. 动态代理：Java的动态代理机制允许在运行时创建代理对象，代理对象可以拦截对目标对象的方法调用，并在调用前后执行自定义的逻辑。通过使用动态代理，您可以在不修改原始类的情况下，对方法进行增强、拦截或修改。
//
// 下面是一个简单的示例，演示了如何使用动态代理来实现类似hook的功能：
//

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

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

class Application {
    public void start() {
        System.out.println("Application start");
    }
}

class ApplicationInterceptor implements MethodInterceptor {

    private Application application;

    public ApplicationInterceptor(Application application) {
        this.application = application;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 在调用原始方法之前执行自定义逻辑
        System.out.println("在" + method.getName() + "执行前植入hook逻辑链");
        // 通过原始类调用原始方法
        Object result = method.invoke(application, objects);
//        Object result = method.invoke(o, objects);//抛出异常
        //通过子类调用父类的方法
//        Object result = methodProxy.invokeSuper(o, objects);
//        Object result = methodProxy.invoke(o, objects);//不支持，与原方法不一致，会产生错误结果
        // 在调用原始方法之后执行自定义逻辑
        System.out.println("在" + method.getName() + "执行前植入hook逻辑链");

        return result;
    }
}

public class HookExample {
    public static void main(String[] args) {
        Application application = new Application();
        // 创建动态代理对象
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(Application.class);
        //设置回调方法
        enhancer.setCallback(new ApplicationInterceptor(application));
        //生成代理类
        Application proxyApplication = (Application) enhancer.create();
        // 调用代理对象的方法
        proxyApplication.start();
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

运行结果：

在start执行前植入hook逻辑链
Application start
在start执行前植入hook逻辑链
1
2
3

对 method.invoke()和methodProxy.invokeSuper()的分析

在JDK动态代理中，我们使用method.invoke()方法来调用原始对象的方法，而使用methodProxy.invokeSuper()方法来调用代理对象的父类方法。

这是因为在基于类的动态代理中，代理对象是通过继承原始对象的方式创建的。代理对象继承了原始对象的方法，并且可以通过super关键字来调用父类方法。因此，当我们在代理对象的方法中调用methodProxy.invokeSuper()时，实际上是在调用父类的方法，即原始对象的方法。

而使用method.invoke()方法来调用原始对象的方法，是通过反射的方式来实现的。这种方式可以在运行时动态地调用方法，而不需要提前知道方法的具体实现。

在动态代理中，我们通常会在intercept方法中使用methodProxy.invokeSuper()来调用父类方法，以确保代理对象的行为与原始对象的行为保持一致。同时，我们也可以在intercept方法中使用method.invoke()来调用原始对象的方法，以实现一些特定的逻辑。

需要注意的是，当我们使用method.invoke()调用原始对象的方法时，需要传入原始对象作为方法调用的目标对象。而使用methodProxy.invokeSuper()调用父类方法时，不需要传入目标对象，因为代理对象已经继承了父类方法。

综上，使用method.invoke()和methodProxy.invokeSuper()的选择取决于我们想要调用的方法是原始对象的方法还是父类的方法。在动态代理中，我们通常会使用methodProxy.invokeSuper()来调用父类方法，以保持代理对象的行为与原始对象的行为一致。