Spring là gì — bài toán framework giải quyết và bản đồ kiến trúc

TL;DR: Spring ra đời 2003-2004 vì Java EE/EJB 2.x quá phức tạp (5 file cho 1 method nghiệp vụ, vendor lock-in, không test offline được). Idea cốt lõi: object lắp ráp lẫn nhau qua new gây tight coupling — IoC container đảo ngược trách nhiệm này. Spring Framework là bộ ~20 module xây trên IoC; Spring Boot không phải framework mới mà là 5 thứ đóng gói: Framework + Starter + AutoConfig + Embedded server + Actuator. Pitfall lớn nhất: nhầm Boot là Spring "phiên bản mới" và bỏ qua Framework — khi debug bean injection hay transaction rollback, bạn đang chạm vào Framework.

Bạn mở một dự án Java backend bất kỳ ở Việt Nam — banking, e-commerce, fintech, gov-tech — gần như chắc chắn thấy import org.springframework.* ở đầu mọi file. Spring xuất hiện ở 80% job description Java; nhiều nơi viết thẳng "Spring Boot" thay vì "Java" trong tên vị trí. Câu hỏi tự nhiên là: vì sao một framework ra mắt 2003, lúc bạn còn chưa sinh ra hoặc đang học mẫu giáo, lại vẫn là default choice năm 2026?

Bài này dài vì cover bối cảnh + kiến trúc + lịch sử. Bạn sẽ đi qua: (1) bài toán Java EE để lại, (2) ý tưởng cốt lõi Spring giải quyết, (3) bản đồ kiến trúc 20 module của Spring Framework, (4) 5 lớp cốt lõi của Spring Boot, (5) vòng đời 1 HTTP request từ socket đến database. Sau bài này, mọi annotation, magic, autoconfig của các bài sau hiện ra như logic, không còn là phép thuật.

1. Bối cảnh — Java EE 2001 và lý do nó thất bại

Đầu thập niên 2000, Java enterprise đứng trên 3 chân: EJB 2.x (Enterprise JavaBeans), JNDI, và application server kiểu WebLogic, WebSphere, JBoss. Bạn muốn viết 1 service đơn giản — ví dụ BookingService lưu booking vào DB — bạn phải viết:

• 1 interface remote (BookingServiceRemote) extend EJBObject.
• 1 interface home (BookingServiceHome) extend EJBHome với method create().
• 1 bean class (BookingServiceBean) implement SessionBean với ejbCreate(), ejbActivate(), ejbPassivate(), ejbRemove(), setSessionContext().
• 1 file XML deployment descriptor ejb-jar.xml ~80 dòng khai báo bean.
• 1 file XML vendor-specific weblogic-ejb-jar.xml để map JNDI name.

Tổng cộng: 5 file cho 1 method nghiệp vụ. Test? Không thể test ngoài app server. Chạy local? Phải start cả WebLogic 4GB RAM. Đổi từ WebLogic sang JBoss? Viết lại vendor descriptor.

flowchart LR
    Client["Client"] --> Home["BookingServiceHome<br/>(JNDI lookup)"]
    Home --> Remote["BookingServiceRemote"]
    Remote --> Bean["BookingServiceBean<br/>(impl thuc te)"]
    Bean --> DB[("Database")]
    style Home fill:#fee
    style Remote fill:#fee

Bốn vấn đề thực tế gặp khi làm EJB 2.x:

Rod Johnson — kỹ sư người Úc làm tư vấn enterprise Java — viết quyển "Expert One-on-One J2EE Design and Development" năm 2002, dày 700 trang. Quyển sách dành chương cuối kèm theo 30,000 dòng code mẫu để demo: cùng nghiệp vụ ấy, viết bằng plain Java POJO (Plain Old Java Object) với một container nhẹ để inject dependency, ngắn hơn 10 lần và test được offline. Code đó tên là Interface21. Năm 2003, Johnson cùng Juergen Hoeller open-source nó dưới tên Spring Framework — phiên bản 1.0 ra ngày 24/03/2004.

Tên "Spring" được chọn theo nghĩa "spring after a long winter of J2EE" — mùa xuân sau mùa đông dài của J2EE. Cái tên là tuyên ngôn ngầm: framework này thoát khỏi sự cồng kềnh của EJB.

2. Bài toán cốt lõi — không phải về annotation, mà về quyền điều khiển

Quên Spring đi 1 phút. Nghĩ về 1 đoạn code Java thuần, chưa có framework nào:

public class OrderService {
    private PaymentGateway payment = new StripePayment();
    private EmailService email = new SmtpEmailService();
    private InventoryClient inventory = new HttpInventoryClient("http://inv:8080");

    public void placeOrder(Order order) {
        inventory.reserve(order.items());
        payment.charge(order.total());
        email.send(order.customer(), "Order confirmed");
    }
}

Code này chạy được. Nhưng nó vướng 5 vấn đề mà mọi backend developer phải đối mặt khi codebase lớn lên:

Ba bài học từ 5 vấn đề trên:

1. Object cần được "lắp ráp" bởi một thực thể bên ngoài, không phải tự lắp ráp lẫn nhau.
2. Object cần được mô tả qua interface, để có thể thay implementation.
3. Lifecycle (tạo, init, destroy) cần một entity quản lý, không phải code nghiệp vụ.

Đó chính là 3 chức năng của IoC container — phần lõi của Spring. Phần còn lại của framework (web, data, security, ...) đều xây trên hạt nhân này.

3. Bản đồ kiến trúc — Spring Framework có gì

Spring Framework không phải 1 jar khổng lồ. Nó là bộ ~20 module, mỗi module giải quyết 1 nhóm vấn đề, có jar riêng, có thể dùng độc lập. Sơ đồ chính thức từ docs Spring (đơn giản hoá):

flowchart TB
    subgraph Core["Core Container (BAT BUOC)"]
        spc["spring-core<br/>(util, classloader, IO)"]
        spb["spring-beans<br/>(BeanFactory, DI engine)"]
        spx["spring-context<br/>(ApplicationContext, events)"]
        spe["spring-expression<br/>(SpEL)"]
    end

    subgraph DataAccess["Data Access / Integration"]
        spj["spring-jdbc"]
        spo["spring-orm<br/>(JPA, Hibernate)"]
        spt["spring-tx<br/>(@Transactional)"]
        spjms["spring-jms"]
        spoxm["spring-oxm<br/>(XML marshalling)"]
    end

    subgraph Web["Web Layer"]
        spw["spring-web<br/>(HTTP foundations)"]
        spmvc["spring-webmvc<br/>(@Controller, DispatcherServlet)"]
        spwf["spring-webflux<br/>(reactive)"]
    end

    subgraph Aspects["AOP & Instrumentation"]
        spa["spring-aop"]
        spaj["spring-aspects<br/>(AspectJ integration)"]
    end

    subgraph Test["Testing"]
        spt2["spring-test<br/>(MockMvc, slice tests)"]
    end

    Core --> DataAccess
    Core --> Web
    Core --> Aspects
    Core --> Test

Bảng module quan trọng cần biết:

Hệ quả thực tế: khi bạn thấy import org.springframework.beans.factory.annotation.Autowired, bạn biết @Autowired ở module spring-beans. Khi thấy import org.springframework.transaction.annotation.Transactional, bạn biết module spring-tx. Hiểu mapping này giúp đọc stack trace nhanh hơn — package org.springframework.X thường tương ứng module spring-X.

3.1 IoC container — module spring-beans + spring-context

Đây là trái tim của Spring. Khi bạn nghe "Spring là IoC container", chính xác là 2 module này. Chúng cung cấp:

• BeanFactory — interface gốc tối giản (sẽ bóc ở bài 03).
• ApplicationContext — interface đầy đủ extend BeanFactory với i18n, event, environment.
• Annotation @Component, @Service, @Repository, @Controller, @Configuration, @Bean, @Autowired, @Qualifier, @Value, @Scope, @PostConstruct, @PreDestroy.
• Component scanner — quét classpath tìm bean.
• Dependency resolution engine — topological sort, ambiguity handling.

Mọi module Spring khác đều build trên IoC container. spring-webmvc đăng ký DispatcherServlet như 1 bean; spring-tx đăng ký TransactionManager như 1 bean; spring-data đăng ký repository như bean. Không có module nào tự sống độc lập với container.

3.2 Web stack — 2 lựa chọn không cùng tồn tại

Spring có 2 web stack hoàn toàn khác kiến trúc:

WebFlux không thay MVC — chúng song song tồn tại, chọn theo nhu cầu. Track này dạy MVC ở course Spring REST & Data (chính), WebFlux ở course Spring Reactive & Microservices (advanced).

3.3 Data access — JDBC, ORM, Transaction

Spring có 3 layer data access từ thấp đến cao:

