spring-: @Configuration-in-depth

In -depth understanding of the @Configuration annotation in the Spring framework

annotations in the Spring framework are used to mark a class defined by a class. In Spring's Java -based configuration, this annotation is very important. It allows developers to configure the application context without XML. @Configuration

When a class uses

annotations, Spring will treat it as a configuration class and processes it to generate and manage Spring Bean. This type usually contains one or more @Configuration annotations. These methods define the Bean managed by the Spring container. @Bean

---

@Configuration's core concept

1. Mark the class as the configuration class

   This class becomes the source of Bean definition, and Spring will use these definitions to set the application context.

The agency mechanism

2. Spring will generate the CGLIB -based sub -class (proxy) to ensure that the method returns the same single -example instance by default. This behavior is called complete mode

   . If you do not perform an agent, call the

   method multiple times may create multiple instances. @Bean @Bean Integrated with components

When
3. When used with (or in a class with

   annotations), the class of annotations can be explicitly defined by, and Spring is allowed to automatically scan and register other beans.

   @ComponentScan Allow the injecting @SpringBootApplication @Configuration

   Class support the dependency injection based on constructor or field -based to solve the dependency item required to create Bean.

4. Basic example

   @Configuration

   @Bean method
: explicitly define bean.

---

Single -example behavior

: Even if

calls

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    @Bean
    public MyController myController() {
        return new MyController(myService());
    }
}

, due to the agency mechanism,

Bean only created once.
Best Practice
• 1. modular configuration myController() myService() According to functions (such as DataConfig, ServiceConfig, and Webconfig), the configuration is split into multiple classes. This improves readability and maintenance. MyService

2. Avoid hard coding value

---

Use the external configuration source (such as Application.properties or Application.yml) and use

or injection value.

3. Use @componentscan to scan

@Configuration
public class DataConfig {
    @Bean
    public DataSource dataSource() {
        // 配置并返回数据源
    }
}

@Configuration
public class ServiceConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

Do not show all beans, use register ,

and

components. @Value @ConfigurationProperties

4. Use conditions bean

@Configuration
public class AppConfig {

    @Value("${app.name}")
    private String appName;

    @Bean
    public AppService appService() {
        return new AppService(appName);
    }
}

use or annotations such as

to define Bean conditionally, and only loaded bean in a specific environment or configuration.

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }

    @Bean
    public MyController myController() {
        return new MyController(myService());
    }
}

5. Organizational application attributes

Use to group the configuration attribute to minimize the decentralized

annotations. @ConfigurationProperties @Value

@Configuration
public class DataConfig {
    @Bean
    public DataSource dataSource() {
        // 配置并返回数据源
    }
}

@Configuration
public class ServiceConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

The matters that need to be noted

---

Avoid manual instantiated Bean

Do not use
1. to create Bean in the class, because it will bypass Spring's dependency injection and life cycle management. @Configuration new Wrong writing:

Cyclone dependence

Be careful when defining mutually dependent Bean, because it will cause circulation dependence.

@Configuration
public class AppConfig {

    @Value("${app.name}")
    private String appName;

    @Bean
    public AppService appService() {
        return new AppService(appName);
    }
}

2. Solution: Reconstructing the code to inject it to inject or use .

The @Bean method Avoid the @Lazy annotation method of re -loading, because it can cause unexpected results.

3. Agent restrictions The agency mechanism of @Bean is not effective when the class is not final. Avoid marking the configuration class to final.

4. Use @Component carefully Avoid mixing and @Configuration in the same class. This may lead to unexpected behaviors, because the

   processing method is different.

5. Using advanced examples of injects @Component @Configuration @Configuration

   Relying in
: Each bean depends on another bean, Spring will automatically solve the dependency relationship.

---

can be reused by bean

:

and

@Configuration
@ComponentScan(basePackages = "com.example.myapp")
public class AppConfig {
    // 必要时使用显式Bean
}

Bean can be reused among multiple services.

• Summary
• Purpose : Allows to define Bean in a concentrated and type security method. DataSource JdbcTemplate Best practice
: Modularize the configuration, use externalized attributes, and use Spring's annotations (such as

and

---

).

The trap that needs to be avoided

: manually instantiated bean, cycle dependencies, heavy load
• methods, and use final. @Configuration
By following these practices, you can effectively use
• to build a strong and easy -to -maintain Spring application.

The above is the detailed content of spring-: @Configuration-in-depth. For more information, please follow other related articles on the PHP Chinese website!