Java动态代理与InvocationHandler代理链的艺术

在Java编程的世界里，动态代理技术以其灵活性和强大的功能，成为许多开发者手中的利器。而在这其中，InvocationHandler及其代理链的设计更是将动态代理的潜力发挥得淋漓尽致。本文将带你深入探索这一技术的奥秘。

动态代理的基本概念

首先，让我们回顾一下动态代理的基本概念。动态代理是一种在运行时创建代理对象的技术，它允许我们在不改变原有类结构的情况下，对方法调用进行拦截和处理。在Java中，java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口是实现动态代理的关键。

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

interface MyInterface {
    void doSomething();
}

class MyInvocationHandler implements InvocationHandler {
    private 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 realObject = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Doing something");
            }
        };

        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class<?>[] { MyInterface.class },
                new MyInvocationHandler(realObject)
        );

        proxy.doSomething();
    }
}

InvocationHandler代理链的引入

在实际应用中，我们往往需要对一个对象的方法调用进行多层次的拦截和处理。这时，单一InvocationHandler就显得力不从心。于是，代理链的概念应运而生。

代理链允许我们将多个InvocationHandler串联起来，形成一个处理链。每个InvocationHandler可以独立地处理方法调用，也可以将调用传递给链中的下一个InvocationHandler。

class FirstInvocationHandler implements InvocationHandler {
    private Object target;
    private InvocationHandler nextHandler;

    public FirstInvocationHandler(Object target, InvocationHandler nextHandler) {
        this.target = target;
        this.nextHandler = nextHandler;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("First handler before method call");
        Object result = nextHandler.invoke(proxy, method, args);
        System.out.println("First handler after method call");
        return result;
    }
}

class SecondInvocationHandler implements InvocationHandler {
    private Object target;

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

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

public class ProxyChainDemo {
    public static void main(String[] args) {
        MyInterface realObject = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("Doing something");
            }
        };

        SecondInvocationHandler secondHandler = new SecondInvocationHandler(realObject);
        FirstInvocationHandler firstHandler = new FirstInvocationHandler(realObject, secondHandler);

        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                MyInterface.class.getClassLoader(),
                new Class<?>[] { MyInterface.class },
                firstHandler
        );

        proxy.doSomething();
    }
}