flowchart TB
    A["Business code"]
    B["spring-data-jpa<br/>Repository<User, Long>"]
    C["spring-orm<br/>JPA / Hibernate / EntityManager"]
    D["spring-jdbc<br/>JdbcTemplate / JdbcClient"]
    E["JDBC driver / DataSource"]

    A --> B
    A --> C
    A --> D
    B --> C
    C --> D
    D --> E

    style B fill:#d1fae5

• spring-jdbc: low-level — JdbcTemplate viết SQL trực tiếp, parameter binding tự động, exception translation. Phù hợp khi bạn cần kiểm soát SQL đầy đủ.
• spring-orm: integrate JPA/Hibernate vào IoC container — EntityManager thành bean inject được.
• spring-data-jpa (separate project, không thuộc Framework core): thêm Repository abstraction — bạn khai báo interface, Spring sinh implementation. Ngày nay là default cho 90% app.

spring-tx là cross-cutting — @Transactional hoạt động trên cả 3 layer trên.

4. Spring Boot — không phải framework mới, là 5 thứ đóng gói

Đến 2014, Spring 4 vẫn yêu cầu mỗi project mới làm 5 thao tác:

1. Khai báo dependency spring-context, spring-web, spring-orm, ... vào pom.xml.
2. Tạo web.xml khai báo DispatcherServlet.
3. Tạo applicationContext.xml (hoặc Java config class) khai báo bean.
4. Cấu hình embedded server (Jetty/Tomcat) hoặc deploy WAR vào server ngoài.
5. Cấu hình logging (Logback), DataSource, JPA properties, ...

Ai cũng làm 5 bước y hệt. Spring Boot ra đời 2014 với 1 idea đơn giản: gom 5 bước đó thành opinionated defaults — bạn chỉ cần khai báo "tôi muốn build web app", Boot tự setup tất cả.

// Spring 4 — toi thieu 80 dong cau hinh + 4 file XML/Java
// Spring Boot 3 — 1 file, 12 dong:

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

@RestController
class HelloController {
    @GetMapping("/")
    String hello() { return "Hello from Spring Boot"; }
}

Chạy mvn spring-boot:run — Boot tự khởi Tomcat embedded port 8080, scan classpath thấy HelloController đăng ký route, log start banner. Không có XML, không có deploy descriptor, không có server cài riêng.

Spring Boot không phải framework mới. Nó là tập hợp 5 thứ đóng gói:

flowchart LR
    SB["Spring Boot"]
    Core["Spring Framework<br/>(core, web, data, ...)"]
    Starter["Starter Dependencies<br/>(spring-boot-starter-*)"]
    Auto["Auto-Configuration<br/>(@EnableAutoConfiguration)"]
    Embed["Embedded Server<br/>(Tomcat/Jetty/Netty)"]
    Act["Actuator<br/>(metrics, health, info)"]

    SB --> Core
    SB --> Starter
    SB --> Auto
    SB --> Embed
    SB --> Act

    style SB fill:#fef3c7

4.1 Starter dependencies

Một starter là 1 jar rỗng — không chứa code, chỉ là collection of <dependency> trong pom.xml. Ví dụ:

<!-- spring-boot-starter-web pull theo: -->
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-json</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-web</artifactId></dependency>
<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId></dependency>

Bạn chỉ khai 1 dòng spring-boot-starter-web, Maven pull tất cả transitive. Starter phổ biến:

Triết lý: 1 use case = 1 starter, không phải pick từng jar.

4.2 Auto-configuration

Đây là magic chính của Boot. Khi container start, Spring Boot scan classpath, tuỳ vào jar có sẵn mà tự đăng ký bean:

Auto-config dựa trên @Conditional* annotation (đã thấy ở bài 06) — register bean chỉ khi điều kiện đúng (class tồn tại, bean chưa có, property bật, ...). Kết quả: thêm/xóa starter → app tự thay đổi behavior, không phải sửa config.

Phần Spring Boot Autoconfig (cuối course này) sẽ bóc tách auto-config ở mức bytecode. Bài này chỉ cần biết: Boot không tạo bean ngẫu nhiên — mỗi bean Boot tạo đều có condition rõ ràng.

4.3 Embedded server

Trước Boot, Java web app deploy WAR vào Tomcat/Jetty cài riêng. Sau Boot, server đóng gói trong jar:

mvn package
java -jar target/app.jar    # Tomcat tu start trong jar

Lợi ích:

