Cách Spring Hoạt Động: Khám Phá Kiến Trúc Cốt Lõi Cho Người Mới Bắt Đầu

Ba chữ IoC, DI, AOP không giải thích được lỗi bạn gặp lúc hai giờ sáng. Ứng dụng chết khi khởi động với BeanCreationException, @Transactional không rollback dù đã đánh dấu, endpoint trả 404 dù class có @RestController — cả ba đều là câu hỏi về thứ tự các chặng, không phải về khái niệm. Cách Spring hoạt động thực sự nằm ở hai đường ống: một đường chạy lúc khởi động để dựng object graph, một đường chạy mỗi request để đi qua graph đó.

Cập nhật 2026

  • Spring Boot 4.1.2 trên Spring Framework 7.0.10, nền tảng Java 25 LTS (Boot 4.1 chạy từ Java 17 tới Java 27).
  • Container mặc định là Tomcat 11.0.x với Servlet 6.1, baseline Jakarta EE 11 (jakarta.*).
  • Framework 7 đánh dấu RestTemplate là deprecated; MVC có API versioning; JSpecify thay JSR-305 cho nullness.
  • Boot 4.2.0-RC2 mới là bản preview — phần còn lại của bài nói về dòng 4.1 ổn định.

Cách Spring hoạt động: hai đường ống, một container

Đường khởi động chạy đúng một lần và tạo ra toàn bộ object. Đường request chạy hàng nghìn lần và chỉ đọc những object đã có. Cả hai dùng chung một ApplicationContext, nhưng hiểu sai đường nào cũng khiến bạn sửa lỗi ở sai chỗ.

STARTUP (once)
SpringApplication.run
  +- Environment           application.yml, profile, env vars, CLI args
  +- BeanFactory           ApplicationContext, empty
  +- BeanDefinition        @Component, @Bean, @Import, auto-config
  +- BeanFactoryPostProc   parse config, pick auto-config, resolve ${...}
  +- Bean + BeanPostProc   constructor, @PostConstruct, AOP proxy
  +- refreshContext        start Tomcat, publish events
  +- ApplicationReadyEvent ready

REQUEST (each call)
socket -> Tomcat -> Filter chain -> DispatcherServlet
  -> HandlerMapping -> HandlerAdapter -> argument resolvers
  -> controller (through proxy) -> return value handler
  -> HttpMessageConverter / ViewResolver -> response

Điểm cần nhớ: mọi bean bạn inject đã tồn tại trước request đầu tiên, trừ bean @Lazy và prototype. Nếu một thứ không có trong graph sau refreshContext, nó sẽ không tự xuất hiện khi có traffic.

Đường ống khởi động: SpringApplication.run làm gì

SpringApplication.run không mở cổng trước rồi mới tìm bean. Nó chạy ba pha: chuẩn bị Environment, tạo context và đăng ký bean definition, rồi refresh context. Sai sót ở pha nào cũng biểu hiện ở pha sau, nên đọc stack trace cần biết mình đang ở đâu.

Pha 1: Environment và loại ứng dụng

Trước khi có bean nào, Spring phải biết cấu hình đến từ đâu. Nó xác định loại ứng dụng — Servlet, reactive hay không web — dựa trên classpath. Quyết định này giải thích vì sao thêm spring-boot-starter-web thì Tomcat xuất hiện, còn không thêm thì không.

Sau đó nó gom property thành một Environment: tham số dòng lệnh, SPRING_APPLICATION_JSON, system properties, biến môi trường, application-{profile}.yml, application.yml, rồi @PropertySource. Thứ tự này rút gọn, nhưng quy tắc thực dụng là: nguồn động (CLI, biến môi trường) thắng file, và file theo profile thắng file mặc định. EnvironmentPostProcessor là hook chèn thêm property source trước khi context tồn tại — cơ chế đứng sau spring.config.import và các thư viện cấu hình từ xa.

Pha 2: bean definition, chưa phải bean

Context được tạo rỗng (ServletWebServerApplicationContext với ứng dụng web). @SpringBootApplication là tổ hợp của @SpringBootConfiguration, @EnableAutoConfiguration và @ComponentScan; scan bắt đầu từ package của class main và đi xuống. Mỗi class khớp (@Component, @Service, @Repository, @Controller, @Configuration) và mỗi method @Bean sinh ra một BeanDefinition: metadata về class, scope, tham số, chứ chưa phải object.

