Spring Boot Roadmap – Lộ trình phát triển cho Java Spring Boot 2026

Phần lớn lộ trình Spring trên mạng vẫn dạy bạn cấu hình XML, dựng Eureka làm service discovery mặc định, dùng Sleuth để trace và Hystrix để chống lỗi. Bốn thứ đó hoặc đã chết, hoặc không còn là lựa chọn đúng cho một hệ thống mới. Bài này là bản đồ cập nhật cho cuối năm 2026: học gì, theo thứ tự nào, và cái gì nên bỏ qua.

Mục tiêu không phải là biết thật nhiều annotation. Mục tiêu là có thể dựng một dịch vụ Spring Boot 4 chạy được trên Java 25, có test tự động, có quan sát, có bảo mật, và biết khi nào không nên dùng Spring cho một bài toán cụ thể.

Cập nhật 2026: năm điều thay đổi cách học Spring

  • Spring Boot 4.1.2 / Spring Framework 7.0.10 là dòng ổn định hiện tại. Boot 3.5 chỉ còn là dòng cũ; tài liệu, video và khóa học viết cho Boot 3 vẫn đọc được nhưng nhiều API đã bị deprecate hoặc remove.
  • Java 25 LTS là nền tảng production. Java 27 (GA 15/09/2026) là bản feature release, không phải LTS — đừng chọn nó chỉ vì số lớn hơn.
  • Sleuth đã bị archive, thay bằng Micrometer Tracing. Hystrix đã chết từ 2018, thay bằng Resilience4j qua Spring Cloud Circuit Breaker.
  • RestTemplate đã deprecated trong Framework 7. Đường mặc định là RestClient, HTTP interface client, hoặc WebClient cho luồng reactive.
  • Test stack đổi thế hệ: JUnit Jupiter 6.1.x, Testcontainers 2.0.x, @MockitoBean thay cho @MockBean.

Bức tranh phiên bản trước khi bắt đầu

Hãy chọn phiên bản trước khi chọn tài liệu. Học theo một tutorial dùng Boot 2.7 sẽ khiến bạn debug những thứ không còn tồn tại.

Thành phần Bản ổn định (11/2026) Ghi chú
JDK 25 LTS Boot 4.1 hỗ trợ Java 17–27
Spring Boot 4.1.2 4.0.9 là dòng trước; 4.2.0-RC2 chỉ là preview
Spring Framework 7.0.10 JSpecify, API versioning, retry trong core
Spring Cloud 2025.1.4 “Oakwood” Dùng chung với Boot 4.0/4.1
Spring Security 7.1.2 Lambda DSL là bắt buộc
Spring Data JPA / Hibernate 4.1.2 / 7.4.15.Final Hibernate 8 chỉ là beta
Spring AI 2.0.2 Có MCP client/server
Build Maven 3.10.0, Gradle 9.9.0 Maven 4 vẫn chỉ là RC

Điểm dễ hiểu sai nhất: Boot 4 không phải bản “làm lại” cần học từ đầu. Nó là Boot 3.5 cộng với Framework 7, Jakarta EE 11 và một tầng module hóa. Nếu bạn đã quen Boot 3, phần lớn kiến thức giữ nguyên; thứ thay đổi là cách cấu hình, cách gọi HTTP, cách test và cách version API.

Lộ trình 9 chặng

Thứ tự dưới đây đi từ ngôn ngữ đến vận hành. Đừng nhảy vào Spring Cloud trước khi biết viết một service Boot có test — microservices chỉ khuếch đại vấn đề cơ bản, không sửa được chúng.

Chặng 1 — Java core và toolchain (2–3 tuần)

Spring là một lớp mỏng trên Java. Nếu bạn không hiểu generics, collections, exception, thread và JVM memory, mọi lỗi Spring sẽ trông như lỗi “magic”. Với bản 2026, phần concurrency cần thêm virtual threads: chúng là lý do spring.threads.virtual.enabled=true trở thành lựa chọn thực tế thay vì thí nghiệm.

Nội dung tối thiểu: OOP và SOLID ở mức áp dụng được, collections và Map semantics, stream API, exception handling, generics, record, sealed class, pattern matching, thread pool và virtual thread, JVM heap/GC ở mức đọc log. Bỏ qua Applet, Java EE cũ, và các câu hỏi kiểu “String có immutable không” nếu bạn chỉ cần làm việc.

Hai bài phỏng vấn trong series là nguồn câu hỏi tốt để tự kiểm tra: Trọn bộ câu hỏi phỏng vấn Java Core và bản mở rộng.

