Java动态代理中的InvocationHandler上下文传递技巧

在Java编程中，动态代理是一种强大的机制，允许我们在运行时创建一个代理对象，实现对目标对象的增强。而InvocationHandler作为动态代理的核心组件，负责拦截对代理对象的所有方法调用。本文将深入探讨如何在InvocationHandler中巧妙地传递上下文信息，从而提升代码的灵活性和可维护性。

动态代理与InvocationHandler简介

首先，简单回顾一下动态代理的基本概念。Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口，通过这两个工具，我们可以动态地创建一个代理类，该代理类实现了目标接口的所有方法。当调用代理对象的方法时，实际上会调用InvocationHandler的invoke方法。

public interface MyInterface {
    void doSomething();
}

public class MyTarget implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

public class MyInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

public class ProxyDemo {
    public static void main(String[] args) {
        MyInterface target = new MyTarget();
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class<?>[] { MyInterface.class },
            new MyInvocationHandler(target)
        );
        proxy.doSomething();
    }
}

上下文传递的需求

在实际应用中，我们往往需要在InvocationHandler中传递一些上下文信息，比如用户身份、请求参数等。这些信息可以帮助我们在方法调用前后进行更复杂的逻辑处理。

传统方法的局限性

一种常见的做法是通过构造函数将上下文信息传递给InvocationHandler，但这存在一定的局限性。首先，构造函数参数过多会使得代码冗长且难以维护；其次，如果上下文信息在调用过程中发生变化，这种方式无法动态更新。

创新的上下文传递方案

为了克服上述局限性，我们可以利用ThreadLocal来存储上下文信息。ThreadLocal为每个线程提供了一个独立的变量副本，确保线程安全的同时，也方便在方法调用链中传递信息。

实现步骤

定义上下文类：创建一个上下文类，用于存储需要传递的信息。

public class Context {
    private String userId;
    private Map<String, Object> params;

    public Context(String userId, Map<String, Object> params) {
        this.userId = userId;
        this.params = params;
    }

    public String getUserId() {
        return userId;
    }

    public Map<String, Object> getParams() {
        return params;
    }
}

使用ThreadLocal存储上下文：在InvocationHandler中使用ThreadLocal来存储和获取上下文信息。

public class MyInvocationHandler implements InvocationHandler {
    private final Object target;
    private static final ThreadLocal<Context> contextThreadLocal = new ThreadLocal<>();

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

    public static void setContext(Context context) {
        contextThreadLocal.set(context);
    }

    public static void clearContext() {
        contextThreadLocal.remove();
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Context context = contextThreadLocal.get();
        if (context != null) {
            System.out.println("User ID: " + context.getUserId());
            System.out.println("Params: " + context.getParams());
        }
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

在调用前设置上下文：在调用代理对象的方法前，设置好上下文信息。

public class ProxyDemo {
    public static void main(String[] args) {
        MyInterface target = new MyTarget();
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class<?>[] { MyInterface.class },
            new MyInvocationHandler(target)
        );

        Map<String, Object> params = new HashMap<>();
        params.put("key1", "value1");
        MyInvocationHandler.setContext(new Context("12345", params));

        try {
            proxy.doSomething();
        } finally {
            MyInvocationHandler.clearContext();
        }
    }
}