Toàn bộ definition được đăng ký trước khi bất kỳ bean thường nào được tạo. Đây là lý do @ConditionalOnMissingBean hoạt động được: nó nhìn thấy definition đã xử lý, không cần bean đã tồn tại. Cũng vì vậy, thứ tự giữa các auto-configuration phải khai báo bằng @AutoConfiguration(after = ...), không thể dựa vào thứ tự file trên classpath.

Pha 3: BeanFactoryPostProcessor và auto-configuration

Đây là chặng bị bỏ qua nhiều nhất. ConfigurationClassPostProcessor đọc @Configuration, @Import, @Bean, @ComponentScan; AutoConfigurationImportSelector đọc danh sách auto-config từ META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports trên classpath rồi lọc bằng condition: @ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty, @ConditionalOnWebApplication.

Đó là toàn bộ “phép thuật” của Boot. Không có code ẩn nào biết bạn muốn làm web: có DispatcherServlet trên classpath thì điều kiện đúng và definition được thêm; bạn đã khai báo DataSource của mình thì @ConditionalOnMissingBean tắt bản mặc định. Ở cùng chặng này, PropertySourcesPlaceholderConfigurer resolve ${...} bên trong definition.

// File: src/main/java/shop/audit/AuditAutoConfiguration.java
// ví dụ auto-config của chính bạn, không phải của Boot
@AutoConfiguration(after = DataSourceAutoConfiguration.class)
@ConditionalOnProperty(name = "shop.audit.enabled", havingValue = "true", matchIfMissing = true)
public class AuditAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    AuditLog auditLog(DataSource dataSource) {
        return new JdbcAuditLog(dataSource);
    }
}

Nếu đóng gói auto-config trong thư viện riêng, bạn phải liệt kê class đó trong file AutoConfiguration.imports; thiếu một dòng là toàn bộ class không được nhìn thấy, dù annotation đúng.

Pha 4: khởi tạo bean và BeanPostProcessor

refreshContext gọi finishBeanFactoryInitialization, và đây mới là lúc phần lớn singleton thật sự được tạo. Với mỗi bean, thứ tự là: constructor (inject dependency) → aware callback → BeanPostProcessor.postProcessBeforeInitialization → InitializingBean.afterPropertiesSet hoặc init method → postProcessAfterInitialization.

@PostConstruct chạy trong bước before, qua CommonAnnotationBeanPostProcessor. Proxy AOP sinh ra ở bước after, không phải ở constructor. AnnotationAwareAspectJAutoProxyCreator — hoặc InfrastructureAdvisorAutoProxyCreator khi chỉ có @Transactional — bọc bean tại đây. Từ lúc đó, bản được cache trong factory là proxy, nên bean khác inject vào nhận proxy; nhưng bên trong quá trình init, object vẫn là chính nó.

Pha 5: Tomcat và ApplicationReadyEvent

onRefresh của ServletWebServerApplicationContext mới tạo và start Tomcat. Server không tồn tại trong lúc bean được tạo, nên lỗi bind port xảy ra muộn hơn lỗi wiring. Sau khi server lên, ApplicationRunner và CommandLineRunner chạy, rồi ApplicationReadyEvent được publish.

Nếu cần làm việc một lần lúc khởi động mà phải có transaction hoặc proxy, đây là chỗ đúng — không phải @PostConstruct.

Đường ống request: từ socket đến body

Request đi qua nhiều tầng hơn người mới thường nghĩ. Biết tầng nào chịu trách nhiệm gì quyết định việc bạn đặt logic ở filter, interceptor hay @ControllerAdvice.

Filter chain và DispatcherServlet

Tomcat nhận socket và giao cho servlet. Trước servlet là filter chain: encoding, tracing, và springSecurityFilterChain do Spring Security đăng ký qua DelegatingFilterProxy. Filter bọc ngoài servlet nên chạy cho mọi request vào servlet đó, kể cả request không khớp handler nào.

DispatcherServlet được đăng ký ở / và gọi doDispatch. Ba thành phần ở đây: HandlerMapping tìm handler, HandlerExecutionChain gắn interceptor, HandlerAdapter gọi handler. RequestMappingHandlerMapping được xây lúc khởi động từ các @RequestMapping/@GetMapping, nên route không được tính lại mỗi request; thêm route lúc runtime phải đăng ký mapping mới.

