Spring父项目Bean能否被子项目访问？如何规避循环依赖？

先直接明确两个你关心的基础问题：

1. 父项目定义的Bean能不能被子项目使用？
   当然可以！只要子项目通过Maven/Gradle这类构建工具依赖了父项目（不管是继承<parent>还是直接添加依赖），并且两者共享同一个Spring上下文（比如同属一个Spring Boot应用，或者子项目上下文是父上下文的子上下文），子项目的组件就能正常引用父项目的Bean。除非是完全独立的Spring上下文，那得做上下文引用或者远程调用，但这种场景很少见。

2. 除了移到公共库，还有哪些方案能避免循环依赖，同时从API层面隐藏Bean的使用？
   公共库方案确实是最直接的拆分方式，但还有几种更灵活的方案，完美适配你“隐藏API”的需求：

方案1：接口隔离+延迟注入 #

这是最常用的解耦方式，核心就是用接口把具体实现藏起来：

• 思路：在父项目里定义一个抽象接口，把Bean的核心能力抽象出来，具体实现留在父项目。子项目只依赖这个接口，完全看不到父项目的具体Bean类。
• 破循环：如果存在双向依赖（父项目Bean需要子项目Bean，子项目Bean也需要父项目Bean），给其中一方的注入加上@Lazy延迟初始化，就能打破启动时的循环依赖。
• 代码示例：
  父项目定义接口：

  public interface CoreService {
      void executeCoreLogic();
  }
  

  父项目实现接口并注册为Bean：

  @Service
  public class CoreServiceImpl implements CoreService {
      // 如果需要依赖子项目Bean，用@Lazy延迟注入
      private final ChildService childService;
  
      public CoreServiceImpl(@Lazy ChildService childService) {
          this.childService = childService;
      }
  
      @Override
      public void executeCoreLogic() {
          // 业务逻辑
      }
  }
  

  子项目只注入接口：

  @Service
  public class ChildService {
      private final CoreService coreService;
  
      // 构造注入接口，而非具体实现类
      public ChildService(CoreService coreService) {
          this.coreService = coreService;
      }
  }
  

  这样一来，子项目完全不知道CoreServiceImpl的存在，只和CoreService接口交互，完美隐藏了API，同时@Lazy也解决了循环依赖问题。

方案2：上下文动态查找（ApplicationContextAware） #

如果不想用接口，也可以通过Spring上下文动态获取Bean，彻底打破编译期依赖：

• 思路：封装一个工具类实现ApplicationContextAware，子项目通过这个工具类获取父项目的Bean，而不是直接注入。
• 隐藏API：工具类对外只暴露基于接口的查找方法，子项目依然看不到具体的Bean实现类。
• 代码示例：
  子项目里的工具类：

  @Component
  public class SpringBeanLookup implements ApplicationContextAware {
      private static ApplicationContext ctx;
  
      @Override
      public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
          ctx = applicationContext;
      }
  
      // 对外暴露通用查找方法，只依赖接口
      public static <T> T getBean(Class<T> beanType) {
          return ctx.getBean(beanType);
      }
  }
  

  子项目类中使用：

  @Service
  public class ChildService {
      private CoreService coreService;
  
      @PostConstruct
      public void init() {
          // 初始化时动态获取Bean，避免构造注入的循环
          this.coreService = SpringBeanLookup.getBean(CoreService.class);
      }
  }
  

  这种方式完全消除了编译期的依赖关系，只要运行时上下文存在该Bean就能正常工作，同时API层面完全隐藏了具体实现。

方案3：事件驱动解耦 #

如果循环依赖是因为双向调用，那直接把同步调用改成异步事件发布/订阅，彻底解耦：

• 思路：父子项目之间通过Spring事件交互，子项目发布事件，父项目Bean订阅事件处理逻辑，反之亦然。双方都不需要直接依赖对方的Bean类。
• 隐藏API：父子项目只依赖Spring的事件基础类，完全看不到对方的具体实现。
• 代码示例：
  父项目定义事件类：

  public class CoreOperationEvent extends ApplicationEvent {
      private String operationData;
  
      public CoreOperationEvent(Object source, String operationData) {
          super(source);
          this.operationData = operationData;
      }
  
      public String getOperationData() {
          return operationData;
      }
  }
  

  子项目发布事件：

  @Service
  public class ChildService {
      private final ApplicationEventPublisher eventPublisher;
  
      public ChildService(ApplicationEventPublisher eventPublisher) {
          this.eventPublisher = eventPublisher;
      }
  
      public void doChildWork() {
          // 发布事件，无需直接依赖父项目Bean
          eventPublisher.publishEvent(new CoreOperationEvent(this, "需要父项目处理的数据"));
      }
  }
  

  父项目Bean订阅事件：

  @Service
  public class CoreServiceImpl implements CoreService {
      @EventListener
      public void handleCoreOperation(CoreOperationEvent event) {
          // 处理事件逻辑
          System.out.println("收到子项目事件，数据：" + event.getOperationData());
      }
  }
  

  这种方式完全消除了双向依赖，父子项目之间通过事件松耦合，API层面完全隐藏了具体的交互细节。

方案4：注册表模式（依赖反转） #

如果父项目需要主动调用子项目的Bean，又不想直接依赖，可以用注册表让子项目主动注册自己：

• 思路：父项目定义一个注册表接口，子项目Bean初始化时把自己注册到注册表中，父项目通过注册表获取子项目Bean，而非直接依赖。
• 隐藏API：父项目只依赖注册表接口，子项目也只依赖注册表接口，双方都看不到对方的具体实现。
• 代码示例：
  父项目定义注册表：

  public interface ChildServiceRegistry {
      void registerChildService(ChildService service);
      ChildService getRegisteredChildService();
  }
  

  父项目实现注册表：

  @Service
  public class ChildServiceRegistryImpl implements ChildServiceRegistry {
      private ChildService childService;
  
      @Override
      public void registerChildService(ChildService service) {
          this.childService = service;
      }
  
      @Override
      public ChildService getRegisteredChildService() {
          return childService;
      }
  }
  

  子项目Bean注册自己：

  @Service
  public class ChildService {
      public ChildService(ChildServiceRegistry registry) {
          // 初始化时注册自己
          registry.registerChildService(this);
      }
  }
  

  父项目Bean通过注册表获取子项目Bean：

  @Service
  public class CoreServiceImpl implements CoreService {
      private final ChildServiceRegistry registry;
  
      public CoreServiceImpl(ChildServiceRegistry registry) {
          this.registry = registry;
      }
  
      public void doCoreWork() {
          ChildService childService = registry.getRegisteredChildService();
          // 调用子项目Bean方法
      }
  }
  

  这种方式彻底打破了父子项目之间的直接依赖，双方都通过注册表间接交互，完美解决循环依赖并隐藏API。

总结 #

公共库方案是最直观的模块拆分方式，但如果不想调整模块结构，上述几种方案都能有效解决循环依赖问题，同时满足你“从API层面隐藏Bean使用”的需求。具体选哪种，要看你的业务场景和架构复杂度——接口隔离适合大多数常规场景，事件驱动适合异步交互场景，注册表适合父项目需要主动调用子项目的场景。

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