Skip to content
TungDaDev's Blog

Spring IoC và DI: vòng đời bean, cache 3 tầng, bỏ field injection

Spring di.webp
Published on
12 mins read

Vòng phỏng vấn thứ hai, sau mấy câu khởi động về @Service và @Autowired, người phỏng vấn hỏi: "A cần B, B lại cần A, Spring tạo hai bean đó kiểu gì?". Câu này không có trong tutorial nào dạy gõ annotation.

Ở Java, Spring Framework gần như độc chiếm, và thứ kéo cả hệ sinh thái đó chạy là IoC Container (Inversion of Control) cùng Dependency Injection (DI). Gõ @Component, @Service, @Autowired hằng ngày là một chuyện. Đụng tới bài toán kiến trúc lớn thì vẫn còn vài câu hỏi gốc rễ mà nhiều người chưa rõ:

  • DIP, IoC và DI khác nhau thế nào về lý thuyết và kiến trúc?
  • Một Spring bean thật sự đi qua những giai đoạn nào trong vòng đời, từ lúc nạp class tới lúc bị huỷ? Vì sao proxy cho @Transactional hay Spring Security chỉ được tạo ở giai đoạn BeanPostProcessor?
  • Vì sao field injection (@Autowired trên private field) bị coi là anti-pattern nguy hiểm và bị loại khỏi các chuẩn code hiện đại?
  • Spring gỡ circular dependency bên trong DefaultSingletonBeanRegistry bằng cache 3 tầng (three-level cache) như thế nào?

# phân biệt dip vs ioc vs di

Nhiều người dùng ba khái niệm này lẫn lộn như một. Thật ra chúng nằm ở 3 tầng trừu tượng khác hẳn nhau:

Đặt vào một ví dụ quen thuộc cho dễ hình dung: DIP là nguyên tắc thiết kế dặn rằng OrderService chỉ nên khai báo phụ thuộc vào interface OrderRepository thay vì class cụ thể PostgresOrderRepository. IoC là hướng tổ chức kiến trúc đảo ngược quyền điều khiển: thay vì OrderService tự gọi new PostgresOrderRepository(), nó nhường hẳn quyền khởi tạo và quản lý vòng đời đó cho Spring Container. Còn DI là thao tác kỹ thuật cụ thể mà Spring thực hiện lúc chạy: khởi tạo sẵn một instance PostgresOrderRepository rồi truyền ("bơm") nó vào constructor của OrderService.


# vòng đời của spring bean

Từ lúc được khai báo tới lúc sẵn sàng phục vụ HTTP request, một Spring bean phải qua một loạt bước kiểm tra và biến đổi bên trong ApplicationContext:

Sơ đồ trên là bản rút gọn để dễ nhớ; bên trong thì ranh giới các bước không rạch ròi vậy. ApplicationContextAware thật ra được gọi bởi một BeanPostProcessor (ApplicationContextAwareProcessor) ở bước 4, và @PostConstruct cũng do CommonAnnotationBeanPostProcessor gọi trong postProcessBeforeInitialization. Thứ tự init đầy đủ là @PostConstruct → afterPropertiesSet() → init-method. Javadoc của BeanFactory liệt kê đủ các bước nếu bạn muốn xem danh sách dài.

# vì sao postProcessAfterInitialization lại quan trọng

Khi bạn gắn @Transactional hay @Secured lên một method, object mà Spring inject vào các Controller hay Service khác không còn là instance class gốc của bạn nữa. Chính ở bước postProcessAfterInitialization này, Spring AOP chen vào và bọc object gốc bằng một CGLIB dynamic proxy (ví dụ OrderService$$SpringCGLIB$$0 từ Spring 6; Spring Boot mặc định bật proxyTargetClass=true nên dùng CGLIB, còn nếu tắt đi và bean có interface thì Spring dùng JDK dynamic proxy, khi đó chỉ inject được theo kiểu interface). Một ngoại lệ đáng nhớ là khi bean dính circular dependency, proxy sẽ phải tạo sớm hơn qua getEarlyBeanReference() như sẽ thấy ở phần cache 3 tầng bên dưới. Cũng vì mọi logic mở/đóng transaction đều nằm ở lớp vỏ proxy bên ngoài, nếu một hàm trong class gọi nội bộ this.methodWithTransactional() thì lời gọi đi thẳng vào instance gốc mà không qua proxy, khiến @Transactional bị bỏ qua hoàn toàn!