Argument resolver, handler, return value

RequestMappingHandlerAdapter bọc handler thành ServletInvocableHandlerMethod. Trước khi method chạy, một loạt HandlerMethodArgumentResolver làm việc: @PathVariable, @RequestParam, @RequestBody (đọc body qua HttpMessageConverter), @AuthenticationPrincipal lấy từ Security context. Interceptor chạy quanh lời gọi: preHandle → handler → postHandle → afterCompletion.

Sau khi handler trả về, HandlerMethodReturnValueHandler quyết định cách ghi response. @ResponseBody hoặc @RestController đi qua RequestResponseBodyMethodProcessor và HttpMessageConverter, chọn converter theo Accept. Trả về tên view thì ViewResolver ánh xạ sang JSP hoặc template rồi View.render.

Exception đi qua HandlerExceptionResolver: ExceptionHandlerExceptionResolver xử lý các method trong @ControllerAdvice trước, phần không khớp được dispatch sang /error và BasicErrorController.

Một chi tiết dễ bỏ qua: controller gọi service qua proxy, nên @Transactional trên service có hiệu lực. Gọi thẳng repository hoặc gọi method nội bộ của service thì proxy bị bỏ qua — phần dưới giải thích vì sao.

Boot khác Spring thuần ở đâu

Không có kiến trúc riêng. Boot là lớp ra quyết định thay bạn dựa trên classpath và condition, còn container, proxy và DispatcherServlet vẫn là của Framework.

Khả năng Spring Framework thuần Boot 4.1
Khởi động Tự tạo context, đăng ký servlet qua web.xml hoặc ServletContainerInitializer SpringApplication.run, tự chọn loại ứng dụng
Web server WAR, deploy lên Tomcat ngoài Tomcat 11 nhúng, jar chạy trực tiếp
Cấu hình XML hoặc Java config viết tay Environment, application.yml, profile, @ConfigurationProperties
Bean hạ tầng Tự khai báo DispatcherServlet, resolver, converter Auto-config có điều kiện
Vận hành Không có sẵn Actuator

Starter là dependency đã tuyển chọn, không phải code. spring-boot-starter-web kéo MVC, Jackson, validation và Tomcat; chính việc Tomcat có trên classpath là điều kiện để auto-config web bật. Boot 4 chia module nhỏ hơn nhưng spring-boot-starter-web vẫn là entry point cho ứng dụng web thông thường.

Actuator là phần dễ bỏ sót khi debug: /actuator/conditions cho biết condition nào pass, /actuator/beans cho biết bean nào tồn tại và dependency của nó, /actuator/mappings cho biết route nào được map. Ba endpoint này tương ứng đúng ba chặng ở trên.

Proxy: nơi AOP chạm vào code của bạn

@Transactional, @Async, @Cacheable chỉ là metadata trên method; metadata không tự làm gì. Hiệu lực đến từ proxy được tạo ở postProcessAfterInitialization, và mọi lời gọi phải đi qua proxy đó.

JDK proxy và CGLIB

Nếu target implement interface và proxyTargetClass=false, Spring dùng JDK dynamic proxy — chỉ method khai báo trong interface bị chặn. Boot đặt spring.aop.proxy-target-class=true mặc định nên phần lớn trường hợp dùng CGLIB (đã được repackage trong spring-core), tạo subclass của class thật. Hệ quả: class final, method final hoặc private không proxy được, và @Transactional trên đó không tạo transaction, không có cảnh báo.

Self-invocation phá proxy

Lời gọi this.audit(order) không rời khỏi object nên không đi qua proxy. REQUIRES_NEW bị bỏ qua, và rollback của method ngoài nuốt luôn phần việc bên trong.

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

    private final OrderRepository orders;

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

    @Transactional
    public void place(Order order) {
        orders.save(order);
        this.audit(order);   // self-invocation: không qua proxy
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void audit(Order order) {
        // transaction mới không bao giờ được tạo ở đây
    }
}

