Niềm tin sai phổ biến nhất về Spring là Dependency Injection (DI) đồng nghĩa với @Autowired. @Autowired chỉ là một chi tiết triển khai, và là chi tiết bạn nên viết ít nhất. DI là design pattern: object không tự tìm collaborator mà nhận nó từ bên ngoài. Hiểu pattern trước rồi mới thấy Spring Framework 7 và Boot 4.1 làm gì — và vì sao phần lớn lỗi kiến trúc Spring bắt đầu từ chỗ hiểu sai pattern này.
Mục lục
Cập nhật 2026
- Boot 4.1.2 / Framework 7.0.10: cách đăng ký bean và inject không đổi, không có API break cho DI.
- Framework 7 không còn hỗ trợ
javax.injectvàjavax.annotation; dùng chuẩn JSR-330 thì chuyển sangjakarta.inject. - JSpecify thay JSR-305 để mô tả nullness; bean được inject là non-null theo hợp đồng.
- Nền tảng: Java 25 LTS; test với JUnit Jupiter 6.1.x.
Dependency Injection là design pattern, không phải @Autowired
Một object cần object khác: OrderService cần ProductRepository để đọc sản phẩm. Có đúng hai cách để có collaborator đó: tự tạo bên trong, hoặc nhận từ bên ngoài. Cách hai là DI, và nó tồn tại độc lập với Spring — bạn có thể làm DI bằng tay trong một unit test, không cần container.
// Trước: object tự quyết định implementation và tự khởi tạo
public class OrderService {
private final ProductRepository repo = new JpaProductRepository();
}
Vấn đề không nằm ở chữ new. Vấn đề là OrderService vừa chọn implementation, vừa biết cách khởi tạo, vừa giữ nó. Đổi implementation phải sửa class, test phải có database, và constructor không cho biết class cần gì. DI tách ba việc đó: class khai báo nó cần kiểu gì, còn ai đó quyết định instance nào và tạo lúc nào.
“Ai đó” chính là IoC container, thứ nắm bean và vòng đời của chúng. Điều cần nhớ ở đây: DI nói về quan hệ giữa các object, còn container chỉ tự động hóa việc lắp ráp quan hệ đó.
Ba kiểu injection và kiểu nào là mặc định
Spring hỗ trợ ba điểm tiêm: constructor, setter, field. Chúng khác nhau ở thời điểm object nhận dependency và ở hậu quả khi cấu hình sai.
| Tiêu chí | Constructor injection | Setter / field injection |
|---|---|---|
| Dependency bắt buộc | Đảm bảo ngay khi object được tạo | Có thể null, phải kiểm tra lúc dùng |
Gán final |
Được | Không |
| Unit test | new OrderService(fake) |
Cần reflection hoặc Spring context |
| Phát hiện lỗi | Fail fast lúc khởi động | NullPointerException lúc chạy |
| Khuyến nghị | Mặc định cho dependency bắt buộc | Chỉ cho dependency thật sự tùy chọn |
Constructor injection là mặc định, không phải sở thích. Constructor chạy xong là object đã đủ dependency, field có thể final, và không ai gọi được method trên một nửa object. Đây là lý do nó vẫn là lựa chọn số một trong Framework 7.
Setter injection có chỗ đứng thật: dependency tùy chọn hoặc dependency có thể thay đổi sau khi tạo, ví dụ client cấu hình lại lúc runtime. Field injection chỉ thắng ở độ ngắn và trả giá bằng gần như mọi thứ còn lại — phần đó nằm ở mục lỗi thường gặp bên dưới.
Constructor injection trong Spring 7: những gì bạn không cần viết
// File: src/main/java/shop/order/OrderService.java
@Service
public class OrderService {
private final ProductRepository products;
public OrderService(ProductRepository products) { // không cần @Autowired
this.products = products;
}
public Product require(long id) {
return products.findById(id)
.orElseThrow(() -> new IllegalArgumentException("Unknown product: " + id));
}
}
Nếu class có đúng một constructor, Spring tự dùng nó và tự inject tham số. Quy tắc này có từ Spring 4.3 và vẫn đúng: thêm @Autowired ở đây chỉ tạo thêm một dòng nhiễu. Chỉ khi có nhiều constructor, bạn mới cần chỉ rõ Spring dùng cái nào; cách gọn hơn là giữ một constructor public duy nhất và tạo biến thể cho test bằng static factory.
Dependency tùy chọn trong constructor nên khai báo bằng Optional<T> hoặc ObjectProvider<T>, không phải field nullable. Sự vắng mặt khi đó là một phần của chữ ký constructor thay vì những câu if (x == null) rải rác trong thân method. Và constructor dài là tín hiệu, không phải lỗi cần che: sáu tham số nghĩa là class đang gánh sáu trách nhiệm.
Nhiều bean cùng kiểu: @Qualifier, @Primary, collection và map
Hai implementation của cùng một interface là chuyện bình thường, và cũng là lúc Spring ném NoUniqueBeanDefinitionException. Ba cách chọn: @Primary trên bean, @Qualifier tại điểm tiêm, hoặc nhận toàn bộ danh sách. Spring còn so tên tham số với tên bean như phương án cuối, nhưng đừng dựa vào đó — nó chỉ đúng cho đến lần đổi tên đầu tiên.
// File: src/main/java/shop/payment/CheckoutService.java
@Service
public class CheckoutService {
private final PaymentGateway defaultGateway;
private final Map<String, PaymentGateway> allGateways;
public CheckoutService(@Qualifier("momo") PaymentGateway defaultGateway,
Map<String, PaymentGateway> allGateways) {
this.defaultGateway = defaultGateway;
this.allGateways = allGateways;
}
}
Map<String, PaymentGateway> nhận mọi bean cùng kiểu với key là tên bean (momo, stripe, …). List<PaymentGateway> nhận cùng tập đó theo thứ tự @Order. Đây là dạng DI mạnh nhất và cũng bị lạm dụng nhiều nhất: dùng khi bạn thật sự cần chiến lược động (plugin, gateway, handler), không dùng để gom dependency bắt buộc cho gọn constructor. Nếu định @Qualifier, hãy đặt tên bean ngay từ đầu: @Component("momo") ổn định hơn tên suy ra từ tên class.
@Value hay @ConfigurationProperties
@Value("${shop.page-size:20}") tiêm một scalar và có giá trị mặc định sau dấu hai chấm. Nó phù hợp cho một tham số đơn lẻ ở một chỗ, không phù hợp khi cùng một nhóm cấu hình xuất hiện ở năm class: mỗi nơi một chuỗi key, không kiểu dữ liệu, không validation, không metadata cho IDE.
// File: src/main/java/shop/order/OrderProperties.java
@ConfigurationProperties(prefix = "shop.order")
public record OrderProperties(int maxItemsPerOrder, Duration holdTimeout) {}
// File: src/main/java/shop/order/OrderConfig.java
@Configuration
@EnableConfigurationProperties(OrderProperties.class)
class OrderConfig {}
Record + @ConfigurationProperties cho bạn constructor binding, relaxed binding (hold-timeout trong YAML khớp holdTimeout), ép kiểu và một chỗ duy nhất để đọc cấu hình. Với class hoặc record chỉ có một constructor, Boot tự chọn constructor binding; @ConstructorBinding không còn cần thiết. Thêm @Validated và constraint Jakarta nếu giá trị sai phải làm ứng dụng dừng ngay lúc khởi động.
Quy tắc thực dụng: một giá trị, một chỗ dùng → @Value. Một nhóm giá trị, nhiều chỗ dùng → @ConfigurationProperties. Đừng trộn cả hai cho cùng một nhóm key.
Lazy injection và ObjectProvider
@Lazy trên tham số constructor khiến Spring tiêm một proxy và chỉ resolve bean thật ở lần gọi method đầu tiên. Nó hữu ích cho bean đắt hoặc để phá vòng phụ thuộc, nhưng đẩy lỗi cấu hình từ lúc khởi động sang lúc chạy — nơi khó debug nhất. Đừng rắc @Lazy để “cho nhanh start-up”; hãy đo trước.
ObjectProvider<T> là cách tường minh hơn: giữ khả năng resolve tại thời điểm gọi, với getObject(), getIfAvailable(), getIfUnique() và stream(). Nó xử lý cả “có hoặc không có bean” lẫn vòng phụ thuộc mà không cần proxy, và trung thực hơn một field nullable vì ý định nằm ngay trong chữ ký constructor.
Circular dependency: phá đúng, không phải bằng field injection
A cần B, B cần A. Với constructor injection, Spring không tạo được object nào trước và ứng dụng dừng lúc khởi động với thông báo “the dependencies of some of the beans … form a cycle”. Boot từ 2.6 đặt spring.main.allow-circular-references=false theo mặc định, và Boot 4.1 giữ nguyên.
Field injection “giải quyết” được vòng này vì object được tạo trước, field gán sau. Đó không phải bản sửa lỗi: nó hoãn vấn đề, giữ nguyên kiến trúc sai, và có thể khiến proxy AOP (@Transactional, @Async) gặp object chưa hoàn chỉnh. Bật spring.main.allow-circular-references=true để “cho chạy” là cùng một loại quyết định.
Ba cách phá đúng, theo thứ tự nên thử:
- Sửa thiết kế. Tách phần dùng chung thành collaborator thứ ba, hoặc đổi chiều phụ thuộc bằng event:
OrderServicephátOrderPlaced, bên kia lắng nghe. @Lazytrên một tham số constructor. Một đầu của vòng thành proxy, chuỗi khởi tạo bị cắt tại đó.ObjectProvider<T>. Resolve đối tác khi thật sự cần, không phải lúc tạo object.
Điều không nên làm: thêm @Autowired vào field để vòng “biến mất”. Bạn vừa che một vòng phụ thuộc bằng một lỗi thiết kế khác.
Java config thay cho XML
Code legacy vẫn còn XML nên bạn cần đọc được nó. Nhưng XML không phải cách cấu hình cho dự án mới, và Framework 7 còn deprecate các namespace XML của MVC và lang.
<!-- legacy: src/main/resources/applicationContext.xml -->
<bean id="orderService" class="shop.order.OrderService">
<constructor-arg ref="productRepository"/>
</bean>
Vấn đề của đoạn trên: tên class là chuỗi nên sai chính tả chỉ lộ ra lúc chạy, IDE không refactor được, không có kiểu để kiểm tra, và file cấu hình phải nạp bằng @ImportResource thay vì cơ chế cấu hình chuẩn của Boot.
// File: src/main/java/shop/ShopConfig.java
@Configuration
public class ShopConfig {
@Bean
OrderService orderService(ProductRepository products) { // tham số cũng được inject
return new OrderService(products);
}
}
Java config cho bạn kiểm tra kiểu lúc compile, refactor được, và dùng chung cơ chế DI: tham số của method @Bean được inject như tham số constructor. Dùng @Bean cho object thuộc thư viện bên thứ ba mà bạn không thể đánh dấu @Component; class của chính bạn thì để component scanning làm việc.
Test: constructor injection làm unit test thành việc của ba mươi giây
Đây là lợi ích lớn nhất của constructor injection trong thực tế, và cũng là lý do field injection bị loại. Không cần Spring context, không cần Mockito nếu một fake đủ dùng.
// File: src/test/java/shop/order/FakeProductRepository.java
class FakeProductRepository implements ProductRepository {
private final Map<Long, Product> rows = new HashMap<>();
FakeProductRepository() {
rows.put(1L, new Product(1L, "Mechanical keyboard", new BigDecimal("129.00")));
}
@Override
public Optional<Product> findById(long id) {
return Optional.ofNullable(rows.get(id));
}
}
// File: src/test/java/shop/order/OrderServiceTest.java
class OrderServiceTest {
private final OrderService service = new OrderService(new FakeProductRepository());
@Test
void rejects_unknown_product() {
assertThatThrownBy(() -> service.require(404L))
.isInstanceOf(IllegalArgumentException.class)
.hasMessageContaining("404");
}
@Test
void returns_known_product() {
assertThat(service.require(1L).name()).isEqualTo("Mechanical keyboard");
}
}
Hai test này chạy trong vài mili giây, chỉ cần JUnit Jupiter 6.1.x với AssertJ. Chúng cũng chứng minh OrderService không phụ thuộc Spring: nếu class chỉ tạo được bên trong container, bạn đã biến framework thành điều kiện để test.
Sáu lỗi hay gặp
- Field injection vì “ngắn hơn”. Dependency bị ẩn khỏi chữ ký class, vòng phụ thuộc được phép tồn tại, test phải dùng reflection hoặc cả context.
@Autowiredtrên field static. Spring chỉ tiêm field của instance; static field vẫnnull. Cần truy cập từ chỗ tĩnh thì truyền dependency qua tham số method.- Prototype bean inject vào singleton. Singleton tạo một lần nên giữ đúng một instance prototype mãi mãi. Sửa bằng
ObjectProvidervà gọigetObject()tại điểm dùng. - Service locator đội lốt DI. Inject
ApplicationContextrồi gọigetBean(): dependency biến mất khỏi constructor và lỗi cấu hình chuyển sang runtime. Khai báo dependency thật. @Autowired(required = false)cộng kiểm tra null rải rác. Thay bằngOptional<T>hoặcObjectProvider; đừng dùngnulllàm tín hiệu nghiệp vụ.- Đánh dấu
@Autowiredcho mọi constructor. Vô nghĩa khi chỉ có một constructor; khi có nhiều mà không đánh dấu cái nào, ứng dụng lỗi ngay lúc khởi động.
Chọn kiểu injection trong ba giây
| Tình huống | Cách làm |
|---|---|
| Dependency bắt buộc | Constructor, field final |
| Dependency tùy chọn | Optional<T> hoặc ObjectProvider<T> |
| Nhiều implementation, chọn một | @Qualifier tại điểm tiêm hoặc @Primary |
| Cần toàn bộ implementation | List<T> hoặc Map<String, T> |
| Có vòng phụ thuộc | Sửa thiết kế trước; rồi @Lazy hoặc ObjectProvider |
Boot 4.1 và hướng 2027
Boot 4.1 không thay đổi cách DI hoạt động: @Component, @Bean, @ConfigurationProperties, constructor injection đều giữ nguyên, kể cả sau khi Boot chia nhỏ jar theo công nghệ. Thay đổi thật nằm ở hợp đồng nullness: API của Spring được mô tả bằng JSpecify nên bean inject là non-null theo hợp đồng. Đừng viết if (repo == null) để “cho chắc”, và cũng đừng dùng null để biểu diễn “không có bean” — hãy dùng Optional/ObjectProvider, nơi sự vắng mặt là kiểu dữ liệu chứ không phải tai nạn.
Framework 7.1 và Boot 4.2 hiện chỉ ở mức RC, đừng viết tài liệu nội bộ dựa trên chúng. Java 29 là LTS kế tiếp theo nhịp hai năm, dự kiến 09/2027. Bản thân DI khó thay đổi vì nó là pattern, không phải API; điều đang dịch chuyển là cách mô tả cấu hình (record + @ConfigurationProperties) và kiểm tra nullness ở compile time.
Checklist
- Rà các class: bỏ
@Autowiredtrên field private, chuyển sang constructor +final. - Bỏ
@Autowiredthừa trên constructor duy nhất. - Nhóm cấu hình lặp ở ba class trở lên: gom thành một
@ConfigurationProperties. - Mọi vòng phụ thuộc đang “chữa” bằng field injection: ghi lại và sửa thiết kế trong sprint này.
- Viết một unit test không dùng Spring context cho service quan trọng nhất.
- Tìm ai đang inject
ApplicationContextđểgetBean()và thay bằng dependency thật.
Đi tiếp trong series: Spring IoC trong thực tế, bean scope để hiểu vì sao singleton và prototype hành xử khác nhau khi inject, và tất tần tật về Spring annotations. Vị trí của DI trong toàn bộ lộ trình nằm ở roadmap Spring Boot.