Chặng 2 — Spring Core: IoC, DI, bean, AOP (2 tuần)

Đây là phần không được phép học vẹt. Bốn khái niệm cần nắm như một hệ thống: container quản lý bean, bean definition mô tả cách tạo, dependency injection quyết định ai nhận ai, và proxy giải thích tại sao @Transactional hay @Async lại hoạt động.

Hiểu thứ tự này sẽ trả lời được các câu hỏi thực tế: tại sao @Transactional không có tác dụng khi gọi nội bộ cùng class; tại sao prototype bean không được inject vào singleton; tại sao circular dependency chỉ lộ ra lúc runtime với constructor injection.

Đọc theo thứ tự: thuật ngữ cốt lõi, dependency injection, IoC trong thực tế, bean scope, annotations và AOP.

Bỏ qua: cấu hình XML. Nó vẫn tồn tại trong các dự án cũ, nhưng không phải kỹ năng cần học đầu tiên. Bài XML và annotations đủ để bạn đọc được code legacy; đừng dựng dự án mới bằng XML.

Chặng 3 — Web nền tảng và Spring MVC (2 tuần)

Bạn không cần viết servlet thuần, nhưng cần biết request đi qua đâu: filter → DispatcherServlet → handler mapping → argument resolver → message converter → view. Khi một request trả về 415 hoặc 406, kiến thức này là thứ giúp bạn sửa trong vài phút thay vì đoán.

Bài học theo thứ tự: kiến trúc cốt lõi, servlet, DispatcherServlet, ứng dụng web đầu tiên, các thành phần thiết yếu.

Bỏ qua JSP cho dự án mới. Bài Spring MVC và JSP hữu ích để đọc code cũ; frontend mới nên tách khỏi backend và dùng JSON API. Nếu cần render server-side, Thymeleaf là lựa chọn hợp lý hơn JSP.

Chặng 4 — Spring Boot: từ cấu hình đến vận hành (2 tuần)

Boot là thứ biến Spring từ một framework cấu hình tay thành một runtime có opinion. Học ba cơ chế: starter (gom dependency), auto-configuration (quyết định bean nào được tạo), và điều kiện bật/tắt (@ConditionalOnClass, @ConditionalOnProperty). Hiểu ba thứ này là hiểu tại sao thêm một starter lại “tự có” cả một tính năng.

Thứ tự: starter, auto-configuration, Tomcat nhúng, Actuator.

Một application.yml tối thiểu cho Boot 4.1 trên Java 25:

# File: src/main/resources/application.yml
spring:
  application:
    name: order-service
  threads:
    virtual:
      enabled: true
  mvc:
    apiversion:
      use:
        header: X-API-Version

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  tracing:
    sampling:
      probability: 1.0

Lưu ý: API versioning có trong Boot 4 nhưng cách đặt property có thể khác theo tài liệu từng bản. Hãy kiểm tra mục “API Versioning” trong reference của Boot 4.1 trước khi copy nguyên khối trên vào production.

Chặng 5 — Tầng dữ liệu: JPA, Hibernate, JDBC (3 tuần)

Đây là chặng gây lỗi production nhiều nhất. Ba câu hỏi phải trả lời được: entity đang ở trạng thái nào trong persistence context, transaction biên ở đâu, và query nào thực sự chạm database.

Học theo thứ tự: entity đầu tiên, quan hệ JPA, vòng đời entity, transaction, Spring Data JPA.

Ba quy tắc thực dụng:

  • Transaction nằm ở service, không nằm ở controller. Controller mở transaction nghĩa là bạn giữ connection trong lúc serialize response.
  • LAZY chỉ có nghĩa trong transaction hoặc khi có fetch plan rõ ràng. Nếu không, bạn sẽ gặp LazyInitializationException hoặc N+1 mà không biết.
  • Đừng dùng JPA cho mọi thứ. Báo cáo phức tạp, batch lớn, bulk update nên đi qua JDBC (JdbcClient) hoặc query native có kiểm soát.

Khi JPA quá nặng cho mô hình đơn giản, Spring Data JDBC là lựa chọn tốt hơn: không lazy loading, không dirty checking ngầm, aggregate rõ ràng. Với tài liệu linh hoạt, Spring Data MongoDB vẫn hữu dụng, nhưng đừng chọn MongoDB chỉ vì “không cần schema”.

Chặng 6 — Bảo mật với Spring Security 7 (2–3 tuần)

Security 7 không còn WebSecurityConfigurerAdapter và không còn DSL and(). Mọi cấu hình là một SecurityFilterChain bean, viết theo lambda. Đây là thay đổi cú pháp lớn nhất mà tutorial cũ sẽ làm bạn sai.