Ba cách sửa, theo thứ tự nên thử: tách audit sang bean riêng và inject; inject chính proxy của mình bằng ObjectProvider<OrderService>; hoặc AopContext.currentProxy() với exposeProxy=true. Cách đầu thường đúng nhất, vì method cần transaction riêng thường cũng là một đơn vị nghiệp vụ riêng.

@Async dùng cùng cơ chế: gọi nội bộ thì chạy đồng bộ, và nếu return type là void thì không ai thấy lỗi. @Cacheable gọi nội bộ thì cache không được đọc, nhưng method vẫn chạy đúng nên lỗi chỉ lộ ra qua hiệu năng.

Những thay đổi 2026 ảnh hưởng trực tiếp

  • RestTemplate deprecated. Dùng RestClient cho lời gọi đồng bộ, HTTP interface client cho khai báo. Đây là thay đổi ở tầng client, không đổi đường ống khởi động hay request.
  • JSpecify nullness. Tham số constructor là non-null theo hợp đồng; dependency thật sự tùy chọn phải khai báo @Nullable hoặc dùng ObjectProvider. Tooling có thể cảnh báo lúc compile thay vì để NullPointerException lúc chạy.
  • API versioning trong MVC. Việc khớp version nằm ở HandlerMapping, cấu hình dưới spring.mvc.apiversion.*, với các hook ApiVersionResolver, ApiVersionParser, ApiVersionDeprecationHandler. Đây là thay đổi ở đường request, không phải ở container.
  • Virtual threads. spring.threads.virtual.enabled=true khiến Tomcat 11 trên JDK 25 chạy mỗi request trên một virtual thread. Pipeline không đổi, chỉ thread thực thi đổi; ThreadLocal vẫn tách theo request, nhưng giả định về thread pool và bộ nhớ thread-local phải xem lại.

Lỗi thường gặp

Component scan không phủ package

Class main ở com.shop, class ở com.shared thì không được scan, dù có @Service. Sửa bằng @SpringBootApplication(scanBasePackages = "com") hoặc đặt main ở package gốc. Nhớ rằng @EntityScan và @EnableJpaRepositories là scan riêng, không đi theo @ComponentScan.

Cho rằng thứ tự bean là thứ tự khai báo

Không có thứ tự đó. Thứ tự tạo phụ thuộc vào quan hệ dependency và thứ tự đăng ký definition; @Order chỉ ảnh hưởng collection được inject, không tạo thứ tự khởi tạo. Cần thứ tự thật thì dùng @DependsOn, @AutoConfiguration(after = ...), hoặc chuyển sang event và ApplicationRunner.

Chờ proxy trong @PostConstruct

@PostConstruct chạy trên target trước khi proxy tồn tại, nên @Transactional bên trong nó không có hiệu lực. Đừng đặt việc cần transaction ở đây; cũng đừng block lâu, vì context đang trong giai đoạn init.

Debug auto-config bằng cách đọc log

Chạy với --debug hoặc đặt debug=true để in condition evaluation report; class đứng sau là ConditionEvaluationReport. Trên ứng dụng đang chạy, /actuator/conditions cho câu trả lời nhanh hơn, và logging.level.org.springframework.boot.autoconfigure=DEBUG cho log chi tiết.

@Transactional trên method không proxy được

Method private, final, hoặc class final sẽ không có transaction và cũng không có lỗi. Kiểm tra bằng AopUtils.isAopProxy(bean) trong test, hoặc log TransactionSynchronizationManager.isActualTransactionActive() bên trong method.

Checklist trước khi đọc stack trace

  • Xác định lỗi thuộc pha nào: Environment, bean definition, instantiation, hay web server.
  • Kiểm tra class nằm trong phạm vi component scan, và repository/entity có scan riêng hay không.
  • Nếu thiếu transaction hoặc cache: kiểm tra lời gọi có đi qua proxy hay không.
  • Nếu bean mặc định không xuất hiện: xem condition report trước khi thêm @Bean thủ công.
  • Nếu startup chậm: tìm bean bị tạo sớm không cần thiết và @PostConstruct làm việc nặng.

Bài tiếp theo

Bài này là bản đồ; các bài sau đi vào từng chặng. Đọc tiếp Dependency Injection để hiểu cách container lắp ráp tham số constructor, autoconfiguration bên dưới để mổ xẻ pha 3, Tomcat nhúng để hiểu pha 5, và DispatcherServlet để đi hết đường request.