TIP

Để tránh bẫy self-invocation của Spring AOP, tách các method cần @Transactional hoặc @Async sang một Service riêng, hoặc inject chính Service đó qua lazy lookup để lời gọi đi qua CGLIB proxy.


# vì sao field injection bị loại

Tutorial cũ thì lúc nào cũng viết kiểu này:

@Service
public class OrderService {
    @Autowired // FIELD INJECTION: ANTI-PATTERN NGUY HIỂM!
    private PaymentClient paymentClient;
    @Autowired
    private OrderRepository orderRepository;
}

Ngắn thì ngắn thật, nhưng chính tài liệu Spring khuyên dùng constructor injection, IntelliJ thì cảnh báo "Field injection is not recommended", và nhiều team cấm hẳn field injection trong code review vì 4 lý do khá nặng:

# constructor injection đúng chuẩn với requiredArgsConstructor

@Service
@RequiredArgsConstructor // Tự động sinh Constructor cho toàn bộ các trường 'final'
public class OrderService {
 
    // Tham chiếu không đổi được sau khi tạo; 'final' còn đảm bảo publish an toàn giữa các thread
    // (bản thân object được tham chiếu tới có bất biến hay không là chuyện khác)
    private final PaymentClient paymentClient;
    private final OrderRepository orderRepository;
 
    // Viết Unit Test bằng 'new' thẳng, không cần Spring context hay reflection:
    // OrderService service = new OrderService(mockPayment, mockRepo);
}

Class chỉ có một constructor thì không cần gắn @Autowired (từ Spring 4.3), Spring tự dùng constructor đó. @RequiredArgsConstructor là của Lombok; không dùng Lombok thì tự viết constructor, kết quả y hệt.


# cache 3 tầng xử lý circular dependency

Bài toán kinh điển: class A cần inject B, còn class B lại cần inject A.

Khởi tạo kiểu thông thường thì: muốn tạo A phải có B, muốn tạo B lại phải có A -> vòng lặp vô tận, ném ra BeanCurrentlyInCreationException!

Để gỡ chuyện này cho singleton bean, DefaultSingletonBeanRegistry của Spring giữ một cache 3 tầng (three-level cache):

Vì sao cần tới tầng 3 mà không bỏ thẳng A thô vào tầng 2? Vì lúc tạo A, Spring chưa biết có ai cần tham chiếu sớm tới A hay không. Tầng 3 chỉ giữ một "lời hứa" (() -> getEarlyBeanReference(beanName, mbd, bean)). Chỉ khi thật sự có vòng, lời hứa này mới được gọi, và nếu A cần AOP thì proxy của A được tạo sớm ngay lúc đó, để B nhận đúng proxy chứ không phải object thô. Không có vòng thì proxy vẫn được tạo đúng chỗ ở postProcessAfterInitialization. Cũng vì cần gọi được constructor trước rồi mới inject, cơ chế này chỉ gỡ được vòng qua setter/field; vòng qua constructor thì luôn ném BeanCurrentlyInCreationException.

WARNING

Thay đổi từ Spring Boot 2.6+: Cache 3 tầng gỡ được phụ thuộc vòng cho setter/field injection, nhưng có circular dependency là dấu hiệu chia trách nhiệm sai. Từ Spring Boot 2.6, Spring Boot mặc định cấm hẳn circular dependency (spring.main.allow-circular-references: false; Spring Framework dùng riêng thì vẫn cho phép). Ứng dụng sẽ fail-fast ngay lúc khởi động!


# scope mismatch: inject prototype vào singleton

Mặc định, bean nào trong Spring cũng là singleton (chỉ có một instance trong ApplicationContext).

Giả sử bạn có ReportGenerator (scope prototype, mỗi lần lấy là một object mới) được inject vào BillingService (scope singleton):

@Component
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class ReportGenerator {
    private final String reportId = UUID.randomUUID().toString();
 
    public String getReportId() {
        return reportId;
    }
}
 
