// Spring容器中的三級緩存
public class DefaultSingletonBeanRegistry {
    // 一級緩存：完整的Bean實例
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    // 二級緩存：早期Bean實例（未完成屬性注入）
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    // 三級緩存：Bean工廠對象
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
    /**
     * 獲取單例Bean的核心方法
     * 依次從三級緩存中查找Bean實例
     */
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 從一級緩存獲取完整Bean
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                // 從二級緩存獲取早期Bean
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    // 從三級緩存獲取Bean工廠
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        // 將早期Bean放入二級緩存
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }
}

# application.yml
spring:
  main:
    # 是否允許循環(huán)依賴（Spring Boot 2.6+默認(rèn)為false）
    allow-circular-references: true
    # 懶加載配置
    lazy-initialization: false
# 更細(xì)粒度的配置
management:
  endpoints:
    web:
      exposure:
        include: beans,health,info

@Service
public class UserService {
    private final OrderService orderService;
    // 構(gòu)造器注入 - 會導(dǎo)致循環(huán)依賴異常
    public UserService(OrderService orderService) {
        this.orderService = orderService;
    }
    public void processUser(Long userId) {
        // 業(yè)務(wù)邏輯
        orderService.getOrdersByUser(userId);
    }
}
@Service
public class OrderService {
    private final UserService userService;
    // 構(gòu)造器注入 - 形成循環(huán)依賴
    public OrderService(UserService userService) {
        this.userService = userService;
    }
    public List<Order> getOrdersByUser(Long userId) {
        // 業(yè)務(wù)邏輯
        userService.processUser(userId);
        return Collections.emptyList();
    }
}

@Service
public class UserService {
    private OrderService orderService;
    // 使用Setter注入避免循環(huán)依賴
    @Autowired
    public void setOrderService(OrderService orderService) {
        this.orderService = orderService;
    }
    public void processUser(Long userId) {
        if (orderService != null) {
            orderService.getOrdersByUser(userId);
        }
    }
}
@Service
public class OrderService {
    private UserService userService;
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public List<Order> getOrdersByUser(Long userId) {
        if (userService != null) {
            // 注意：這里可能導(dǎo)致無限遞歸
            // userService.processUser(userId);
        }
        return Collections.emptyList();
    }
}

@Configuration
@EnableConfigurationProperties
public class LazyLoadingConfig {
    /**
     * 全局懶加載配置
     * 注意：這可能會掩蓋循環(huán)依賴問題
     */
    @Bean
    @Lazy
    public UserService userService() {
        return new UserService();
    }
    /**
     * 選擇性懶加載
     * 推薦：只對特定Bean使用懶加載
     */
    @Bean
    @Lazy
    @ConditionalOnProperty(name = "app.lazy-loading.enabled", havingValue = "true")
    public ExpensiveService expensiveService() {
        return new ExpensiveService();
    }
}
// 在Bean級別使用懶加載
@Service
@Lazy  // 這個注解會延遲Bean的創(chuàng)建
public class ReportService {
    @Autowired
    @Lazy  // 延遲注入依賴
    private DataService dataService;
    public void generateReport() {
        // 只有在實際調(diào)用時才會創(chuàng)建dataService
        dataService.fetchData();
    }
}

@Component
public class CircularDependencyDetector implements BeanPostProcessor {
    private static final Logger logger = LoggerFactory.getLogger(CircularDependencyDetector.class);
    private final Set<String> beansInCreation = ConcurrentHashMap.newKeySet();
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        beansInCreation.add(beanName);
        logger.debug("開始創(chuàng)建Bean: {}", beanName);
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        beansInCreation.remove(beanName);
        logger.debug("完成創(chuàng)建Bean: {}", beanName);
        // 檢測潛在的循環(huán)依賴
        if (hasCircularDependency(bean)) {
            logger.warn("檢測到潛在循環(huán)依賴: {}", beanName);
        }
        return bean;
    }
    /**
     * 檢測Bean是否存在循環(huán)依賴
     */
    private boolean hasCircularDependency(Object bean) {
        Class<?> beanClass = bean.getClass();
        Field[] fields = beanClass.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Autowired.class)) {
                String fieldTypeName = field.getType().getSimpleName();
                if (beansInCreation.contains(fieldTypeName.toLowerCase())) {
                    return true;
                }
            }
        }
        return false;
    }
}

