Tại sao chọn Spring? Hướng dẫn cho người mới bắt đầu với Framework phổ biến nhất của Java

Câu trả lời ngắn cho câu hỏi “tại sao chọn Spring” không phải “vì nó phổ biến nhất”. Cuối năm 2026, Spring Boot 4.1.2 vẫn là thứ bạn gặp ở phần lớn dự án Java doanh nghiệp, nhưng lý do đúng để chọn nó nằm ở cấu trúc dự án của bạn, không nằm ở thứ hạng trong một bảng khảo sát.

Bài này là bước 0 của lộ trình: Spring cho bạn cái gì, bạn trả giá bằng gì, và khi nào nên chọn thứ khác. Đọc phần “khi nào không nên” trước khi quyết định.

Cập nhật 2026: bốn điều cần biết trước khi bắt đầu

  • Spring Boot 4.1.2 và Spring Framework 7.0.10 là dòng ổn định. Boot 4.2.0-RC2 và Framework 7.1.0-RC2 chỉ là release candidate — đừng dựng production trên đó.
  • Java 25 LTS là nền tảng production. Boot 4.1 chạy được trên Java 17 đến 27, nhưng Java 27 (GA 15/09/2026) là feature release, không phải LTS.
  • Baseline là Jakarta EE 11: mọi import là jakarta.*. Framework 7 đã bỏ hỗ trợ javax.annotation và javax.inject.
  • RestTemplate đã deprecated. Đường đi hiện tại là RestClient, HTTP interface client dùng @HttpExchange, hoặc WebClient nếu thực sự cần reactive.

Tại sao chọn Spring — và tại sao câu hỏi đó hay bị trả lời sai

Lập luận quen thuộc là “Spring phổ biến nhất nên chọn Spring”. Đó không phải lập luận kỹ thuật. Một con số khảo sát không đo chi phí khởi động của ứng dụng bạn, không đo RAM còn trống trên node Kubernetes, và không nói gì về việc team bạn có debug được một proxy AOP lúc hai giờ sáng hay không.

Câu hỏi đúng là: hình dạng công việc của bạn có khớp với thứ Spring giỏi không? Bốn tiêu chí:

  • Độ phức tạp nghiệp vụ. Nhiều entity, nhiều ràng buộc giao dịch, nhiều tích hợp, vòng đời sản phẩm tính bằng năm. Spring được thiết kế cho đúng hoàn cảnh này.
  • Team. Có người đã làm Java, hoặc bạn sẵn sàng tuyển người Java. Đừng học ngôn ngữ và framework cùng lúc.
  • Ràng buộc vận hành. Startup vài trăm mili giây hay RAM mỗi pod rất thấp có phải yêu cầu cứng? Nếu có, Spring là câu trả lời sai bất kể nó phổ biến đến đâu.
  • Vòng đời. Hệ thống sống 5–10 năm, cần tuyển người, cần thư viện từ SSO đến batch. Đây là nơi hệ sinh thái Spring thắng.

Nếu cả bốn đều nghiêng về Spring, đọc tiếp. Nếu không, xem mục so sánh bên dưới.

Spring thực sự cung cấp cho bạn những gì

Một ứng dụng Spring điển hình nhận được sáu thứ sau.

1. IoC container quản lý vòng đời object

Container đọc bean definition, tạo instance theo scope, inject dependency qua constructor, chạy callback như @PostConstruct, và đóng tài nguyên khi context shutdown. Bạn không viết new cho repository hay client — chỉ khai báo chúng cần gì. Constructor injection cho phép field final, phát hiện circular dependency ngay lúc khởi động, và cho phép test thuần JUnit không cần Spring context.

// File: src/main/java/dev/evotek/order/OrderService.java
@Service
public class OrderService {

    private final OrderRepository orders;
    private final PaymentClient payments;

    public OrderService(OrderRepository orders, PaymentClient payments) {
        this.orders = orders;
        this.payments = payments;
    }

