Différence entre @ComponentScan et @EnableAutoConfiguration dans Spring Boot

1. Introduction

Dans ce tutoriel rapide, nous allons découvrir les différences entre les annotations @ComponentScan et @EnableAutoConfiguration dans Spring Framework.

2. Annotations de printemps

Les annotations facilitent la configuration de l'injection de dépendances dans Spring. Au lieu d'utiliser des fichiers de configuration XML, nous pouvons utiliser des annotations Spring Bean sur des classes et des méthodes pour définir des beans . Après cela, le conteneur Spring IoC configure et gère les beans.

Voici un aperçu des annotations dont nous allons discuter dans cet article:

  • @ComponentScan scanne les composants Spring annotés
  • @EnableAutoConfiguration est utilisé pour activer la configuration automatique

Regardons maintenant la différence entre ces deux annotations.

3. Comment ils diffèrent

La principale différence entre ces annotations est que @ComponentScan recherche les composants Spring tandis que @EnableAutoConfiguration est utilisé pour la configuration automatique des beans présents dans le chemin de classe dans les applications Spring Boot .

Maintenant, passons en revue plus en détail.

3.1. @ComponentScan

Lors du développement d'une application, nous devons dire au framework Spring de rechercher les composants gérés par Spring. @ComponentScan permet à Spring de rechercher des éléments tels que les configurations, les contrôleurs, les services et d'autres composants que nous définissons .

En particulier, le @ComponentScanL'annotation est utilisée avec l' annotation @Configuration pour spécifier le package pour Spring à analyser les composants:

@Configuration @ComponentScan public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(EmployeeApplication.class, args); // ... } }

Alternativement, Spring peut également démarrer l'analyse à partir du package spécifié, que nous pouvons définir à l'aide de basePackageClasses () ou basePackages () . Si aucun package n'est spécifié, il considère le package de la classe déclarant l' annotation @ComponentScan comme package de départ :

package com.baeldung.annotations.componentscanautoconfigure; // ... @Configuration @ComponentScan(basePackages = {"com.baeldung.annotations.componentscanautoconfigure.healthcare", "com.baeldung.annotations.componentscanautoconfigure.employee"}, basePackageClasses = Teacher.class) public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(EmployeeApplication.class, args); // ... } }

Dans l'exemple, Spring analysera les packages des soins de santé et des employés et la classe Enseignant pour les composants.

Spring recherche les packages spécifiés avec tous ses sous-packages pour les classes annotées avec @Configuration . De plus , les classes de configuration peuvent contenir des annotations @Bean , qui enregistrent les méthodes en tant que beans dans le contexte de l'application Spring . Après cela, l' annotation @ ComponentScan peut détecter automatiquement ces beans:

@Configuration public class Hospital { @Bean public Doctor getDoctor() { return new Doctor(); } }

En outre, l' annotation @ ComponentScan peut également analyser, détecter et enregistrer des beans pour les classes annotées avec @Component, @Controller, @Service et @Repository .

Par exemple, nous pouvons créer une classe Employee en tant que composant qui peut être analysé par l' annotation @ ComponentScan :

@Component("employee") public class Employee { // ... }

3.2. @EnableAutoConfiguration

L' annotation @EnableAutoConfiguration permet à Spring Boot de configurer automatiquement le contexte de l'application . Par conséquent, il crée et enregistre automatiquement des beans basés à la fois sur les fichiers jar inclus dans le chemin de classe et sur les beans définis par nous.

Par exemple, lorsque nous définissons la dépendance spring-boot-starter-web dans notre chemin de classe, Spring boot configure automatiquement Tomcat et Spring MVC. Cependant, cette auto-configuration a moins de priorité au cas où nous définirions nos propres configurations.

Le package de la classe déclarant l' annotation @EnableAutoConfiguration est considéré comme la valeur par défaut . Par conséquent, nous devons toujours appliquer l' annotation @EnableAutoConfiguration dans le package racine afin que chaque sous-package et classe puisse être examiné:

@Configuration @EnableAutoConfiguration public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(EmployeeApplication.class, args); // ... } }

De plus, l' annotation @EnableAutoConfiguration fournit deux paramètres pour exclure manuellement tout paramètre:

Nous pouvons utiliser exclude pour désactiver une liste de classes que nous ne voulons pas être configurées automatiquement:

@Configuration @EnableAutoConfiguration(exclude={JdbcTemplateAutoConfiguration.class}) public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(EmployeeApplication.class, args); // ... } }

Nous pouvons utiliser excludeName pour définir une liste complète de noms de classes que nous voulons exclure de la configuration automatique:

@Configuration @EnableAutoConfiguration(excludeName = {"org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration"}) public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(EmployeeApplication.class, args); // ... } }

Depuis Spring Boot 1.2.0, nous pouvons utiliser l' annotation @SpringBootApplication , qui est une combinaison des trois annotations @Configuration, @EnableAutoConfiguration et @ComponentScan avec leurs attributs par défaut :

@SpringBootApplication public class EmployeeApplication { public static void main(String[] args) { ApplicationContext context = SpringApplication.run(EmployeeApplication.class, args); // ... } }

4. Conclusion

Dans cet article, nous avons découvert les différences entre @ComponentScan et @EnableAutoConfiguration dans Spring Boot.

Comme toujours, le code de ces exemples est disponible à l'adresse over sur GitHub.