• 1 artifact duy nhất — dễ ship Docker, K8s.
• Process model 1 jar = 1 process — phù hợp cloud-native.
• Test local không cần cài server.

Boot support 4 embedded server:

4.4 Actuator

Production-ready endpoints có sẵn — health, metrics, env, loggers, info, configprops, mappings, beans, threaddump. Thêm spring-boot-starter-actuator, expose /actuator/health, /actuator/metrics, ... ngay lập tức.

curl http://localhost:8080/actuator/health
# {"status":"UP","components":{"db":{"status":"UP"},"diskSpace":{"status":"UP"}}}

Course Spring in Production (Observability) sẽ dùng Actuator + Micrometer + Prometheus + Grafana đầy đủ.

4.5 DevTools (optional)

spring-boot-devtools: hot reload class khi save, restart context, disable cache template. Chỉ kích hoạt khi chạy local — production tự skip qua dependency scope.

5. Vòng đời 1 HTTP request — bản đồ tổng

Khi bạn gửi GET /api/orders/123 đến app Spring Boot, request đi qua những lớp nào? Đây là big picture giúp định vị mọi annotation/concept của các module sau:

sequenceDiagram
    participant Client
    participant TC as Tomcat Connector<br/>(port 8080)
    participant Filter as Servlet Filter Chain<br/>(Security, CORS, ...)
    participant DS as DispatcherServlet
    participant HM as HandlerMapping
    participant HI as HandlerInterceptor
    participant Ctrl as @RestController<br/>OrderController
    participant Svc as @Service<br/>OrderService
    participant Repo as @Repository<br/>OrderRepository
    participant DB as PostgreSQL

    Client->>TC: GET /api/orders/123
    TC->>Filter: HttpServletRequest
    Filter->>DS: pass (filter doesn't reject)
    DS->>HM: which handler for path?
    HM-->>DS: OrderController.getOrder(Long)
    DS->>HI: preHandle()
    DS->>Ctrl: invoke getOrder(123)
    Ctrl->>Svc: orderService.findById(123)
    Svc->>Repo: orderRepository.findById(123)
    Repo->>DB: SELECT * FROM orders WHERE id=123
    DB-->>Repo: row data
    Repo-->>Svc: Optional<Order>
    Svc-->>Ctrl: Order DTO
    Ctrl-->>DS: ResponseEntity<OrderDto>
    DS->>DS: serialize JSON via Jackson
    DS->>HI: postHandle()
    DS-->>Filter: HttpServletResponse
    Filter-->>TC: response with body
    TC-->>Client: HTTP 200 + JSON

Mỗi lớp do 1 module Spring quản lý:

Hệ quả: khi debug "tại sao request 401", bạn biết lớp Filter (Security). "Tại sao 404" — HandlerMapping. "Tại sao tx không rollback" — spring-tx. "Tại sao N+1 query" — spring-orm/spring-data-jpa.

Track Spring bóc từng lớp qua nhiều course:

• Course này — Spring Core (đang đọc): IoC container, lifecycle, config + Spring Boot foundations (auto-config, starter, embedded server) — phần lõi cho mọi lớp service/repo.
• Spring REST & Data: Web layer (DispatcherServlet, @RestController, validation) + Data layer (Spring Data JPA, transaction).
• Spring Security & Testing: Filter layer — Spring Security, JWT — và test slice cho từng layer.
• Spring in Production: observability cho toàn bộ chain.
• Spring Reactive & Microservices, Spring Cloud & AI: các lớp nâng cao reactive, microservice, tích hợp AI.

6. Spring Framework qua 6 phiên bản

Spring không phải framework tĩnh — nó tiến hoá theo Java và theo industry. Hiểu lịch sử các version giúp bạn đọc code legacy không hoang mang:

Hai bước nhảy quan trọng nhất:

• Spring 3 (2009): chuyển từ XML sang annotation. Đây là lý do code Spring legacy 2009-2014 vẫn còn applicationContext.xml, code 2015+ chủ yếu là Java config.
• Spring 6 (2022): rename namespace từ javax.* (Java EE) sang jakarta.* (Jakarta EE) do Oracle nhường thương hiệu Java EE cho Eclipse Foundation. Đây là breaking change — code Spring 5 không build được trên Spring 6 nếu không migrate import. Khoá này dùng Spring 6.x đi cùng Spring Boot 3.x.

Bảng compatibility quan trọng — dùng để pick version cho project mới:

(kn 21 = "khuyến nghị 21" để có Virtual Threads).

7. Spring ecosystem — không chỉ là "Spring Boot"

Khi search "Spring", bạn sẽ thấy hàng chục project. Đây là bản đồ rút gọn — mỗi mảng là 1 module riêng, có lifecycle release riêng, đôi khi có version riêng:

Khoá này tập trung Spring Framework + Spring Boot + Spring Data + Spring Security + Spring AI. Bốn module này phủ ~95% công việc của Java backend developer mid-level. Spring Cloud, Modulith chạm đến ở Tier 3 (senior). Batch, Integration là use case ngách — không có trong khoá nhưng nền tảng IoC giống nhau, dễ pick up khi cần.

8. Vì sao Spring vẫn dominate năm 2026

Quarkus, Micronaut, Helidon — 3 framework Java backend ra đời sau 2018, đều thiết kế lại "tốt hơn Spring" trên giấy: native image first-class, startup nhanh hơn, bộ nhớ ít hơn. Nhưng Spring vẫn chiếm ~70% thị phần. Vì sao?

Bốn lý do, theo thứ tự ảnh hưởng:

1. Inertia khổng lồ: 22 năm tài liệu, Stack Overflow, sách. Bạn gặp bug — search ra 30 issue cũ + giải pháp. Quarkus/Micronaut có vài năm — community còn nhỏ, search ra ít kết quả.
2. Ecosystem chiều rộng: tất cả integration (Kafka, Redis, Postgres, S3, OAuth provider, Vault, ...) đều có Spring starter sẵn. Quarkus đang đuổi nhưng chưa tới — vd Spring AI có sẵn provider cho 8 LLM, Quarkus LangChain4j chưa có Anthropic native.
3. Spring Boot 3.2+ bắt kịp: Virtual Threads (Java 21), GraalVM native, observability với Micrometer — không còn yếu thế về performance/startup. Boot 3.3 + CDS + Java 21 = startup ~500ms cho app cỡ vừa.
4. Pivotal/VMware/Broadcom đầu tư đều đặn — Spring có team trả lương full-time, không phải open source kiểu hobby. Release đều mỗi 6 tháng.

Câu hỏi đúng không phải "Spring có còn phù hợp?", mà là "khi nào dùng Spring vs Quarkus?". Câu trả lời ngắn:

• Default Spring: web app, microservices, monolith, anything với team Java mainstream.
• Quarkus: serverless function với cold-start critical (AWS Lambda, GCP Functions), native image là yêu cầu cứng (memory dưới 64MB), team đã có kinh nghiệm Quarkus từ trước.

9. 📚 Deep Dive Spring Reference

10. Tóm tắt

• Spring ra đời 2003-2004 để giải quyết sự phức tạp và vendor lock-in của Java EE/EJB 2.x.
• Bài toán cốt lõi: object lắp ráp lẫn nhau qua new dẫn đến tight coupling, khó test, lifecycle khó kiểm soát. Lời giải: IoC container — entity bên ngoài chịu trách nhiệm tạo, lắp ráp, lifecycle.
• Spring Framework là bộ ~20 module, tất cả xây trên IoC container (spring-beans + spring-context). Modules theo nhóm: Core, Data Access, Web, AOP, Test.
• Spring Boot không phải framework mới. Nó là 5 thứ đóng gói: Spring Framework + Starter dependency + Auto-configuration + Embedded server + Actuator.
• Web app có 2 stack song song: MVC (servlet, blocking) — default 95% case, WebFlux (reactive, non-blocking) — I/O-heavy/streaming.
• Vòng đời 1 HTTP request đi qua 10 lớp — mỗi lớp do module Spring khác quản. Hiểu mapping này giúp debug nhanh.
• Spring 6 (2022) là cột mốc rename javax.* → jakarta.*. Khoá này dùng Spring Boot 3.4.x + Spring Framework 6.2.x + Java 21.
• Ecosystem có hàng chục project. Khoá tập trung Framework + Boot + Data + Security + AI — phủ 95% việc của backend developer.
• Năm 2026 Spring vẫn dominate nhờ inertia, ecosystem rộng, và Boot 3.2+ đã bắt kịp về startup/native với competitor.

11. Tự kiểm tra

error: package javax.servlet does not exist
import javax.servlet.http.HttpServletRequest;
                  ^

Bài tiếp theo: IoC và DI — bóc tách 2 thuật ngữ bị lạm dụng nhất