使用 Spring bean 的惰性对象构建器

Question

我正在考虑使用@Configuration 类能够执行的类似方法，它们可以通过调用@Bean 方法懒惰地创建bean，并在已经调用的情况下返回现有对象。这是通过 CGLib 代理的一些魔法来完成的。

一个特别有趣的事情是，即使在自己调用方法时它也能工作：

@Configuration
class Config {
    @Bean ClassA beanA() {
        return new ClassA(beanB());
    }

    @Bean ClassB beanB() {
        return new ClassB();
    }
}

现在，在我的用例中，不涉及 Spring 配置，我想通过调用 Builder bean 的方法来使用这种能力来懒惰地创建任意对象图（不应该是 Spring Beans）如果尚未调用，它将创建对象，如果已调用则返回现有对象。而且我还想利用在同一个实例上自调用方法的能力。到目前为止，我无法做到这一点。

我如何创建和增强 Spring Bean（作为 CGLib 代理）以便它们能够自我调用方法，与 @Configuration 类类似，但使用我自己的自定义建议处理懒惰和缓存？

---

编辑：更多细节

最终的结果应该类似于上面的配置示例，但它会是一个普通的 Spring 单例 bean：

@Component
@MyBuilder // or some other custom annotation
class MyObjectGraphBuilder {
    @Builder ClassA objectA() {
        return new ClassA(objectB());
    }

    @Builder ClassB objectB() {
        return new ClassB();
    }
}

增加了只调用一次原始方法的能力，并为任何后续调用缓存结果（尤其包括自调用）。上面只是一个例子，可能有很多这样的builder bean，它们之间可能很复杂，相互依赖。

方法调用结果缓存很简单（可以通过AOP来完成），但我想要的是自调用能力，Spring一般不支持，除非是@Configuration类。

我认为 Spring 通过使用自己的 CGlib 代理增强 @Configuration bean 类来做到这一点。但是，它涉及到大量的复​​制和定制（例如 ConfigurationClassEnhancer、ConfigurationClassPostProcessor 等），到目前为止，我还没有运气真正使它与我的自定义后处理器和增强器一起工作（代码太长，但它基本上是一个副本提到的类并编写我的自定义方法拦截器）。所以我正在尝试寻找是否存在任何其他方式。

Answer 1

关于 AOP 和自调用的简单答案是：你不能使用 Spring AOP，你必须使用完整的 AspectJ。好消息是该解决方案不需要任何代理。 Spring手册描述了如何use AspectJ from Spring via LTW (load-time weaving)。别担心，如果配置正确，您可以将 AspectJ 与通过 Spring AOP 实现的其他方面一起使用。另外，如果你不喜欢 LTW，你也可以通过 AspectJ Maven 插件使用编译时编织。

现在这里有一个纯 Java + AspectJ（不涉及 Spring）的小缓存示例用于演示：

建造者注解：

package de.scrum_master.app;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Retention(RUNTIME)
@Target(METHOD)
public @interface Builder {}

示例类：

package de.scrum_master.app;

public class ClassB {
  @Override
  public String toString() {
    return "ClassB@" + hashCode();
  }
}

package de.scrum_master.app;

public class ClassA {
  private ClassB objectB;

  public ClassA(ClassB objectB) {
    this.objectB = objectB;
  }

  @Override
  public String toString() {
    return "ClassA@" +hashCode() + "(" + objectB + ")";
  }
}

带注释工厂方法的驱动程序应用：

package de.scrum_master.app;

public class MyObjectGraphBuilder {
  @Builder
  ClassA objectA() {
    return new ClassA(objectB());
  }

  @Builder
  ClassB objectB() {
    return new ClassB();
  }

  public static void main(String[] args) {
    MyObjectGraphBuilder builder = new MyObjectGraphBuilder();
    System.out.println(builder.objectB());
    System.out.println(builder.objectA());
    System.out.println(builder.objectB());
    System.out.println(builder.objectA());
    System.out.println(builder.objectB());
    System.out.println(builder.objectA());
  }
}

没有缓存方面的控制台日志：

ClassB@1829164700
ClassA@2018699554(ClassB@1311053135)
ClassB@118352462
ClassA@1550089733(ClassB@865113938)
ClassB@1442407170
ClassA@1028566121(ClassB@1118140819)

到目前为止，如此可预测。这是正常行为，根本没有缓存。

缓存方面：

现在这方面真的很简单。没有线程安全，无法创建多个相同类的命名bean或类似的东西，但我想你可以从这里开始，原理保持不变。

package de.scrum_master.app;

import java.util.HashMap;
import java.util.Map;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;

@Aspect
public class BuilderCacheAspect {
  private Map<Class<?>, Object> cachedObjects = new HashMap<>();

  @Around("@annotation(de.scrum_master.app.Builder) && execution(* *(..))")
  public Object findOrCreateObject(ProceedingJoinPoint thisJoinPoint) throws Throwable {
    //System.out.println(thisJoinPoint);
    Class<?> returnType = ((MethodSignature) thisJoinPoint.getSignature()).getReturnType();
    Object cachedObject = cachedObjects.get(returnType);
    if (cachedObject == null) {
      cachedObject = thisJoinPoint.proceed();
      cachedObjects.put(returnType, cachedObject);
    }
    return cachedObject;
  }
}

带有缓存方面的控制台日志：

ClassB@1392838282
ClassA@664740647(ClassB@1392838282)
ClassB@1392838282
ClassA@664740647(ClassB@1392838282)
ClassB@1392838282
ClassA@664740647(ClassB@1392838282)

多多！有我们简单的对象缓存。享受吧。