为何自动生成的Java代理类必须继承java.lang.reflect.Proxy？

Great question! Let's break down the core reasons behind this design choice in JDK's dynamic proxy mechanism, using the code snippet from sun.misc.ProxyGenerator you shared as context.

1. Reuse Core Proxy Logic #

The Proxy class encapsulates all the foundational logic needed for dynamic proxies:

• It holds a reference to the InvocationHandler instance (via the h member variable) that handles method invocations.
• It provides the infrastructure to route method calls from the proxy to the handler's invoke() method.

By making every generated proxy class a subclass of Proxy, the JDK avoids duplicating this critical logic across every proxy class. Instead, all proxies inherit this functionality directly, ensuring consistency and reducing redundant code.

Looking at your code snippet, this line hardcodes the parent class to Proxy:

// u2 super_class;
dout.writeShort(cp.getClass(superclassName)); // superclassName is "java/lang/reflect/Proxy"

2. Enforce a Standardized Proxy Behavior #

JDK dynamic proxies are designed to follow a uniform pattern: all method calls on the proxy are intercepted and delegated to an InvocationHandler. By forcing proxies to extend Proxy, the JDK guarantees that every proxy adheres to this pattern.

This standardization makes it easy for developers to work with any dynamic proxy—regardless of the interfaces it implements—because they know to interact with it via the InvocationHandler contract.

3. Leverage Java's Single-Inheritance Model #

Java only allows single inheritance, so the JDK uses this constraint to centralize proxy-specific logic in one parent class. Since proxy classes need to implement the target interfaces (which is handled via the interfaces array in your code), using Proxy as the parent class ensures that all proxy-related functionality is contained in a single place, without conflicting with the interfaces the proxy must implement.

The generated proxy class's methods will ultimately delegate to the InvocationHandler stored in the parent Proxy class, like this (simplified example of generated code):

public class $Proxy0 extends Proxy implements YourInterface {
    // ...
    public void yourMethod() {
        try {
            h.invoke(this, m3, null); // h is inherited from Proxy
        } catch (Throwable e) {
            throw new UndeclaredThrowableException(e);
        }
    }
}

In short, this design choice is a deliberate way to keep the dynamic proxy mechanism clean, consistent, and maintainable.

内容的提问来源于stack exchange，提问作者Benny