Java动态代理：InvocationHandler复用的艺术

在Java编程中，动态代理是一种强大的机制，允许我们在运行时创建代理对象，从而实现对目标对象的增强。而在这其中，InvocationHandler扮演着至关重要的角色。本文将深入探讨InvocationHandler的复用技巧，揭示其在提升代码复用性和可维护性方面的独特魅力。

什么是InvocationHandler？

InvocationHandler是Java动态代理机制的核心接口，定义了代理对象的方法调用逻辑。当我们通过Proxy类创建代理对象时，必须提供一个InvocationHandler实例。每当代理对象的方法被调用时，都会委托给InvocationHandler的invoke方法进行处理。

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

单一职责原则与InvocationHandler复用

在实际开发中，我们往往需要为不同的接口或类创建代理。如果为每个代理对象都创建一个新的InvocationHandler实例，代码将变得冗余且难以维护。此时，复用InvocationHandler成为了一种优雅的解决方案。

复用策略一：通用逻辑封装

我们可以将通用的代理逻辑封装在一个InvocationHandler中，供多个代理对象共享。例如，日志记录、性能监控等通用功能可以统一处理。

public class CommonInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 通用逻辑：例如日志记录
        System.out.println("Method " + method.getName() + " is called.");

        // 调用目标对象的方法
        Object result = method.invoke(target, args);

        // 通用逻辑：例如性能监控
        System.out.println("Method " + method.getName() + " is finished.");

        return result;
    }
}

复用策略二：策略模式结合

当不同的代理对象需要不同的增强逻辑时，我们可以结合策略模式，将具体的增强逻辑抽象为策略接口，并在InvocationHandler中动态选择。

public interface EnhancementStrategy {
    void before(Method method, Object[] args);
    void after(Method method, Object[] args);
}

public class LoggingStrategy implements EnhancementStrategy {
    @Override
    public void before(Method method, Object[] args) {
        System.out.println("Logging before method: " + method.getName());
    }

    @Override
    public void after(Method method, Object[] args) {
        System.out.println("Logging after method: " + method.getName());
    }
}

public class StrategyInvocationHandler implements InvocationHandler {
    private final Object target;
    private final EnhancementStrategy strategy;

    public StrategyInvocationHandler(Object target, EnhancementStrategy strategy) {
        this.target = target;
        this.strategy = strategy;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        strategy.before(method, args);
        Object result = method.invoke(target, args);
        strategy.after(method, args);
        return result;
    }
}

实战应用：灵活的代理工厂

结合上述复用策略，我们可以设计一个灵活的代理工厂，根据不同的需求动态创建代理对象。

public class ProxyFactory {
    public static <T> T createProxy(Class<T> interfaceType, T target, EnhancementStrategy strategy) {
        return (T) Proxy.newProxyInstance(
            interfaceType.getClassLoader(),
            new Class<?>[] { interfaceType },
            new StrategyInvocationHandler(target, strategy)
        );
    }
}

使用示例：

public interface SomeService {
    void doSomething();
}

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

public class Main {
    public static void main(String[] args) {
        SomeService target = new SomeServiceImpl();
        SomeService proxy = ProxyFactory.createProxy(SomeService.class, target, new LoggingStrategy());
        proxy.doSomething();
    }
}