Class tự new mọi thứ nó cần thì bị trói chặt vào các class đó: đổi implementation phải sửa code, unit test phải kéo theo database thật. IoC và DI gỡ trói: class chỉ khai báo “tôi cần gì”, còn IoC container của Spring (ApplicationContext) tạo và lắp ráp. Đọc xong, bạn giải thích được cách container tạo, inject, quản lý vòng đời, scope, proxy và circular dependency của bean.
1. Coupling: vấn đề gốc
Ý chính: coupling là mức độ phụ thuộc giữa hai module. Class phụ thuộc vào interface và nhận dependency từ bên ngoài thì dễ thay, dễ test; class tự new class cụ thể thì không.
- Tight coupling (liên kết chặt): A biết class cụ thể của B và tự tạo B.
- Loose coupling (liên kết lỏng): A chỉ biết interface của B, không quan tâm ai tạo ra B.
Tight coupling
class MomoGateway {
PaymentResult pay(Order order) { /* gọi API Momo */ }
}
class CheckoutService {
private final MomoGateway gateway = new MomoGateway(); // tự tạo, gắn chết vào Momo
PaymentResult checkout(Order order) {
return gateway.pay(order);
}
}
Muốn thêm VNPay? Sửa CheckoutService. Muốn test checkout mà không gọi Momo thật? Gần như không thể.
Loose coupling qua interface + constructor
interface PaymentGateway {
PaymentResult pay(Order order);
}
class MomoGateway implements PaymentGateway { ... }
class VnPayGateway implements PaymentGateway { ... }
class CheckoutService {
private final PaymentGateway gateway;
CheckoutService(PaymentGateway gateway) { // nhận từ bên ngoài
this.gateway = gateway;
}
}
Nhờ đa hình, truyền implementation nào vào cũng chạy. Đây là Dependency Inversion Principle (chữ D trong SOLID): module cấp cao và cấp thấp cùng phụ thuộc vào abstraction.
Nhưng ai sẽ lắp ráp?
PaymentGateway momo = new MomoGateway(httpClient, momoConfig);
PaymentGateway vnpay = new VnPayGateway(httpClient, vnpayConfig);
CheckoutService checkout = new CheckoutService(momo);
RefundService refund = new RefundService(vnpay, orderRepository); // lỡ tay truyền nhầm?
Với hàng trăm class, lắp bằng tay sinh ba vấn đề: tự quản lý thứ tự tạo và vòng đời (khi nào đóng connection pool?), dễ truyền nhầm object, và phụ thuộc vòng (A cần B, B cần A, tạo cái nào trước?).
2. Inversion of Control
Ý chính: IoC đảo quyền điều khiển: framework tạo object, nối chúng với nhau và gọi code của bạn khi cần (“Don’t call us, we’ll call you”).
- Truyền thống: cần xe máy thì tự mua máy, khung, bánh rồi về tự lắp, phải biết mọi chi tiết và thứ tự lắp.
- IoC: bạn chỉ nói “tôi cần xe máy”, nhà máy (IoC container) sản xuất rồi giao tận nhà. Giao tận nhà là dependency injection, chiếc xe là dependency.
flowchart LR
subgraph T[Truyền thống]
direction LR
A1[Code của mình] -- tự mua và lắp từng phụ tùng --> P1[Engine, Frame, Wheel]
P1 --> O1[Object cần dùng]
end
subgraph I[IoC]
direction LR
A2[Code của mình] -- khai báo: cần xe máy --> F[IoC container]
F -- inject dependency đã lắp sẵn --> A2
end
Ngoài DI, IoC còn có: template method (framework gọi hook method của bạn), callback/event listener, service locator (bạn hỏi một registry để lấy dependency). Spring dùng DI, dạng phổ biến nhất.
3. Dependency Injection và IoC container
Ý chính: DI là đưa dependency vào object thay vì để object tự tạo hay tự đi tìm. Trong Spring, container là ApplicationContext, và object nó quản lý gọi là bean.
- Bean: object do container tạo và quản lý, thường là controller, service, repository, config, client.
- Khi bean A cần bean B, container tìm B trong context: chưa có thì tạo, có rồi thì lấy ra inject vào A.
ApplicationContextthuộc Spring Framework, không riêng Spring Boot. Boot chỉ tự cấu hình (auto-configuration) và tạo context cho bạn.
BeanFactory vs ApplicationContext
ApplicationContext mở rộng BeanFactory và tạo sẵn mọi singleton lúc startup. Nhờ vậy lỗi cấu hình (thiếu bean, vòng phụ thuộc) lộ ra lúc khởi động, không đợi request đầu tiên: fail fast có chủ đích.
Bảng so sánh BeanFactory và ApplicationContext
BeanFactory |
ApplicationContext |
|
|---|---|---|
| Vai trò | Interface gốc, chỉ tạo/lấy bean | Mở rộng BeanFactory |
| Khởi tạo singleton | Lazy (khi được hỏi) | Eager lúc startup (mặc định) |
| Tính năng thêm | Event, i18n (MessageSource), Environment/profile, đăng ký BeanPostProcessor tự động, resource loading |
|
| Dùng khi | Gần như không dùng trực tiếp | Mọi app Spring |
Component scanning
4. Tạo bean
Ý chính: class của mình thì gắn stereotype annotation (@Service…); class thư viện hoặc bean cần nhiều bước tạo thì khai báo method @Bean trong class @Configuration.
Cách 1: stereotype annotation
@Service
public class CheckoutService { ... }
| Annotation | Dùng cho | Khác biệt thật |
|---|---|---|
@Component |
Bean chung chung | Gốc của các stereotype |
@Service |
Tầng nghiệp vụ | Chỉ là tên gọi, giúp đọc code |
@Repository |
Tầng truy cập dữ liệu | Bật dịch exception của JDBC/JPA thành DataAccessException của Spring |
@Controller / @RestController |
Tầng web | Được DispatcherServlet nhận diện để map request |
@Configuration |
Class chứa định nghĩa bean | Được CGLIB proxy (xem dưới) |
Cách 2: @Configuration + @Bean
@Configuration
public class PaymentConfig {
@Bean
public HttpClient paymentHttpClient() {
return HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(3))
.build();
}
@Bean
public PaymentGateway momoGateway(HttpClient paymentHttpClient, MomoProperties props) {
return new MomoGateway(paymentHttpClient, props.endpoint(), props.secretKey());
}
}
Tham số của method @Bean cũng được inject. Tên bean mặc định là tên method.
5. Inject bean vào bean khác
Ý chính: có ba cách inject: field, constructor, setter. Constructor injection là mặc định; setter cho dependency tuỳ chọn; tránh field injection trong code production.
Field injection
@Service
public class ReportService {
@Autowired
private OrderRepository orderRepository;
}
Constructor injection
@Service
public class ReportService {
private final OrderRepository orderRepository;
public ReportService(OrderRepository orderRepository) { // không cần @Autowired
this.orderRepository = orderRepository;
}
}
Setter injection
@Service
public class ReportService {
private ReportExporter exporter;
@Autowired
public void setExporter(ReportExporter exporter) {
this.exporter = exporter;
}
}
So sánh
Khi có nhiều bean cùng kiểu
Bài Adapter và Factory dùng cách 3 để dựng registry Map<ListingType, BookingHandler> có kiểm tra trùng/thiếu lúc khởi động.
Bài Adapter và Factory còn có gì
Bài đó dựng registry từ List<BookingHandler>, so nó với simple factory bằng switch, chạy thử bẫy @RequiredArgsConstructor và bẫy inject theo class cha khi các lớp con cũng là bean. Nó cũng kể hai hình ảnh của khoá học (ông chủ và nhân viên làm pizza, nhà máy lắp xe đạp) để phân biệt Dependency Inversion, IoC và DI.
Dependency không bắt buộc: Optional<T>, @Autowired(required = false), hoặc ObjectProvider<T> (lấy lười, có getIfAvailable()).
6. Vòng đời của bean
Ý chính: container đọc định nghĩa bean, gọi constructor, inject, chạy các callback khởi tạo (@PostConstruct), rồi mới bọc AOP proxy; khi context đóng thì gọi @PreDestroy.
flowchart TD
A[Đọc BeanDefinition<br/>scan / @Bean] --> B[BeanFactoryPostProcessor<br/>sửa definition, ví dụ resolve placeholder]
B --> C[Khởi tạo: gọi constructor]
C --> D[Populate: inject field/setter]
D --> E[Aware callbacks<br/>BeanNameAware, ApplicationContextAware]
E --> F[BeanPostProcessor.before<br/>@PostConstruct chạy ở đây]
F --> G[InitializingBean.afterPropertiesSet<br/>rồi init-method]
G --> H[BeanPostProcessor.after<br/>AOP proxy được tạo ở đây]
H --> I[Bean sẵn sàng sử dụng]
I --> J[Context đóng: @PreDestroy<br/>DisposableBean.destroy, destroy-method]
BeanFactoryPostProcessorsửa định nghĩa bean trước khi tạo.BeanPostProcessorcan thiệp vào instance sau khi tạo. Phần lớn “phép màu” của Spring (@Autowired,@Async,@Transactional,@Scheduled) chạy bằng các post processor này.- Prototype bean không có destroy callback: container tạo xong là giao cho bạn, không quản lý tiếp.
7. Bean scope
Ý chính: scope quyết định container tạo bao nhiêu instance của một bean. Mặc định là singleton: một instance cho mỗi container, dùng chung cho mọi thread.
| Scope | Số instance | Ghi chú |
|---|---|---|
singleton (mặc định) |
Một instance cho mỗi bean definition trong một container | Không phải singleton toàn JVM như design pattern |
prototype |
Mỗi lần lấy/inject tạo mới | Không có destroy callback |
request |
Một instance mỗi HTTP request | Chỉ có trong web app |
session |
Một instance mỗi HTTP session | |
application |
Một instance mỗi ServletContext |
|
websocket |
Một instance mỗi WebSocket session |
Singleton phải thread-safe
Inject prototype vào singleton
8. Proxy: chìa khoá của AOP trong Spring
Ý chính: với @Transactional, @Async, @Cacheable, @Validated, @PreAuthorize, Spring inject một proxy bọc ngoài bean. Proxy chặn lời gọi, làm việc thêm (mở transaction, đẩy sang thread khác…) rồi gọi object thật; lời gọi không qua proxy thì không có việc thêm đó.
Proxy giống thư ký trước phòng giám đốc: khách gọi qua thư ký thì được ghi sổ, giám đốc tự gọi chính mình thì không.
sequenceDiagram
participant C as OrderController
participant P as Proxy của OrderService
participant T as OrderService (object thật)
C->>P: placeOrder()
P->>P: mở transaction
P->>T: placeOrder()
T->>T: this.sendEmail() gọi nội bộ, KHÔNG qua proxy
T-->>P: return
P->>P: commit / rollback
P-->>C: return
JDK dynamic proxy và CGLIB proxy
| JDK dynamic proxy | CGLIB proxy | |
|---|---|---|
| Cơ chế | Implement cùng interface | Tạo subclass lúc runtime |
| Yêu cầu | Bean phải có interface | Class không final, method không final/private |
| Mặc định | Spring Framework thuần khi có interface | Spring Boot (spring.aop.proxy-target-class=true) |
Kiểu runtime của bean là OrderService$$SpringCGLIB$$0, không phải OrderService, nên so sánh getClass() sẽ sai.
9. Circular dependency
Ý chính: A cần B và B cần A qua constructor thì Spring không tạo được bên nào trước, báo BeanCurrentlyInCreationException ngay lúc startup. Vòng phụ thuộc gần như luôn là dấu hiệu chia trách nhiệm sai.
@Service
class OrderService {
OrderService(InventoryService inventory) { ... }
}
@Service
class InventoryService {
InventoryService(OrderService orders) { ... }
}
Ba tầng cache singleton: cách Spring từng “cứu” field injection
10. Các tầng trong project Spring Boot
Ý chính: chỉ thứ stateless và dùng chung mới là bean (controller, service, repository). DTO và entity là dữ liệu tạo theo từng request, không phải bean.
| Tầng | Trách nhiệm | Bean? |
|---|---|---|
| Controller | Nhận request, map endpoint, gọi service | @RestController |
| DTO | Chở dữ liệu giữa các tầng, che field nhạy cảm của entity | Không, là object thường |
| Service | Logic nghiệp vụ, transaction | @Service |
| Repository | Truy vấn, thao tác dữ liệu | @Repository / interface Spring Data |
| Entity | Ánh xạ bảng trong DB | Không, do JPA quản lý |
Hướng phụ thuộc giữa các tầng (controller không gọi thẳng repository, domain không phụ thuộc web) nên kiểm bằng ArchUnit trong test, không trông vào review bằng mắt.
Dependency Injection không phải Dependency Inversion
- Dependency Injection là kỹ thuật: ai tạo object và đưa dependency vào (ở đây là Spring, qua constructor).
- Dependency Inversion (chữ D trong SOLID) là nguyên lý: nghiệp vụ không phụ thuộc hạ tầng; cả hai phụ thuộc abstraction, và abstraction thuộc về phía nghiệp vụ.
Dùng DI vẫn có thể vi phạm DIP: service nhận JpaOrderRepository cụ thể, hay import entity JPA và JpaRepository, thì nghiệp vụ vẫn dính hạ tầng. Áp dụng DIP: đặt interface OrderRepository cạnh domain, để adapter JPA cài đặt nó. Cách tổ chức codebase quanh nguyên lý này có ở bài Kiến trúc codebase: layered, hexagonal, onion, clean.
Bài tập
Bài 1: Tách logic từ controller vào service
Đề (diễn đạt lại): định nghĩa các class service cho pet project và chuyển toàn bộ logic nghiệp vụ đang nằm ở controller sang tầng service.
Lời giải bài 1
// Trước: controller làm mọi thứ
@RestController
@RequestMapping("/api/products")
class ProductController {
@Autowired ProductRepository repo;
@PostMapping
Product create(@RequestBody ProductRequest req) {
if (repo.existsBySku(req.sku())) throw new IllegalStateException("sku exists");
Product p = new Product(req.sku(), req.name(), req.price());
return repo.save(p);
}
}
// Sau: controller chỉ là lớp vận chuyển HTTP
@RestController
@RequestMapping("/api/products")
class ProductController {
private final ProductService productService;
ProductController(ProductService productService) {
this.productService = productService;
}
@PostMapping
ResponseEntity<ProductResponse> create(@Valid @RequestBody ProductRequest req) {
ProductResponse created = productService.create(req);
return ResponseEntity.created(URI.create("/api/products/" + created.id())).body(created);
}
}
@Service
class ProductService {
private final ProductRepository repo;
ProductService(ProductRepository repo) {
this.repo = repo;
}
@Transactional
public ProductResponse create(ProductRequest req) {
if (repo.existsBySku(req.sku())) {
throw new BusinessException(ErrorCode.PRODUCT_SKU_TAKEN);
}
return ProductResponse.from(repo.save(Product.from(req)));
}
}
Quy tắc: controller lo HTTP (status, header, map DTO), service lo nghiệp vụ và transaction. Service không chứa HttpServletRequest hay ResponseEntity.
Bài 2: Tạo bean service theo hai cách
Đề (diễn đạt lại): tạo bean cho các service bằng annotation, và bằng @Configuration + @Bean.
Lời giải bài 2
// Cách 1: annotation
@Service
public class ProductService { ... }
// Cách 2: bỏ @Service ở class, khai báo trong config
public class CategoryService {
private final CategoryRepository repo;
public CategoryService(CategoryRepository repo) { this.repo = repo; }
}
@Configuration
public class ServiceConfig {
@Bean
public CategoryService categoryService(CategoryRepository repo) {
return new CategoryService(repo);
}
}
Bài 3: Inject theo ba cách
Đề (diễn đạt lại): inject các bean service bằng field, constructor và setter injection. Sau đó viết unit test cho mỗi controller không dùng Spring (new trực tiếp với mock).
Lời giải bài 3
@RestController
class CategoryController {
@Autowired
private CategoryService categoryService; // field
}
@RestController
class ProductController {
private final ProductService productService; // constructor (khuyên dùng)
ProductController(ProductService productService) { this.productService = productService; }
}
@RestController
class ReportController {
private ReportService reportService;
@Autowired
void setReportService(ReportService reportService) { // setter
this.reportService = reportService;
}
}
Khi viết test bạn sẽ thấy ngay: constructor injection dễ test nhất, còn field injection buộc phải dùng @InjectMocks hoặc reflection. Viết các unit test đó với JUnit 5 và Mockito: unit test với JUnit 5 và Mockito.
Bài 4: Validate dữ liệu request trong service
Đề (diễn đạt lại): viết code kiểm tra dữ liệu đầu vào của request ở tầng service.
Lời giải bài 4
Phân vai: DTO + Bean Validation kiểm tra hình thức (không trống, đúng định dạng) ở controller; service kiểm tra nghiệp vụ cần dữ liệu khác (tồn tại, trạng thái, quan hệ).
@Service
@Validated // bật method validation cho service
class OrderService {
@Transactional
public OrderResponse place(@Valid PlaceOrderRequest req) { // vẫn chạy khi gọi từ nơi khác ngoài controller
Product product = productRepo.findById(req.productId())
.orElseThrow(() -> new BusinessException(ErrorCode.PRODUCT_NOT_FOUND));
if (!product.isActive()) {
throw new BusinessException(ErrorCode.PRODUCT_INACTIVE);
}
if (product.stock() < req.quantity()) {
throw new BusinessException(ErrorCode.OUT_OF_STOCK);
}
...
}
}
Vì @Validated dựa vào proxy, gọi place từ chính OrderService (this.place(...)) sẽ không được validate. Cách thiết kế BusinessException và xử lý lỗi tập trung có ở bài Exception trong Java.
Ghi nhớ
- Phân biệt được IoC, DI và Dependency Inversion bằng một câu mỗi cái.
- Giải thích được vì sao constructor injection là mặc định, và bẫy quên
finalvới@RequiredArgsConstructor. - Biết proxy được tạo ở bước nào của vòng đời, và vì sao self-invocation hay
@PostConstructlàm mất@Transactional. - Biết khi nào singleton gây race condition và cách lấy prototype mới mỗi lần từ singleton.
- Biết xử lý circular dependency theo thứ tự: thiết kế lại, event,
@Lazy, bật lại cấu hình.
Câu hỏi phỏng vấn
Junior
IoC và DI khác nhau thế nào?
IoC là nguyên lý (framework nắm quyền tạo và nối object), DI là một cách hiện thực nó.
Với DI, dependency được đưa vào object qua constructor/setter/field thay vì object tự tạo. Các cách hiện thực IoC khác: template method, callback, service locator.
Bean là gì? ApplicationContext là gì?
Bean là object do Spring IoC container tạo và quản lý vòng đời; ApplicationContext chính là container đó.
ApplicationContext mở rộng BeanFactory với event, i18n, environment/profile và khởi tạo singleton sẵn khi startup.
@Component, @Service, @Repository khác nhau gì?
Cả ba đều đánh dấu bean để component scan tìm thấy; chỉ @Repository có thêm hành vi.
@Service chỉ khác về ngữ nghĩa. @Repository dịch exception của tầng persistence sang DataAccessException.
Vì sao nên dùng constructor injection?
Vì dependency bắt buộc được đảm bảo ngay khi tạo object và class test được không cần Spring.
Thêm nữa: field có thể final, constructor dài cảnh báo class làm quá nhiều việc, và vòng phụ thuộc lộ ra ngay lúc startup.
Mid
Khi nào dùng @Bean thay vì @Component?
Khi không sửa được source của class (thư viện bên ngoài).
Hoặc khi tạo bean cần logic/tham số cấu hình phức tạp, hoặc cần nhiều bean cùng kiểu với cấu hình khác nhau.
Có hai bean cùng implement một interface, inject thế nào?
@Primary cho bean mặc định, @Qualifier("name") để chỉ đích danh.
Hoặc inject List<T>/Map<String, T> để lấy tất cả, hợp với strategy pattern.
Bean singleton có thread-safe không?
Không, Spring không làm nó thread-safe; bean phải stateless.
Một instance được nhiều thread dùng chung. State theo request đi qua tham số, hoặc dùng request scope / ThreadLocal có dọn dẹp.
Kể các bước chính trong vòng đời một bean.
Đọc definition, tạo, inject, khởi tạo, bọc proxy, dùng, huỷ.
Chi tiết: đọc definition, chạy BeanFactoryPostProcessor, gọi constructor, inject dependency, Aware callbacks, BeanPostProcessor.before (gồm @PostConstruct), afterPropertiesSet/init-method, BeanPostProcessor.after (tạo AOP proxy), dùng, rồi @PreDestroy/destroy khi đóng context. Prototype không có destroy callback.
Senior
Vì sao @Transactional không có tác dụng khi gọi method trong cùng class?
Vì transaction được áp bằng proxy bọc ngoài bean, còn this.method() gọi thẳng object thật.
Cách sửa: tách method sang bean khác, hoặc dùng TransactionTemplate. Tương tự với @Async, @Cacheable, và với method private/final khi dùng CGLIB.
Spring xử lý circular dependency thế nào?
Constructor injection thì không xử lý được (BeanCurrentlyInCreationException); cách đúng là thiết kế lại.
Với field/setter, ba tầng cache singleton cho phép inject early reference, nhưng từ Boot 2.6 bị cấm mặc định. Sửa bằng cách tách bean thứ ba hoặc dùng event; @Lazy chỉ là chữa cháy.
Inject prototype bean vào singleton thì chuyện gì xảy ra?
Prototype chỉ được lấy một lần khi tạo singleton, nên luôn là cùng một instance.
Dùng ObjectProvider<T>.getObject(), @Lookup hoặc scoped proxy để mỗi lần lấy được instance mới.
@Configuration khác gì @Component chứa method @Bean?
@Configuration (full mode) được CGLIB proxy, nên gọi method @Bean từ method khác vẫn trả cùng singleton.
Trong @Component hoặc proxyBeanMethods = false (lite mode), lời gọi đó tạo object mới. Lite mode khởi động nhanh hơn, nhưng phải lấy dependency qua tham số method.
DI giúp gì cho việc test và cho kiến trúc dài hạn?
Test: thay dependency bằng mock/fake mà không cần container hay hạ tầng thật. Kiến trúc: code phụ thuộc abstraction nên đổi implementation bằng cấu hình.
Đổi được DB, cổng thanh toán, cache mà không sửa nghiệp vụ; kết hợp kiểm tra kiến trúc tự động (ArchUnit) để giữ ranh giới giữa các tầng.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu trong phỏng vấn |
|---|---|---|---|
| inversion of control | /ɪnˈvɜːrʒən/ | đảo ngược quyền điều khiển | “With inversion of control, the framework creates objects and calls my code.” |
| dependency injection | /dɪˈpɛndənsi ɪnˈdʒɛkʃən/ | tiêm phụ thuộc | “Dependency injection lets me swap implementations without touching the class.” |
| coupling | /ˈkʌplɪŋ/ | độ phụ thuộc | “Depending on an interface keeps the coupling loose.” |
| wire / wiring | /waɪər/ | nối các bean lại với nhau | “Spring wires the repository into the service through the constructor.” |
| eager / lazy initialization | /ˈiːɡər/ /ˈleɪzi/ | khởi tạo sớm / lười | “Singletons are eagerly initialized, so misconfiguration fails fast at startup.” |
| scope | /skoʊp/ | phạm vi | “Prototype scope gives you a new instance every time you ask.” |
| lifecycle | /ˈlaɪfˌsaɪkəl/ | vòng đời | “The AOP proxy is created late in the bean lifecycle.” |
| proxy | /ˈprɒksi/ | đối tượng đại diện | “@Transactional works through a proxy that wraps the bean.” |
| self-invocation | /sɛlf ˌɪnvəˈkeɪʃən/ | tự gọi method nội bộ | “Self-invocation bypasses the proxy, so the annotation is ignored.” |
| circular dependency | /ˈsɜːrkjələr/ | phụ thuộc vòng | “A circular dependency is usually a sign of misplaced responsibilities.” |
| qualifier | /ˈkwɒlɪfaɪər/ | định danh bean | “When two beans share a type, I use a qualifier or a primary bean.” |
| stateless | /ˈsteɪtləs/ | không giữ trạng thái | “Singleton beans must be stateless to be thread-safe.” |
Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer), viết lại theo cách hiểu của mình.