Tổng quan về cơ chế Auto-Assembly

Trong hệ sinh thái Spring truyền thống, việc cấu hình các Bean phụ thuộc thường đòi hỏi lượng lớn mã XML hoặc Java Config. Các nhà phát triển phải định nghĩa rõ ràng từng DataSource, EntityManagerFactory hay các Template client. Spring Boot giải quyết vấn đề này thông qua cơ chế Auto-Assembly (tự động装配), cho phép ứng dụng tự động cấu hình các Bean dựa trên các thư viện có trên classpath, giảm thiểu tối thiểu các cấu hình thủ công.

Điểm mấu chốt của cơ chế này nằm ở sự kết hợp giữa Java Config tiêu chuẩn và mô hình SPI (Service Provider Interface) để phát hiện và đăng ký các cấu hình tự động.

Phân tích annotation @SpringBootApplication

Một ứng dụng Spring Boot thường được khởi động bằng class chính được đánh dấu bởi @SpringBootApplication. Annotation này thực chất là một aggregate annotation (gộp 3 annotation khác) đóng vai trò cốt lõi trong quá trình khởi động context.

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
    // ...
}

Trong đó, ba annotation quan trọng nhất bao gồm:

• @SpringBootConfiguration: Đánh dấu class này là một class cấu hình (tương đương với @Configuration), cho phép định nghĩa các Bean thêm bằng phương thức @Bean.
• @ComponentScan: Cho phép Spring quét các thành phần như @Controller, @Service, @Repository nằm trong package hiện tại và các package con.
• @EnableAutoConfiguration: Đây là thành phần quan trọng nhất, kích hoạt cơ chế tự động cấu hình. Nó sử dụng @Import(AutoConfigurationImportSelector.class) để nạp các định nghĩa Bean vào context.

Lõi của Auto-Assembly: AutoConfigurationImportSelector

Lớp AutoConfigurationImportSelector chịu trách nhiệm tìm kiếm và lọc các class cấu hình. Khi phương thức selectImports được gọi, nó thực hiện logic như sau:

1. Tải ứng viên cấu hình: Đọc tất cả các key/value từ file META-INF/spring.factories nằm trong các jar file trên classpath. Nó tìm kiếm key org.springframework.boot.autoconfigure.EnableAutoConfiguration.
2. Lọc bỏ trùng lặp: Loại bỏ các class cấu hình bị trùng tên.
3. Sàng lọc điều kiện: Kiểm tra các điều kiện @Conditional (như @ConditionalOnClass, @ConditionalOnMissingBean) để quyết định xem cấu hình đó có nên được áp dụng hay không.
4. Đăng ký Bean: Nếu thỏa mãn điều kiện, các Bean được định nghĩa trong class cấu hình sẽ được tạo và nạp vào IoC Container.

Vai trò của file spring.factories

File spring.factories đóng vai trò như một manifest chỉ ra các class cấu hình tự động cần được tải. Ví dụ, trong thư viện spring-boot-autoconfigure, file này sẽ liệt kê hàng trăm class cấu hình cho Redis, MongoDB, DataSource, v.v.

# Ví dụ nội dung spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.redis.RedisAutoConfiguration,\
com.example.autoconfigure.database.DataSourceAutoConfiguration,\
com.example.autoconfigure.security.SecurityAutoConfiguration

Cơ chế Conditional Assembly (Cấu hình có điều kiện)

Để tránh nạp các Bean không cần thiết hoặc xung đột với cấu hình của người dùng, Spring Boot sử dụng rộng rãi các annotation điều kiện (Conditional Annotations). Các annotation này kiểm tra trạng thái của môi trường trước khi cho phép đăng ký Bean.

Annotation	Mô tả chức năng
@ConditionalOnClass	Chỉ kích hoạt khi một class cụ thể tồn tại trên classpath (ví dụ: RedisTemplate).
@ConditionalOnMissingClass	Chỉ kích hoạt khi một class cụ thể không tồn tại.
@ConditionalOnBean	Chỉ kích hoạt khi một Bean cụ thể đã có trong Container.
@ConditionalOnMissingBean	Chỉ kích hoạt khi chưa có Bean nào được đăng ký (cho phép người dùng ghi đè).
@ConditionalOnProperty	Kích hoạt dựa trên giá trị của thuộc tính trong file cấu hình (application.properties/yml).

Ví dụ thực tế:

@Configuration
@ConditionalOnClass(name = "io.lettuce.core.RedisClient")
public class LettuceConnectionConfiguration {

    @Bean
    @ConditionalOnMissingBean(RedisConnectionFactory.class)
    public RedisConnectionFactory redisConnectionFactory(ObjectProvider<RedisStandaloneConfiguration> configuration) {
        // Logic tạo kết nối Redis
        return new LettuceConnectionFactory(configuration.getIfUnique());
    }
}

Hướng dẫn xây dựng một Custom Starter

Để đóng gói một thư viện thành Starter riêng, tuân theo quy tắc "convention over configuration", ta cần thực hiện các bước sau. Giả sử ta muốn xây dựng một notification-spring-boot-starter hỗ trợ gửi thông báo qua Email hoặc SMS.

