java - 使用 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 Bean)如果尚未调用，则将创建对象；如果已调用，则返回现有对象。我还想利用在同一实例上自调用方法的能力。到目前为止，我还无法做到这一点。

如何创建和增强 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();
    }
}

增加了仅调用原始方法一次的功能，并缓存任何后续调用的结果(尤其包括自调用)。上面只是一个示例，可能有很多这样的构建器 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)

塔达!这是我们简单的对象缓存。享受吧。