    @Transactional
    public Order place(Long customerId, List<LineItem> items) {
        Order order = Order.newOrder(customerId, items);
        payments.reserve(order.total());
        return orders.save(order);
    }
}

2. Transaction khai báo, nhưng chạy qua proxy

@Transactional không phải phép thuật của trình biên dịch. Spring bọc bean trong một proxy; proxy mở transaction trước khi gọi method thật và commit hoặc rollback sau đó. Hiểu cơ chế này giải thích được gần hết các lỗi transaction mà người mới gặp.

Thứ nhất, gọi method @Transactional từ bên trong cùng class sẽ bỏ qua proxy, nên không có transaction nào được tạo:

@Service
public class ReportService {

    @Transactional
    public Report build(Long id) { /* ... */ }

    public void buildAll(List<Long> ids) {
        ids.forEach(this::build); // this, không phải proxy
    }
}

Thứ hai, mặc định chỉ RuntimeException và Error mới rollback. Checked exception không rollback trừ khi bạn khai báo rollbackFor. Đây là nguồn gốc của rất nhiều bug “dữ liệu nửa vời” trong production.

3. Web layer: MVC hoặc WebFlux

Spring MVC chạy trên Servlet API (Tomcat 11 nhúng, Servlet 6.1 trong Boot 4.1) với DispatcherServlet làm front controller; WebFlux chạy trên Netty và Reactive Streams. Chọn một cho mỗi service — trộn cả hai chỉ tạo ra hai mô hình lỗi khác nhau.

4. Security và Data

Spring Security 7.1.2 cung cấp SecurityFilterChain dạng bean với lambda DSL, method security, OAuth2/OIDC client, JWT resource server. Đây là module khó thay thế nhất: viết lại filter chain, CSRF, session fixation và password encoding từ đầu là việc không ai nên làm.

Spring Data JPA 4.1.2 (Hibernate 7.4.x) cho repository interface, query derivation, phân trang, auditing. Spring Data JDBC phù hợp hơn khi bạn muốn aggregate nhỏ và kiểm soát SQL; cùng họ còn MongoDB, Redis, Elasticsearch.

5. Spring Boot: bỏ phần lắp ráp

Auto-configuration đọc classpath rồi quyết định cấu hình mặc định. Có driver JDBC và Spring Data JPA thì DataSource, EntityManagerFactory, transaction manager được tạo. Có spring-boot-starter-web thì Tomcat nhúng và Jackson được cấu hình. Starter gom dependency theo nhóm để pom.xml không phình thành 40 dòng version.

Boot 4 còn cho Actuator (health, metrics, env), externalized configuration, test slice (@WebMvcTest, @DataJpaTest) và tích hợp Testcontainers — đúng phần “chạy được trong production” mà dự án Java thuần phải tự viết.

6. Hệ sinh thái

Đây là lợi thế thật của Spring. Spring Cloud cho gateway, config, circuit breaker; Spring Modulith 2.1.2 cho kiểm tra ranh giới module; Spring Batch cho job; Spring AI 2.0.2 cho model và MCP. Cần SAML, Kafka, S3 hay scheduled job, khả năng cao đã có module chính thức hoặc thư viện cộng đồng được bảo trì.

Nhưng “có module cho mọi thứ” cũng có nghĩa là “có thêm mọi thứ để cấu hình sai”.

Cái giá bạn phải trả

Spring đổi boilerplate lắp ráp lấy một tầng runtime phức tạp hơn. Năm khoản chi phí thực tế:

Khởi động và bộ nhớ

Một Boot app phải khởi tạo container, quét component, tạo proxy, mở connection pool trước khi phục vụ request đầu tiên. Với JVM, thời gian đó thường tính bằng giây chứ không phải mili giây, và RSS cũng không nhỏ so với một binary Go làm đúng endpoint đó. Nếu cold start là ràng buộc cứng, hãy đo trên workload của bạn — đừng tin con số trên blog, kể cả blog này.

