printemps-: @ configuration en profondeur

In-Depth Compréhension de l'annotation @configuration dans le cadre de printemps

Les annotations dans le cadre de printemps sont utilisées pour marquer une classe définie par une classe. Dans la configuration basée sur Java de Spring, cette annotation est très importante. @Configuration

Lorsqu'une classe utilise

Annotations, Spring le traitera comme une classe de configuration et le traite pour générer et gérer le bean de printemps. Ce type contient généralement une ou plusieurs annotations @Configuration. @Bean

---

@ Concept de base de la configuration

1. Marquez la classe comme classe de configuration

   Cette classe devient la source de la définition du bean et Spring utilisera ces définitions pour définir le contexte de l'application.

Le mécanisme de l'agence

2. Spring générera la sous-classe basée sur CGLIB (proxy) pour s'assurer que la méthode renvoie la même instance unique d'exemple par défaut. Ce comportement est appelé mode complet

   . Si vous n'effectuez pas d'agent, appelez la méthode

   plusieurs fois peut créer plusieurs instances. @Bean @Bean intégré aux composants

Lorsque
3. lorsqu'il est utilisé avec (ou dans une classe avec

   annotations), la classe des annotations peut être explicitement définie par, et le ressort est autorisé à numériser automatiquement et à enregistrer d'autres grains.

   @ComponentScan Autoriser l'injection @SpringBootApplication @Configuration

   Classe Soutenez l'injection de dépendance en fonction du constructeur ou du champ basé pour résoudre l'élément de dépendance requis pour créer du bean.

4. Exemple de base

   @Configuration

   @Bean Method
: Définissez explicitement le bean.

---

Comportement à un seul exemplaire

: Même si

appelle

<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>

, en raison du mécanisme de l'agence,

bean uniquement créé une seule fois.
Best Practice
• 1. Configuration modulaire myController() myService() Selon les fonctions (telles que DataConfig, ServiceConfig et WebConfig), la configuration est divisée en plusieurs classes. Cela améliore la lisibilité et la maintenance. MyService

2. Évitez la valeur de codage dur

---

Utilisez la source de configuration externe (telle que l'application.properties ou application.yml) et utilisez

ou valeur d'injection.

3. Utilisez @componentscan pour scanner

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

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

N'affichez pas tous les haricots, utilisez enregistrer les composants ,

et

. @Value @ConfigurationProperties

4. Conditions d'utilisation Bean

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

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

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

Utiliser ou Annotations telles que

pour définir le bean conditionnellement, et le haricot chargé uniquement dans un environnement ou une configuration spécifique.

<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>

5. Attributs d'application organisationnels

Utiliser pour regrouper l'attribut de configuration pour minimiser les annotations décentralisées

. @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>

les questions qui doivent être notées

---

Évitez le bean instancié manuel

N'utilisez pas
1. pour créer du bean dans la classe , car il contournera l'injection de dépendance de Spring et la gestion du cycle de vie. @Configuration new Mauvaise écriture:

Dépendance du cyclone

Soyez prudent lors de la définition du haricot mutuellement dépendant, car il entraînera une dépendance de la circulation.

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

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

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

2. Solution: Reconstruire le code pour l'injecter pour injecter ou utiliser .

La méthode @Bean Évitez la méthode d'annotation @Lazy de ré-chargement, car elle peut provoquer des résultats inattendus.

3. Restrictions d'agent Le mécanisme de l'agence de @Bean n'est pas efficace lorsque la classe n'est pas définitive. Évitez de marquer la classe de configuration à finir.

4. Utilisez soigneusement @Component Évitez de mélanger et @Configuration dans la même classe. Cela peut conduire à des comportements inattendus, car la méthode de traitement

   est différente.

5. en utilisant des exemples avancés d'injects @Component @Configuration @Configuration

   Seyant dans
: Chaque haricot dépend d'un autre haricot, le ressort résoudra automatiquement la relation de dépendance.

---

peut être réutilisé par le bean

:

et

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

Le bean peut être réutilisé parmi plusieurs services.

• Résumé
• Objectif : Permet de définir le bean dans une méthode de sécurité concentrée et de type. DataSource JdbcTemplate meilleure pratique
: modulariser la configuration, utiliser des attributs externalisés et utiliser les annotations de Spring (telles que

et

---

).

Le piège qui doit être évité

: Bean instancié manuellement, dépendances du cycle, méthodes de charge lourde
• et Utiliser final. @Configuration
En suivant ces pratiques, vous pouvez utiliser efficacement
• pour construire une application de printemps forte et facile à soutenir.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!