👀 Views: 82 💬 Answers: 1 📅 Created: 2025-09-06

spring refactoring dependency-injection design-patterns Java

I'm performance testing and Quick question that's been bugging me - While refactoring an older codebase using Spring Framework 5.3.x, I've stumbled upon a circular dependency issue between two service classes: `OrderService` and `PaymentService`..... The `OrderService` depends on `PaymentService` to process payments, while `PaymentService` requires `OrderService` to fetch order details. This results in a `BeanCurrentlyInCreationException` when the Spring context attempts to instantiate these beans: ``` org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'orderService': Requested bean is currently in creation: Is there an unresolvable circular reference? ``` I've tried using constructor injection for both services, thinking that it would clarify dependencies, but the circular reference remains. I also considered using `@Lazy` annotations on one of the service beans, which allows Spring to inject a proxy instead, but that feels like a workaround rather than a true solution. Here's a snippet of what the relevant sections look like: ```java @Service public class OrderService { private final PaymentService paymentService; @Autowired public OrderService(PaymentService paymentService) { this.paymentService = paymentService; } public void placeOrder(Order order) { paymentService.processPayment(order.getPaymentInfo()); } } @Service public class PaymentService { private final OrderService orderService; @Autowired public PaymentService(OrderService orderService) { this.orderService = orderService; } public void processPayment(PaymentInfo paymentInfo) { // Payment processing logic Order order = orderService.getOrder(paymentInfo.getOrderId()); } } ``` Exploring other strategies like using a mediator pattern or splitting responsibilities across different classes has crossed my mind, but I'm unsure about the implications on code maintainability and testing. What are the best practices for handling such circular dependencies in Spring while maintaining clean, usable code? Any insights or experiences would be greatly appreciated! What's the best practice here? This is for a service running on Debian. The project is a REST API built with Java. I appreciate any insights!