@Configuration
@Slf4j
public class BeanCreationMonitor {
    @EventListener
    public void handleContextRefresh(ContextRefreshedEvent event) {
        ApplicationContext context = event.getApplicationContext();
        String[] beanNames = context.getBeanDefinitionNames();
        log.info("=== Bean創(chuàng)建統(tǒng)計 ===");
        log.info("總Bean數(shù)量: {}", beanNames.length);
        // 分析Bean依賴關(guān)系
        analyzeBeanDependencies(context, beanNames);
    }
    private void analyzeBeanDependencies(ApplicationContext context, String[] beanNames) {
        Map<String, Set<String>> dependencyGraph = new HashMap<>();
        for (String beanName : beanNames) {
            try {
                BeanDefinition beanDefinition = ((ConfigurableApplicationContext) context)
                    .getBeanFactory().getBeanDefinition(beanName);
                if (beanDefinition instanceof AbstractBeanDefinition) {
                    String[] dependsOn = ((AbstractBeanDefinition) beanDefinition).getDependsOn();
                    if (dependsOn != null) {
                        dependencyGraph.put(beanName, Set.of(dependsOn));
                    }
                }
            } catch (Exception e) {
                log.debug("無法獲取Bean定義: {}", beanName);
            }
        }
        // 檢測循環(huán)依賴
        detectCircularDependencies(dependencyGraph);
    }
    private void detectCircularDependencies(Map<String, Set<String>> graph) {
        Set<String> visited = new HashSet<>();
        Set<String> recursionStack = new HashSet<>();
        for (String node : graph.keySet()) {
            if (hasCycle(graph, node, visited, recursionStack)) {
                log.warn("檢測到循環(huán)依賴路徑包含: {}", node);
            }
        }
    }
    private boolean hasCycle(Map<String, Set<String>> graph, String node, 
                           Set<String> visited, Set<String> recursionStack) {
        if (recursionStack.contains(node)) {
            return true;
        }
        if (visited.contains(node)) {
            return false;
        }
        visited.add(node);
        recursionStack.add(node);
        Set<String> neighbors = graph.get(node);
        if (neighbors != null) {
            for (String neighbor : neighbors) {
                if (hasCycle(graph, neighbor, visited, recursionStack)) {
                    return true;
                }
            }
        }
        recursionStack.remove(node);
        return false;
    }
}

// 定義業(yè)務(wù)事件
@Data
@AllArgsConstructor
public class UserCreatedEvent {
    private Long userId;
    private String username;
    private LocalDateTime createdAt;
}
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void createUser(CreateUserRequest request) {
        // 創(chuàng)建用戶邏輯
        User user = new User();
        user.setUsername(request.getUsername());
        user.setCreatedAt(LocalDateTime.now());
        // 保存用戶
        // userRepository.save(user);
        // 發(fā)布事件而不是直接調(diào)用其他服務(wù)
        eventPublisher.publishEvent(new UserCreatedEvent(
            user.getId(), 
            user.getUsername(), 
            user.getCreatedAt()
        ));
    }
}
@Service
public class OrderService {
    // 通過事件監(jiān)聽處理業(yè)務(wù)邏輯，避免直接依賴UserService
    @EventListener
    @Async
    public void handleUserCreated(UserCreatedEvent event) {
        // 為新用戶創(chuàng)建默認(rèn)訂單配置
        createDefaultOrderSettings(event.getUserId());
    }
    private void createDefaultOrderSettings(Long userId) {
        // 創(chuàng)建默認(rèn)訂單設(shè)置的邏輯
        log.info("為用戶 {} 創(chuàng)建默認(rèn)訂單設(shè)置", userId);
    }
}

// 定義接口抽象
public interface UserOperations {
    void processUser(Long userId);
    UserInfo getUserInfo(Long userId);
}
public interface OrderOperations {
    List<Order> getOrdersByUser(Long userId);
    void createOrder(CreateOrderRequest request);
}
// 實現(xiàn)類只依賴接口
@Service
public class UserServiceImpl implements UserOperations {
    @Autowired
    private OrderOperations orderOperations;  // 依賴接口而非具體實現(xiàn)
    @Override
    public void processUser(Long userId) {
        // 處理用戶邏輯
        List<Order> orders = orderOperations.getOrdersByUser(userId);
        // 進(jìn)一步處理
    }
    @Override
    public UserInfo getUserInfo(Long userId) {
        return new UserInfo(userId, "用戶" + userId);
    }
}
@Service
public class OrderServiceImpl implements OrderOperations {
    @Autowired
    private UserOperations userOperations;  // 依賴接口而非具體實現(xiàn)
    @Override
    public List<Order> getOrdersByUser(Long userId) {
        // 獲取用戶信息
        UserInfo userInfo = userOperations.getUserInfo(userId);
        // 返回訂單列表
        return Collections.emptyList();
    }
    @Override
    public void createOrder(CreateOrderRequest request) {
        // 創(chuàng)建訂單邏輯
    }
}