// File: config/SecurityConfig.java
@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    SecurityFilterChain api(HttpSecurity http) throws Exception {
        http
            .csrf(csrf -> csrf.disable())
            .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/actuator/health").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated())
            .oauth2ResourceServer(oauth -> oauth.jwt(Customizer.withDefaults()));
        return http.build();
    }
}

Lộ trình đọc: xác thực vs phân quyền, cấu hình xác thực, RBAC, OAuth2, JWT.

Điểm cần nhấn: đừng tự viết JWT filter nếu bạn có thể dùng oauth2ResourceServer().jwt(). Tự parse token là nơi sinh ra lỗi thuật toán alg:none, thiếu kiểm tra iss/aud, và sai thời gian cache key. Passkey/WebAuthn đã có hỗ trợ trong Security 7 nhưng API còn thay đổi; hãy đọc docs của bản 7.1 trước khi cam kết.

Chặng 7 — Testing: từ unit đến integration (2 tuần)

Test trong Spring có ba tầng, và mỗi tầng có chi phí khác nhau:

  • Unit test thuần — không Spring context, dùng Mockito hoặc fake. Nhanh, chiếm phần lớn test.
  • Slice test — @WebMvcTest cho controller, @DataJpaTest cho repository. Chỉ nạp phần cần thiết.
  • Integration test — @SpringBootTest với database thật qua Testcontainers. Chậm nhưng kiểm tra được wiring, transaction và SQL thật.

Đọc: unit test repository, MockMvc, @SpringBootTest, mock bean (bài cũ dùng @MockBean; bản 2026 dùng @MockitoBean).

// File: src/test/java/OrderRepositoryIT.java
@SpringBootTest
@Testcontainers
class OrderRepositoryIT {

    @Container
    @ServiceConnection
    static PostgreSQLContainer<?> db = new PostgreSQLContainer<>("postgres:17-alpine");

    @Autowired OrderRepository repository;

    @Test
    void finds_by_status() {
        var saved = repository.save(Order.of("NEW"));
        assertThat(repository.findByStatus("NEW")).contains(saved);
    }
}

JUnit Jupiter 6.1.x yêu cầu Java 17+, phù hợp với baseline của Boot 4. Testcontainers 2.0 tách module rõ hơn; nếu dependency không resolve, kiểm tra lại artifact name thay vì thêm version lung tung.

Chặng 8 — Microservices và Spring Cloud (3 tuần)

Chỉ học chặng này khi bạn đã có một service chạy tốt. Spring Cloud không làm code của bạn đúng hơn; nó chỉ thêm network, latency và failure mode.

Bốn thành phần còn sống và đáng học:

  • Gateway — cổng vào, routing, rate limit, auth offload. Bài Gateway.
  • Config — cấu hình tập trung. Vẫn hữu dụng, nhưng với Kubernetes, ConfigMap + Secret thường đủ. Bài Config.
  • Circuit Breaker + Resilience4j — thay Hystrix. Bài circuit breaker; bài Hystrix chỉ nên đọc như lịch sử.
  • Micrometer Tracing — thay Sleuth. Bài Sleuth giải thích khái niệm trace/span; phần triển khai dùng Micrometer Tracing + OpenTelemetry bridge.

Service discovery: Eureka vẫn còn trong Spring Cloud 2025.1 và vẫn chạy tốt trên VM. Nhưng nếu hạ tầng là Kubernetes, đừng dựng Eureka chỉ để “đúng roadmap”. Bài Eureka nên đọc như một lựa chọn, không phải mặc định.

Gọi service khác: ưu tiên HTTP interface client của Framework 7 (@HttpExchange + RestClient). OpenFeign vẫn hoạt động và có giá trị khi bạn cần nhiều tính năng cân bằng tải, nhưng thêm một abstraction cho mỗi lời gọi HTTP là chi phí thật. Bài OpenFeign.

Nền tảng khái niệm: Spring Cloud và microservices.

Chặng 9 — Production: quan sát, hiệu năng, triển khai (liên tục)

Ba việc tách một dự án “chạy được trên máy” khỏi một dịch vụ vận hành được:

  • Observability: Actuator cho health/metrics, Micrometer cho metric, Micrometer Tracing + OTel cho trace, log có correlation ID. Đừng log mọi request body.
  • Hiệu năng: virtual threads cho I/O-bound; pool size cho CPU-bound; connection pool (Hikari) phải nhỏ hơn số connection database chịu được. Đo bằng load test, không đo bằng cảm giác.
  • Đóng gói: JVM mode là mặc định. GraalVM native image chỉ đáng dùng khi cold start hoặc memory là ràng buộc thật; nó đòi hỏi xử lý reflection/resource config và làm test cycle chậm hơn.

