Differenza tra @ComponentScan e @EnableAutoConfiguration in Spring Boot

1. Introduzione

In questo breve tutorial, apprenderemo le differenze tra le annotazioni @ComponentScan e @EnableAutoConfiguration in Spring Framework.

2. Annotazioni di primavera

Le annotazioni semplificano la configurazione dell'inserimento delle dipendenze in Spring. Invece di usare file di configurazione XML, possiamo usare annotazioni Spring Bean su classi e metodi per definire i bean . Successivamente, il contenitore Spring IoC configura e gestisce i bean.

Ecco una panoramica delle annotazioni di cui parleremo in questo articolo:

  • @ComponentScan esegue la scansione dei componenti Spring annotati
  • @EnableAutoConfiguration viene utilizzato per abilitare la configurazione automatica

Esaminiamo ora la differenza tra queste due annotazioni.

3. Come differiscono

La principale differenza tra queste annotazioni è che @ComponentScan esegue la scansione dei componenti Spring mentre @EnableAutoConfiguration viene utilizzato per i bean di configurazione automatica presenti nel percorso di classe nelle applicazioni Spring Boot .

Ora, esaminiamoli in modo più dettagliato.

3.1. @ComponentScan

Durante lo sviluppo di un'applicazione, dobbiamo dire al framework Spring di cercare i componenti gestiti da Spring. @ComponentScan consente a Spring di cercare cose come configurazioni, controller, servizi e altri componenti che definiamo .

In particolare, @ComponentScanl'annotazione viene utilizzata con l' annotazione @Configuration per specificare il pacchetto di Spring per la scansione dei componenti:

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

In alternativa, Spring può anche avviare la scansione dal pacchetto specificato, che possiamo definire utilizzando basePackageClasses () o basePackages () . Se non viene specificato alcun pacchetto, considera il pacchetto della classe che dichiara l' annotazione @ComponentScan come pacchetto iniziale :

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); // ... } }

Nell'esempio, Spring analizzerà i pacchetti sanitari e dei dipendenti e la classe Insegnante per i componenti.

Spring cerca i pacchetti specificati insieme a tutti i suoi sotto-pacchetti per le classi annotate con @Configuration . Inoltre , le classi di configurazione possono contenere annotazioni @Bean , che registrano i metodi come bean nel contesto dell'applicazione Spring . Successivamente, l' annotazione @ ComponentScan può rilevare automaticamente tali bean:

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

Inoltre, l' annotazione @ ComponentScan può anche eseguire la scansione, rilevare e registrare i bean per le classi annotate con @Component, @Controller, @Service e @Repository .

Ad esempio, possiamo creare una classe Employee come componente che può essere scansionato dall'annotazione @ ComponentScan :

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

3.2. @EnableAutoConfiguration

L' annotazione @EnableAutoConfiguration consente a Spring Boot di configurare automaticamente il contesto dell'applicazione . Pertanto, crea e registra automaticamente i bean in base sia ai file jar inclusi nel classpath che ai bean definiti da noi.

Ad esempio, quando definiamo la dipendenza spring-boot-starter-web nel nostro classpath, Spring boot configura automaticamente Tomcat e Spring MVC. Tuttavia, questa configurazione automatica ha meno precedenza nel caso in cui definiamo le nostre configurazioni.

Il pacchetto della classe che dichiara l' annotazione @EnableAutoConfiguration è considerato come predefinito . Pertanto, dovremmo sempre applicare l' annotazione @EnableAutoConfiguration nel pacchetto radice in modo che ogni sotto-pacchetto e classe possa essere esaminato:

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

Inoltre, l' annotazione @EnableAutoConfiguration fornisce due parametri per escludere manualmente qualsiasi parametro:

Possiamo usare exclude per disabilitare un elenco di classi che non vogliamo essere configurate automaticamente:

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

Possiamo usare excludeName per definire un elenco completo di nomi di classi che vogliamo escludere dalla configurazione automatica:

@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); // ... } }

A partire da Spring Boot 1.2.0, possiamo utilizzare l' annotazione @SpringBootApplication , che è una combinazione delle tre annotazioni @Configuration, @EnableAutoConfiguration e @ComponentScan con i loro attributi predefiniti :

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

4. Conclusione

In questo articolo, abbiamo appreso le differenze tra @ComponentScan e @EnableAutoConfiguration in Spring Boot.

Come sempre, il codice per questi esempi è disponibile su GitHub.