@Component
@Slf4j
public class MemoryUsageAnalyzer {
    private final MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
    @EventListener
    public void analyzeMemoryUsage(ContextRefreshedEvent event) {
        MemoryUsage heapUsage = memoryBean.getHeapMemoryUsage();
        MemoryUsage nonHeapUsage = memoryBean.getNonHeapMemoryUsage();
        log.info("=== 內(nèi)存使用分析 ===");
        log.info("堆內(nèi)存使用: {} MB / {} MB", 
                heapUsage.getUsed() / 1024 / 1024,
                heapUsage.getMax() / 1024 / 1024);
        log.info("非堆內(nèi)存使用: {} MB / {} MB",
                nonHeapUsage.getUsed() / 1024 / 1024,
                nonHeapUsage.getMax() / 1024 / 1024);
        // 分析Bean實例占用的內(nèi)存
        analyzeBeanMemoryUsage(event.getApplicationContext());
    }
    private void analyzeBeanMemoryUsage(ApplicationContext context) {
        String[] beanNames = context.getBeanDefinitionNames();
        Map<String, Long> beanSizes = new HashMap<>();
        for (String beanName : beanNames) {
            try {
                Object bean = context.getBean(beanName);
                long size = calculateObjectSize(bean);
                beanSizes.put(beanName, size);
            } catch (Exception e) {
                log.debug("無法計算Bean大小: {}", beanName);
            }
        }
        // 輸出占用內(nèi)存最多的前10個Bean
        beanSizes.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
                .limit(10)
                .forEach(entry -> log.info("Bean: {} - 大小: {} bytes", 
                        entry.getKey(), entry.getValue()));
    }
    private long calculateObjectSize(Object obj) {
        // 簡化的對象大小計算
        // 實際項目中可以使用更精確的工具如JOL
        return obj.toString().length() * 2; // 粗略估算
    }
}

@Component
public class CircularDependencyMetrics {
    private final MeterRegistry meterRegistry;
    private final Counter circularDependencyCounter;
    private final Timer beanCreationTimer;
    public CircularDependencyMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.circularDependencyCounter = Counter.builder("circular.dependency.detected")
                .description("檢測到的循環(huán)依賴數(shù)量")
                .register(meterRegistry);
        this.beanCreationTimer = Timer.builder("bean.creation.time")
                .description("Bean創(chuàng)建耗時")
                .register(meterRegistry);
    }
    public void recordCircularDependency(String beanName) {
        circularDependencyCounter.increment(
                Tags.of("bean.name", beanName)
        );
    }
    public void recordBeanCreationTime(String beanName, Duration duration) {
        beanCreationTimer.record(duration, 
                Tags.of("bean.name", beanName)
        );
    }
    @EventListener
    public void handleApplicationReady(ApplicationReadyEvent event) {
        // 應(yīng)用啟動完成后，輸出循環(huán)依賴統(tǒng)計
        double totalCircularDependencies = circularDependencyCounter.count();
        if (totalCircularDependencies > 0) {
            log.warn("應(yīng)用啟動過程中檢測到 {} 個循環(huán)依賴", totalCircularDependencies);
        }
    }
}

# Prometheus告警規(guī)則
groups:
  - name: spring-boot-circular-dependency
    rules:
      - alert: CircularDependencyDetected
        expr: increase(circular_dependency_detected_total[5m]) > 0
        for: 0m
        labels:
          severity: warning
        annotations:
          summary: "檢測到循環(huán)依賴"
          description: "應(yīng)用 {{ $labels.application }} 在過去5分鐘內(nèi)檢測到循環(huán)依賴"
      - alert: BeanCreationTimeHigh
        expr: histogram_quantile(0.95, rate(bean_creation_time_seconds_bucket[5m])) > 10
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Bean創(chuàng)建耗時過長"
          description: "Bean創(chuàng)建95%分位數(shù)耗時超過10秒"