@Service // Singleton (Mặc định)
@RequiredArgsConstructor
public class BillingService {
    private final ReportGenerator reportGenerator; // Bẫy Scope Mismatch!
 
    public void generate() {
        System.out.println(reportGenerator.getReportId());
    }
}

# code này sai logic ở đâu?

BillingService là singleton nên chỉ được khởi tạo đúng 1 lần lúc Spring dựng ApplicationContext. Ngay tại thời điểm đó, container tạo một instance ReportGenerator rồi truyền vào constructor của BillingService và giữ nguyên tham chiếu đó suốt vòng đời ứng dụng. Hệ quả là mọi lần gọi billingService.generate() về sau đều dùng đi dùng lại đúng cái instance ReportGenerator đầu tiên, làm cho khai báo @Scope(SCOPE_PROTOTYPE) mất sạch tác dụng!

# cách xử lý

# cách 1: dùng ObjectProvider
@Service
@RequiredArgsConstructor
public class BillingService {
    private final ObjectProvider<ReportGenerator> reportGeneratorProvider;
 
    public void generate() {
        // Mỗi lần gọi getObject() sẽ kích hoạt container sinh ra một prototype mới
        ReportGenerator generator = reportGeneratorProvider.getObject();
        System.out.println(generator.getReportId());
    }
}
# cách 2: dùng scoped proxy

Spring inject một CGLIB proxy thay cho object thật (@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE, proxyMode = ScopedProxyMode.TARGET_CLASS)). Mỗi lần method của proxy được gọi, nó xin container một instance để chuyển tiếp lời gọi. Với prototype, "xin" nghĩa là tạo mới mỗi lần gọi method: gọi setX() rồi getX() trên cùng biến là chạm vào hai object khác nhau, rất dễ dính bug. Scoped proxy hợp với scope request/session (trong một request luôn trả cùng object) hơn là prototype.

Ngoài hai cách trên còn có @Lookup trên một method abstract/rỗng, Spring override method đó để trả prototype mới mỗi lần gọi.

TIP

Nên chọn cái nào: Ưu tiên ObjectProvider<T> vì code rõ ràng, dễ mock khi viết unit test và không tốn thêm overhead của dynamic proxy CGLIB lúc runtime.


# so sánh các kiểu dependency injection

Tiêu chíConstructor Injection (nên dùng)Setter InjectionField Injection (anti-pattern)
Bất biến (final)🟢 Hỗ trợ 100%🔴 Không được🔴 Không được
Viết unit test🟢 Rất dễ (không cần Spring)🟡 Trung bình (gọi setter)🔴 Khó (cần Reflection / Mockito Runner)
Chặn coupling chặt🟢 Constructor dài là thấy ngay🔴 Dễ bị lạm dụng🔴 Giấu hẳn code smell
Null safety🟢 Tránh được NPE🔴 Dễ dính NPE nếu quên set🔴 Dễ dính NPE ngoài Spring context
Phát hiện circular dep🟢 Luôn fail-fast lúc startup🟡 Tự gỡ ngầm nếu được phép🟡 Tự gỡ ngầm nếu được phép

# tổng kết và lời khuyên

Ba thứ đáng rà lại ngay trong codebase hiện tại, mỗi thứ bắt đầu bằng một lần tìm kiếm:

  1. Bỏ field injection: tìm @Autowired đứng trên field, bỏ đi và chuyển sang constructor injection với các trường final (vừa giữ tính bất biến, vừa viết unit test nhẹ tênh không cần dựng container).
  2. Nắm vòng đời của bean: tìm các method @Transactional được gọi qua this trong cùng class. Lời gọi đó không đi qua proxy AOP (được bọc ở BeanPostProcessor), nên transaction không hề được mở.
  3. Cẩn thận với scope mismatch: tìm bean prototype hay request scope đang được inject thẳng vào singleton, rồi đổi sang lấy chúng qua ObjectProvider<T>.

Chỉ là những ghi chép cá nhân với hy vọng mang lại chút giá trị. Nếu thấy hữu ích, đừng ngại chia sẻ cho bạn bè & đồng nghiệp nhé!

Happy coding 😎 👍🏻 🚀 🔥.