为什么 Spring-proxy 使用委托模式而不是继承+超级？

Question

众所周知，在没有AspectJ的情况下，bean的方法的自调用在Spring中是行不通的。

例如，请参阅this question。

我认为这是因为 Spring 创建的代理使用 delagate 模式调用目标对象的方法。像这样：

class MyClass {

    @Autowired
    private MyClass self; // actually a MyProxy instance

    @Transactional // or any other proxy magic
    public void myMethod() {}

    public void myOtherMethod() {
        this.myMethod(); // or self.myMethod() to avoid self-invokation problem
    }
}

class MyProxy extends MyClass { // or implements MyInterface if proxyMode is not TARGET_CLASS and MyClass also implements MyInterface

    private final MyClass delegate;

    @Override
    public void myMethod() {
        // some proxy magic: caching, transaction management etc
        delegate.myMethod();
        // some proxy magic: caching, transaction management etc
    }

    @Override
    public void myOtherMethod() {
        delegate.myOtherMethod();
    }
}

我说的对吗？

使用此代码：

public void myOtherMethod() {
    this.myMethod();
}

this.myMethod() 将绕过代理（所以所有@Transactional 或@Cacheable 魔术）因为它只是内部委托的调用......所以我们应该注入一个MyClass bean（实际上是MyProxy 实例) 在MyClass 中调用self.myMethod()。这是可以理解的。

但是为什么代理是这样实现的呢？ 为什么它不只是扩展目标类，覆盖所有公共方法并调用super 而不是delegate？ 像这样：

class MyProxy extends MyClass {
    // private final MyClass delegate; // no delegate
    @Override
    public void myMethod() {
        // some proxy magic: caching, transaction management etc
        super.myMethod();
        // some proxy magic: caching, transaction management etc
    }
    @Override
    public void myOtherMethod() {
        super.myOtherMethod();
    }
}

它应该解决自调用问题，其中this.myMethod()绕过代理，因为在这种情况下this.myMethod()，从MyClass.myOtherMethod()调用（我们记得MyClass bean实际上是MyProxy实例），将调用覆盖的child的方法(MyProxy.myMethod())。

那么，我的主要问题是为什么不这样实现？

Answer 1

您认为 Spring AOP 为其代理使用委托的假设是正确的。这也是documented。

使用CGLIB，理论上你可以使用proxy.invokeSuper()来达到你想要的效果，即通过代理的方法拦截器实现的切面注册自调用（我这里使用的是Spring的嵌入式CGLIB版本，因此包名）：

package spring.aop;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

class SampleClass {
  public void x() {
    System.out.println("x");
    y();
  }

  public void y() {
    System.out.println("y");
  }

  public static void main(String[] args) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(SampleClass.class);
    enhancer.setCallback(new MethodInterceptor() {
      @Override
      public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
        throws Throwable {
        if(method.getDeclaringClass() == Object.class)
          return proxy.invokeSuper(obj, args);
        System.out.println("Before proxy.invokeSuper " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After proxy.invokeSuper " + method.getName());
        return result;
      }
    });
    SampleClass proxy = (SampleClass) enhancer.create();
    proxy.x();
  }
}

控制台日志：

Before proxy.invokeSuper x
x
Before proxy.invokeSuper y
y
After proxy.invokeSuper y
After proxy.invokeSuper x

这正是您想要的。但是，当您有几个方面时，问题就开始了：事务、日志记录等等。你如何确保它们一起工作？

• 选项 1：每个方面都有自己的代理。除非您根据方面优先级将代理相互嵌套，否则这显然不起作用。但是将它们相互嵌套意味着继承，即一个代理必须从另一个代理从外向内继承。尝试代理一个 CGLIB 代理，它不起作用，你得到异常。此外，CGLIB 代理非常昂贵并且使用 perm-gen 内存，请参阅 this CGLIB primer 中的描述。

• 选项 2：使用组合而不是继承。组合更灵活。拥有一个可以根据需要向其注册方面的代理解决了继承问题，但也意味着委托：代理在执行实际真实对象的代码之前/之后以正确的顺序在运行时注册方面并调用它们的方法（或不执行，如果@Around 建议永远不会调用proceed()）。请参阅 Spring 手册中有关 manually registering aspects to a proxy 的此示例：

// create a factory that can generate a proxy for the given target object
AspectJProxyFactory factory = new AspectJProxyFactory(targetObject);

// add an aspect, the class must be an @AspectJ aspect
// you can call this as many times as you need with different aspects
factory.addAspect(SecurityManager.class);

// you can also add existing aspect instances, the type of the object supplied must be an @AspectJ aspect
factory.addAspect(usageTracker);

// now get the proxy object...
MyInterfaceType proxy = factory.getProxy();

至于 为什么 Spring 开发人员选择了这种方法，以及是否可以使用单一代理方法，但仍确保自调用像我的小 CGLIB 示例“日志记录”中一样工作方面”上面，我只能推测。您可以在开发人员邮件列表中询问他们或查看源代码。原因可能是 CGLIB 代理的行为应该类似于默认的 Java 动态代理，以便在两种接口类型之间无缝切换。也许是另一个原因。

我并不是要对我的 cmets 粗鲁，只是直截了当，因为您的问题确实不适合 StackOverflow，因为它不是一个可以找到解决方案的技术问题。这是一个历史设计问题，而且本质上是哲学问题，因为使用 AspectJ 可以解决实际问题之下的技术问题（自我调用）。但也许您仍想深入研究 Spring 源代码，将 Spring AOP 实现从委托更改为 proxy.invokeSuper() 并提交拉取请求。不过，我不确定这样的重大更改是否会被接受。

Answer 2

此外，在以下情况下您将无法使用Inheritance + super：

• 如果 RealSubject 是最终的，那么代理将无法扩展它怎么办
• 如果 Proxy 需要扩展 RealSubject 以外的东西，该怎么办
• 如果您需要在 RealSubject 中隐藏某些功能（方法）怎么办
• 优先组合而不是继承（许多开发人员推荐）