Native image là lối thoát có thật, nhưng bạn phải xử lý reflection hint và resource config, đồng thời mất một phần khả năng debug runtime. Nó là tuỳ chọn cho một số service, không phải mặc định.

“Magic” và proxy

Khi một annotation không hoạt động, lý do gần như luôn là proxy: self-invocation, method private, class final, hoặc bean không nằm trong context. Stack trace dài vài chục frame và error message thường chỉ đúng phần ngọn.

Đường cong học và version churn

Để dùng Spring đúng, bạn phải hiểu cả servlet container, JDBC pool, JPA dirty checking, transaction boundary và cách JVM phân bổ bộ nhớ. Học annotation trước rồi va vào tất cả các tầng dưới cùng lúc là lý do phổ biến khiến Spring có vẻ khó.

Nâng cấp cũng là việc thật: Boot 4 module hoá lại jar, Framework 7 bỏ spring-jcl và ListenableFuture, đồng thời deprecate JUnit 4 và Jackson 2.x. Chuyển từ Boot 3 lên 4 không phải đổi số version trong pom.xml, và dự án sống lâu phải tính chi phí này mỗi 2–3 năm.

So sánh với các lựa chọn khác năm 2026

Quarkus

Quarkus lấy CDI làm mô hình DI và JAX-RS làm web layer, build quanh GraalVM native image. Điểm mạnh là startup và bộ nhớ sau khi build native, dev mode khởi động lại nhanh. Điểm yếu là hệ sinh thái nhỏ hơn, nhiều thư viện cần extension để chạy native, và chuyển từ Spring sang Quarkus là đổi mô hình DI chứ không chỉ đổi annotation.

Micronaut

Micronaut làm DI ở compile time, không dùng reflection lúc khởi động, nên startup nhanh và RAM thấp; cũng hỗ trợ GraalVM native. Đổi lại, số tích hợp sẵn ít hơn và cộng đồng nhỏ hơn đáng kể — gặp lỗi lạ thì ít bài để tra hơn.

Jakarta EE 11 + JAX-RS

Con đường chuẩn hoá: viết theo specification, chạy trên WildFly, Payara hoặc TomEE, không khoá vào container riêng của framework. Nhẹ và rõ ràng hơn về khái niệm, nhưng bạn tự lo phần lớn những gì Boot làm sẵn (config, health, test slice, observability).

Node/Go cho service nhỏ

Với một service ba endpoint, đọc/ghi một bảng, không có nghiệp vụ phức tạp, Go hoặc Node/TypeScript thường đủ yêu cầu với ít code và ít RAM hơn. Chọn Java ở đây thường vì team hoặc hệ thống xung quanh, không phải vì bài toán.

Tình huống Lựa chọn hợp lý Lý do
Monolith/enterprise, nghiệp vụ dày, team Java, sống 5+ năm Spring Boot 4.1 Hệ sinh thái, Security/Data có sẵn, dễ tuyển người
Nhiều microservice, cold start và RAM là ràng buộc cứng Quarkus hoặc Micronaut Native image, DI lúc build, không reflection khi khởi động
Đội đã có application server chuẩn, muốn bám spec Jakarta EE 11 + JAX-RS Không khoá vào container của framework
Service nhỏ, ít nghiệp vụ, team đa ngôn ngữ Go hoặc Node Ít code, ít bộ nhớ, triển khai đơn giản
Batch job thuần, không web, không DI Java thuần + JDBC Không cần container; chỉ dùng Spring Batch khi cần restart/skip/partition

Khi nào KHÔNG nên chọn Spring

