Java架构：深入理解JDK动态代理机制

代理模式作为一种常见的设计模式，在 Java 开发中有着广泛的应用。其基本原理是通过代理类来间接调用委托类的方法，从而在不修改原有业务逻辑的基础上，增加额外的功能处理，如权限校验、日志记录等。

在代理模式中，代理类和委托类实现相同的接口，代理类通过接口调用委托类的方法，并可以在调用前后添加额外的操作。这种模式不仅能够保护委托类，还能在不改变委托类代码的情况下，扩展其功能。

上图展示了代理模式的基本结构，包括代理接口（Subject）、代理类（ProxySubject）和委托类（RealSubject）。根据代理类的创建方式不同，可以将代理分为静态代理和动态代理。

1. 静态代理

静态代理是指在编译时就已经确定了代理类和委托类的关系。代理类和委托类在程序运行前就已经定义好，代理类通过实现与委托类相同的接口来调用委托类的方法。

接口示例：

public interface BookService {
    void buyBook();
}

实现类示例：

public class BookServiceImpl implements BookService {
    @Override
    public void buyBook() {
        System.out.println("购买一本书...");
    }
}

代理类示例：

public class BookServiceProxy implements BookService {
    private BookService bookService;

    public BookServiceProxy(BookService bookService) {
        this.bookService = bookService;
    }

    @Override
    public void buyBook() {
        prepareMoneyForBuyBook();
        bookService.buyBook();
        readBookAfterBuy();
    }

    private void prepareMoneyForBuyBook() {
        System.out.println("准备购买书籍的资金...");
    }

    private void readBookAfterBuy() {
        System.out.println("终于可以阅读喜欢的书籍了...");
    }
}

客户端代码示例：

public class StaticProxyTest {
    public static void main(String[] args) {
        BookService bookService = new BookServiceProxy(new BookServiceImpl());
        bookService.buyBook();
    }
}

运行结果如下所示：

静态代理的优缺点

优点：

1. 业务类只需关注核心业务逻辑，提高了代码的可复用性和可维护性。

缺点：

1. 每个接口只能有一个代理类，当接口较多时，需要编写大量的代理类，增加了代码的复杂度。
2. 如果接口新增方法，所有实现类和代理类都需要进行相应的修改，维护成本较高。

2. 动态代理

动态代理则是在程序运行时动态生成代理类。这种方式更加灵活，适用于接口较多或接口频繁变化的场景。

创建调用处理器示例：

public class SubjectInvocationHandler implements InvocationHandler {
    private Object delegate;

    public SubjectInvocationHandler(Object bookService) {
        this.delegate = bookService;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        prepareMoneyForBuyBook();
        Object obj = method.invoke(delegate, args);
        readBookAfterBuy();
        return obj;
    }

    private void prepareMoneyForBuyBook() {
        System.out.println("准备购买书籍的资金...");
    }

    private void readBookAfterBuy() {
        System.out.println("终于可以阅读喜欢的书籍了...");
    }
}

客户端代码示例：

public class DynamicProxyTest {
    public static void main(String[] args) {
        BookService bookService = new BookServiceImpl();
        BookService dynamicProxy = (BookService) Proxy.newProxyInstance(
            BookService.class.getClassLoader(),
            new Class[]{BookService.class},
            new SubjectInvocationHandler(bookService)
        );
        dynamicProxy.buyBook();

        // 将代理类的二进制数据写入文件
        createProxyClassFile();
    }

    public static void createProxyClassFile() {
        String name = "ProxySubject";
        byte[] data = ProxyGenerator.generateProxyClass(name, new Class[]{Subject.class});
        try {
            FileOutputStream out = new FileOutputStream(name + ".class");
            out.write(data);
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3. 动态代理相关API

动态代理的核心类和接口主要包括：java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler。

Proxy 类提供了创建动态代理类和实例的方法，而 InvocationHandler 接口则定义了如何处理代理类的方法调用。

4. 动态代理的内部实现

动态代理类的生成过程涉及多个步骤，包括创建代理类、生成字节码、加载字节码等。以下是 Proxy 类中 newProxyInstance 方法的实现细节：

public static Object newProxyInstance(ClassLoader loader,
                                      Class[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException {
    // 检查 h 不为空
    Objects.requireNonNull(h);
    final Class[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    // 获取与指定类加载器和接口相关的代理类类型对象
    Class cl = getProxyClass0(loader, intfs);
    // 通过反射获取构造函数对象并生成代理类实例
    try {
        if (sm != null) {
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }
        final Constructor cOns= cl.getConstructor(constructorParams);
        final InvocationHandler ih = h;
        if (!Modifier.isPublic(cl.getModifiers())) {
            AccessController.doPrivileged(new PrivilegedAction() {
                public Void run() {
                    cons.setAccessible(true);
                    return null;
                }
            });
        }
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException | InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

动态代理类的生成过程中，ProxyGenerator 类负责生成代理类的字节码。可以通过 sun.misc.ProxyGenerator 类的 generateProxyClass 方法生成代理类的二进制数据，并将其写入文件中进行分析。

5. 总结

动态代理是 Java 中一种强大的机制，它允许在运行时动态生成代理类，从而实现对目标对象的透明代理。通过实现 InvocationHandler 接口，可以灵活地控制代理类的方法调用行为，适用于多种场景，如 AOP、RPC 等。

6. 美中不足

尽管动态代理功能强大，但也有其局限性。例如，Java 动态代理目前仅支持接口代理，不支持类代理。这一限制源于 Java 的单继承特性，使得动态代理类无法同时继承多个类。虽然这一点可能会带来一些不便，但总体而言，动态代理仍然是一个非常有用的工具。