Spring中Bean注册的两种方式对比及适用场景咨询

Hey there! Great question—this is such a common point of confusion when you’re getting your feet wet with Spring, so let’s break down the two approaches clearly, including when to use each.

1. @Component, @Service, @Repository, @Controller (Stereotype Annotations) #

These are part of Spring’s component scanning mechanism. Here’s how they work:

• You add these annotations directly to your custom classes (like your Foo class, if you owned it). Spring automatically scans for classes with these annotations (assuming you’ve enabled @ComponentScan, which Spring Boot does by default) and creates a singleton instance of each, registering them in the application context.
• Best for: Your own application classes (business services, data access objects, controllers) where the initialization logic is straightforward—think simple constructor calls with no extra setup.
• Pros: Super clean, minimal code. You don’t need to write extra configuration; just slap the right annotation on your class and Spring does the rest.

Example:

@Service
public class UserService {
    // Simple initialization, no fancy setup needed
    private final UserRepository userRepo;

    public UserService(UserRepository userRepo) {
        this.userRepo = userRepo;
    }
}

2. @Bean in @Configuration Classes #

This is an explicit way to register beans. You define a method in a @Configuration class, mark it with @Bean, and write the code to create and configure the instance yourself. Spring takes whatever the method returns and registers it as a bean.

• Best for:
  • Third-party library classes: You can’t add @Component to classes you don’t own (like RestTemplate, DataSource, or a class from a utility library). This is the only way to register them as Spring beans.
  • Complex initialization: When creating the instance requires more than just a constructor call—like setting properties, adding interceptors, or conditional logic (e.g., different instances for dev vs. prod environments).
  • Multiple instances of the same class: If you need two different configurations of the same type (e.g., a read-only DataSource and a write-only DataSource), you can define separate @Bean methods and name them with the @Bean("beanName") attribute.
• Pros: Full control over how the bean is created and configured. You can add any custom logic inside the method.

Examples:

Third-party class with custom setup: #

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate customRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        // Add custom interceptors, set timeouts, etc.
        restTemplate.getInterceptors().add(new LoggingInterceptor());
        restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory());
        return restTemplate;
    }
}

Multiple instances of the same class: #

@Configuration
public class DataSourceConfig {
    @Bean("readDataSource")
    public DataSource readDataSource() {
        return DataSourceBuilder.create()
                .url("jdbc:mysql://localhost:3306/read_db")
                .username("app_user")
                .password("secure_pass")
                .build();
    }

    @Bean("writeDataSource")
    public DataSource writeDataSource() {
        return DataSourceBuilder.create()
                .url("jdbc:mysql://localhost:3306/write_db")
                .username("app_user")
                .password("secure_pass")
                .build();
    }
}

Key Differences at a Glance #

Quick Rule of Thumb #

• Use stereotype annotations for your own simple classes—keep code clean and let Spring handle registration.
• Use @Bean when you need control over bean creation, or when dealing with classes you can’t annotate directly.

Hope that clears things up! 😊

内容的提问来源于stack exchange，提问作者Denis Stephanov