spring-: @Configuration-in-depth-javaTutorial-php.cn

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

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.
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 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.
Basic example

@Configuration
@Bean method

Single -example behavior

: Even if

calls

<code class="language-java">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());
    }
}</code>

Copy after login

, due to the agency mechanism,

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

<code class="language-java">@Configuration
public class DataConfig {
    @Bean
    public DataSource dataSource() {
        // 配置并返回数据源
    }
}

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

Copy after login

Do not show all beans, use register ,

and

components. @Value @ConfigurationProperties

4. Use conditions bean

<code class="language-java">@Configuration
public class AppConfig {

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

    @Bean
    public AppService appService() {
        return new AppService(appName);
    }
}</code>

Copy after login

use or annotations such as

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

<code class="language-java">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());
    }
}</code>

Copy after login

5. Organizational application attributes

Use to group the configuration attribute to minimize the decentralized

annotations. @ConfigurationProperties @Value

<code class="language-java">@Configuration
public class DataConfig {
    @Bean
    public DataSource dataSource() {
        // 配置并返回数据源
    }
}

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

Copy after login

The matters that need to be noted

Avoid manual instantiated Bean

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.

<code class="language-java">@Configuration
public class AppConfig {

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

    @Bean
    public AppService appService() {
        return new AppService(appName);
    }
}</code>

Copy after login

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.

Agent restrictions The agency mechanism of @Bean is not effective when the class is not final. Avoid marking the configuration class to final.
Use @Component carefully Avoid mixing and @Configuration in the same class. This may lead to unexpected behaviors, because the
processing method is different.
Using advanced examples of injects @Component @Configuration @Configuration
Relying in

can be reused by bean

:

and

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

Copy after login

Bean can be reused among multiple services.

Summary
Purpose : Allows to define Bean in a concentrated and type security method. DataSource JdbcTemplate Best practice

and

The trap that needs to be avoided

methods, and use final. @Configuration
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!