API versioning là thứ nên quyết định sớm, không phải sau khi có client. Framework 7 hỗ trợ version qua header hoặc path; chọn một kiểu và ghi vào hợp đồng API. Nếu dùng header, đặt tên nhất quán (X-API-Version) và trả lỗi rõ ràng khi thiếu version.

Bảng so sánh: lộ trình 2025 và lộ trình 2026

Chủ đề Bản 2025 hay dạy Bản 2026 nên dạy
Nền tảng Spring Boot 3.x, Java 21 Spring Boot 4.1, Java 25 LTS
Cấu hình XML + @Autowired field injection Java config, constructor injection
HTTP client RestTemplate RestClient, HTTP interface
Bảo mật WebSecurityConfigurerAdapter SecurityFilterChain + lambda DSL
Resilience Hystrix Resilience4j + Spring Cloud Circuit Breaker
Tracing Sleuth Micrometer Tracing + OTel
Discovery Eureka mặc định Eureka là một lựa chọn; K8s/Consul là lựa chọn khác
Test JUnit 5, @MockBean JUnit 6.1, @MockitoBean, Testcontainers 2

Kế hoạch 12 tuần

Tuần Nội dung Sản phẩm
1–3 Java core, virtual threads, build tool CLI app có test, chạy trên JDK 25
4–5 Spring Core, DI, AOP Service không dùng Boot, viết bằng Java config
6–7 Spring MVC, REST, validation CRUD API có error handler chuẩn
8–9 Boot, Actuator, cấu hình Service Boot 4.1 có health/metrics
10–11 JPA, transaction, migration Schema bằng Flyway, test repository
12 Security + test tích hợp JWT resource server, Testcontainers IT
13–14 Spring Cloud (tuỳ chọn) Gateway + một service downstream

Nếu chỉ có 6 tuần, cắt chặng 8. Một service Boot đúng chuẩn có giá trị nghề nghiệp cao hơn ba service nối với nhau bằng cấu hình copy-paste.

Những lỗi phổ biến khi tự học theo roadmap

  • Học Spring Cloud trước Spring Core. Kết quả là debug bằng cách thêm annotation, không phải bằng cách hiểu container.
  • Field injection vì “ngắn hơn”. Nó che circular dependency và làm unit test phải dùng reflection hoặc cả Spring context.
  • Dùng @Transactional trên mọi method. Transaction lồng nhau, timeout, và connection giữ lâu là hệ quả trực tiếp.
  • Copy cấu hình Security từ blog cũ. Code không compile vì and() đã bị bỏ; tệ hơn là cấu hình sai thứ tự matcher.
  • Đọc version từ bài viết thay vì từ BOM. Boot BOM đã quản lý version; thêm version tay chỉ tạo xung đột.
  • Đánh đồng “có Actuator” với “có observability”. Metric không có ai xem thì không phải observability.

Nhìn về 2027

Spring Boot 4.2 và Framework 7.1 đang ở giai đoạn RC, nhiều khả năng lên bản ổn định trong vài tháng tới; đừ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). Spring AI 2.x sẽ tiếp tục mở rộng MCP; nếu bạn làm backend có tích hợp LLM, học MCP sớm có lợi hơn học từng SDK riêng. Structured Concurrency vẫn là preview — đừng đưa vào production chỉ vì nó được nhắc nhiều.

Điều không đổi: hiểu container, transaction và network vẫn là kỹ năng có giá trị lâu hơn mọi phiên bản framework.

Checklist bắt đầu

  • Cài JDK 25 LTS (Temurin/Corretto/Zulu), không dùng JDK 8/11 cho dự án mới.
  • Tạo dự án bằng Spring Initializr với Boot 4.1.2, chọn Maven 3.10 hoặc Gradle 9.9.
  • Bật spring.threads.virtual.enabled và đo lại latency trước/sau, đừng bật mù.
  • Viết một integration test Testcontainers trước khi thêm tính năng thứ hai.
  • Chốt cách version API và cách trả lỗi ngay từ endpoint đầu tiên.
  • Đọc docs của bản bạn đang dùng, không đọc blog; ghi version vào README.

Bắt đầu từ nền tảng trong series: Tại sao chọn Spring, rồi Dependency Injection. Khi đã dựng được service đầu tiên, quay lại danh sách chặng và chọn chặng 5 hoặc 6 làm chiều sâu tiếp theo.