Năm trường hợp dưới đây là lý do chính đáng để nói không, kể cả khi bạn thích Spring:

  • Một hàm serverless rất nhỏ. Endpoint 20 dòng không cần container IoC, transaction manager và hàng chục auto-configuration. Cold start của JVM sẽ là chi phí lớn nhất trong cả hàm.
  • Cold start là yêu cầu cứng. Nếu SLO tính bằng mili giây cho request đầu tiên, JVM cộng Spring context là lựa chọn sai, trừ khi bạn build native image và đã đo lại.
  • Team không có ai biết Java. Spring khuếch đại vấn đề cơ bản: team chưa vững Java sẽ debug proxy, bean scope và JPA thay vì làm tính năng. Học Java trước, Spring sau.
  • Batch job thuần. Đọc file, tính toán, ghi DB, chạy theo cron. Bạn cần main, JDBC và một scheduler — không cần web context. Nếu job cần restart, skip, partition thì Spring Batch mới đáng dùng.
  • Ràng buộc bộ nhớ cực chặt. Nếu mỗi pod chỉ có rất ít RAM, hãy cân nhắc Quarkus native, Micronaut hoặc Go trước khi tuning JVM để tiết kiệm vài chục MB.

Không chọn Spring không có nghĩa là không dùng Java. Rất nhiều hệ thống Java tốt chạy JAX-RS thuần hoặc framework nhẹ. Điều cần tránh là chọn Spring theo quán tính rồi trả giá bằng vận hành.

License và JDK: phần ít người đọc nhưng ảnh hưởng ngân sách

Tin tốt: Spring Boot, Framework, Security, Data, Cloud và Spring AI đều là Apache 2.0. Hibernate ORM là LGPL 2.1, Testcontainers là MIT, Resilience4j là Apache 2.0. Không có điều khoản thương mại nào chặn bạn dùng Spring trong sản phẩm bán ra.

Chỗ có ràng buộc là JDK. Oracle JDK theo giấy phép OTN — miễn phí cho phát triển, test và demo, nhưng dùng production cần subscription trả tiền. Nếu không muốn ràng buộc đó, dùng bản build miễn phí: Eclipse Temurin, Amazon Corretto hoặc Azul Zulu. Cùng Java 25, cùng bytecode, không khác biệt hiệu năng đáng kể cho phần lớn ứng dụng.

Với GraalVM: Community Edition miễn phí, tính năng Enterprise là thương mại. Nếu định dùng native image trong production, kiểm tra license trước khi đưa vào kiến trúc, không phải sau khi pipeline đã chạy.

Nhìn về 2027

Boot 4.2 và Framework 7.1 đang ở RC và sẽ là dòng kế tiếp trong vài tháng tới. Điều đó nghĩa là nền tảng bạn học hôm nay vẫn đúng, chỉ thêm tính năng chứ không đổi mô hình.

Java 29 LTS dự kiến ra mắt khoảng tháng 9/2027 theo nhịp hai năm (17 → 21 → 25 → 29); đó là thời điểm hợp lý để nâng JDK nếu bạn đang chạy 25. Virtual threads đã final từ Java 21 nên spring.threads.virtual.enabled=true là lựa chọn thực tế cho workload nhiều I/O blocking. Native image vẫn là tuỳ chọn theo service, không phải đích bắt buộc.

Checklist trước khi chọn Spring

  • Viết ra ba ràng buộc vận hành cứng: startup, RAM mỗi instance, thời gian deploy. Không có con số thì chưa có ràng buộc.
  • Xác nhận team có ít nhất một người debug được JVM và transaction; nếu không, tính vào kế hoạch tuyển dụng.
  • Chọn Java 25 LTS và một JDK miễn phí (Temurin/Corretto/Zulu) trước khi tạo dự án.
  • Tạo dự án bằng Spring Initializr với Boot 4.1.2, chỉ thêm starter bạn thực sự dùng.
  • Đo cold start và RSS của một service mẫu trên hạ tầng thật trước khi cam kết với cả hệ thống.

Bước tiếp theo trong series là hiểu thuật ngữ trước khi đọc code: Giải thích thuật ngữ cốt lõi của Spring. Sau đó đi vào cơ chế: Dependency Injection và kiến trúc cốt lõi của Spring. Khi đã nắm bức tranh, quay lại lộ trình Spring Boot để đi theo 9 chặng.