// 問題代碼示例
@Service
public class PaymentService {
    @Autowired
    private OrderService orderService;  // 構(gòu)造器注入導(dǎo)致循環(huán)依賴
    public void processPayment(Long orderId) {
        Order order = orderService.getOrder(orderId);
        // 支付處理邏輯
    }
}
@Service  
public class OrderService {
    @Autowired
    private PaymentService paymentService;  // 形成循環(huán)依賴
    public Order getOrder(Long orderId) {
        // 獲取訂單邏輯
        return new Order();
    }
}

// 解決方案1：重構(gòu)為事件驅(qū)動架構(gòu)
@Service
public class PaymentService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    public void processPayment(PaymentRequest request) {
        // 處理支付邏輯
        Payment payment = createPayment(request);
        // 發(fā)布支付完成事件
        eventPublisher.publishEvent(new PaymentCompletedEvent(
            payment.getId(), 
            payment.getOrderId(), 
            payment.getAmount()
        ));
    }
    private Payment createPayment(PaymentRequest request) {
        // 創(chuàng)建支付記錄
        return new Payment();
    }
}
@Service
public class OrderService {
    // 通過事件監(jiān)聽處理訂單狀態(tài)更新
    @EventListener
    @Async
    public void handlePaymentCompleted(PaymentCompletedEvent event) {
        updateOrderStatus(event.getOrderId(), OrderStatus.PAID);
    }
    public Order getOrder(Long orderId) {
        // 獲取訂單邏輯
        return new Order();
    }
    private void updateOrderStatus(Long orderId, OrderStatus status) {
        // 更新訂單狀態(tài)
        log.info("訂單 {} 狀態(tài)更新為: {}", orderId, status);
    }
}

// 推薦：使用構(gòu)造器注入 + 接口依賴
@Service
public class RecommendedUserService {
    private final UserRepository userRepository;
    private final NotificationService notificationService;
    // 構(gòu)造器注入，依賴明確
    public RecommendedUserService(UserRepository userRepository, 
                                 NotificationService notificationService) {
        this.userRepository = userRepository;
        this.notificationService = notificationService;
    }
    public void createUser(CreateUserRequest request) {
        User user = new User(request.getUsername(), request.getEmail());
        userRepository.save(user);
        // 異步發(fā)送通知，避免強(qiáng)依賴
        notificationService.sendWelcomeNotification(user.getId());
    }
}
// 不推薦：字段注入 + 循環(huán)依賴
@Service
public class NotRecommendedUserService {
    @Autowired
    private OrderService orderService;  // 可能導(dǎo)致循環(huán)依賴
    @Autowired
    private PaymentService paymentService;  // 可能導(dǎo)致循環(huán)依賴
    // 業(yè)務(wù)邏輯與依賴管理混合
    public void createUser(CreateUserRequest request) {
        // 復(fù)雜的業(yè)務(wù)邏輯
    }
}

# 推薦的配置方式
spring:
  main:
    # 明確禁用循環(huán)依賴，強(qiáng)制良好的架構(gòu)設(shè)計
    allow-circular-references: false
    # 根據(jù)需要配置懶加載
    lazy-initialization: false
  profiles:
    active: ${SPRING_PROFILES_ACTIVE:dev}
# 環(huán)境特定配置
---
spring:
  config:
    activate:
      on-profile: prod
  main:
    # 生產(chǎn)環(huán)境嚴(yán)格模式
    allow-circular-references: false
    lazy-initialization: false
---
spring:
  config:
    activate:
      on-profile: dev
  main:
    # 開發(fā)環(huán)境可以適當(dāng)放寬
    allow-circular-references: true
    lazy-initialization: true

#!/bin/bash
# 循環(huán)依賴檢測腳本
echo "=== Spring Boot 循環(huán)依賴檢測 ==="
# 檢查Spring Boot版本
echo "檢查Spring Boot版本..."
grep -r "spring-boot-starter" pom.xml | head -5
# 檢查循環(huán)依賴配置
echo "檢查循環(huán)依賴配置..."
find . -name "*.yml" -o -name "*.yaml" -o -name "*.properties" | \
xargs grep -l "allow-circular-references\|lazy-initialization"
# 掃描可能的循環(huán)依賴
echo "掃描潛在循環(huán)依賴..."
find . -name "*.java" -exec grep -l "@Autowired\|@Inject" {} \; | \
while read file; do
    echo "分析文件: $file"
    # 簡單的循環(huán)依賴檢測邏輯
done
echo "檢測完成！"