Bước 1: Cấu trúc dự án

Tạo một Maven project với các module cơ bản:

notification-starter
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── techlib
    │   │           └── notification
    │   │               ├── NotificationAutoConfig.java
    │   │               ├── NotificationProperties.java
    │   │               ├── NotificationService.java
    │   │               └── impl
    │   │                   ├── EmailNotifier.java
    │   │                   └── SmsNotifier.java
    │   └── resources
    │       └── META-INF
    │           └── spring.factories

Bước 2: Định nghĩa thuộc tính cấu hình

Tạo class để ánh xạ các giá trị từ file cấu hình application.yml vào object Java.

package com.techlib.notification;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "app.notification")
public class NotificationProperties {

    private ProviderType provider = ProviderType.EMAIL;
    private String apiKey;
    private String senderId;

    public enum ProviderType {
        EMAIL, SMS
    }

    // Getters và Setters
    public ProviderType getProvider() { return provider; }
    public void setProvider(ProviderType provider) { this.provider = provider; }
    public String getApiKey() { return apiKey; }
    public void setApiKey(String apiKey) { this.apiKey = apiKey; }
    public String getSenderId() { return senderId; }
    public void setSenderId(String senderId) { this.senderId = senderId; }
}

Bước 3: Triển khai logic nghiệp vụ

Định nghĩa interface và các implementation cụ thể.

public interface NotificationService {
    void send(String recipient, String message);
}

public class EmailNotifier implements NotificationService {
    private final NotificationProperties props;
    public EmailNotifier(NotificationProperties props) {
        this.props = props;
    }
    @Override
    public void send(String recipient, String message) {
        System.out.println("Sending Email to " + recipient + " via API Key: " + props.getApiKey());
    }
}

public class SmsNotifier implements NotificationService {
    private final NotificationProperties props;
    public SmsNotifier(NotificationProperties props) {
        this.props = props;
    }
    @Override
    public void send(String recipient, String message) {
        System.out.println("Sending SMS to " + recipient + " from Sender: " + props.getSenderId());
    }
}

Bước 4: Cấu hình tự động (Auto Configuration)

Đây là nơi kết nối tất cả lại với nhau. Chúng ta sẽ đăng ký Bean dựa trên cấu hình người dùng.

package com.techlib.notification;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(NotificationProperties.class)
public class NotificationAutoConfig {

    @Bean
    @ConditionalOnMissingBean(NotificationService.class)
    @ConditionalOnProperty(name = "app.notification.provider", havingValue = "EMAIL", matchIfMissing = true)
    public NotificationService emailService(NotificationProperties props) {
        return new EmailNotifier(props);
    }

    @Bean
    @ConditionalOnMissingBean(NotificationService.class)
    @ConditionalOnProperty(name = "app.notification.provider", havingValue = "SMS")
    public NotificationService smsService(NotificationProperties props) {
        return new SmsNotifier(props);
    }
}

Bước 5: Đăng ký với spring.factories

Tạo file src/main/resources/META-INF/spring.factories để Spring Boot phát hiện class cấu hình trên.

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.techlib.notification.NotificationAutoConfig

Bước 6: Sử dụng Starter trong ứng dụng Client

Thêm dependency vào pom.xml của dự án chính:

<dependency>
    <groupId>com.techlib</groupId>
    <artifactId>notification-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>

Cấu hình trong application.yml:

app:
  notification:
    provider: SMS
    api-key: "test-key-123"
    sender-id: "TechLibSystem"

Inject và sử dụng:

@Service
public class OrderService {

    @Autowired
    private NotificationService notifier;

    public void placeOrder(Order order) {
        // Xử lý logic đặt hàng...
        notifier.send(order.getUserPhone(), "Đơn hàng của bạn đã đặt thành công.");
    }
}

Quy trình xử lý tổng thể

Khi ứng dụng Spring Boot khởi động, quy trình xử lý auto-assembly diễn ra theo trình tự sau:

1. Khởi động SpringApplication: Gọi run() và chuẩn bị ApplicationContext.
2. Component Scan: Quét các Bean nội bộ trong ứng dụng.
3. Trigger Auto-Configuration: EnableAutoConfiguration kích hoạt AutoConfigurationImportSelector.
4. Load Spring Factories: Đọc các file META-INF/spring.factories từ tất cả các jar (bao gồm starter mới tạo).
5. Processing Configuration Classes: Với mỗi class cấu hình tìm thấy, Spring kiểm tra các điều kiện @Conditional.
   • Nếu thỏa mãn: Bean được đăng ký.
   • Nếu không thỏa mãn: Bỏ qua.
6. Context Refreshed: IoC Container hoàn tất việc nạp Bean, ứng dụng sẵn sàng phục vụ request.

Cơ chế này cho phép các lập trình viên tách biệt rõ ràng giữa thư viện cung cấp chức năng (starter) và cấu hình cụ thể của ứng dụng, đảm bảo tính linh hoạt và giảm thiểu code boiletplate.