Annotazioni Spring Bean

Questo articolo fa parte di una serie: • Annotazioni Spring Core

• Annotazioni Web primaverili

• Annotazioni Spring Boot

• Annotazioni di pianificazione della primavera

• Annotazioni sui dati primaverili

• Annotazioni Spring Bean (articolo attuale)

1. Panoramica

In questo articolo, discuteremo le annotazioni dei bean Spring più comuni utilizzate per definire diversi tipi di bean.

Esistono diversi modi per configurare i bean in un contenitore Spring. Possiamo dichiararli utilizzando la configurazione XML. Possiamo dichiarare i bean utilizzando l' annotazione @Bean in una classe di configurazione.

Oppure possiamo contrassegnare la classe con una delle annotazioni dal pacchetto org.springframework.stereotype e lasciare il resto alla scansione dei componenti.

2. Scansione dei componenti

Spring può scansionare automaticamente un pacchetto per i bean se la scansione dei componenti è abilitata.

@ComponentScan configura i pacchetti da scansionare per le classi con la configurazione delle annotazioni . Possiamo specificare i nomi dei pacchetti di base direttamente con uno degli argomenti basePackages o value ( value è un alias per basePackages ):

@Configuration @ComponentScan(basePackages = "com.baeldung.annotations") class VehicleFactoryConfig {}

Inoltre, possiamo puntare alle classi nei pacchetti di base con l' argomento basePackageClasses :

@Configuration @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {}

Entrambi gli argomenti sono array in modo da poter fornire più pacchetti per ciascuno.

Se non viene specificato alcun argomento, la scansione viene eseguita dallo stesso pacchetto in cui è presente la classe annotata @ComponentScan .

@ComponentScan sfrutta la funzionalità di annotazioni ripetute di Java 8, il che significa che possiamo contrassegnare una classe con essa più volte:

@Configuration @ComponentScan(basePackages = "com.baeldung.annotations") @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {}

In alternativa, possiamo usare @ComponentScans per specificare più configurazioni @ComponentScan :

@Configuration @ComponentScans({ @ComponentScan(basePackages = "com.baeldung.annotations"), @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) }) class VehicleFactoryConfig {}

Quando si utilizza la configurazione XML , la scansione del componente di configurazione è altrettanto semplice:

3. @Component

@Component è un'annotazione a livello di classe. Durante la scansione dei componenti, Spring Framework rileva automaticamente le classi annotate con @Component .

Per esempio:

@Component class CarUtility { // ... }

Per impostazione predefinita, le istanze del bean di questa classe hanno lo stesso nome del nome della classe con un'iniziale minuscola. Inoltre, possiamo specificare un nome diverso utilizzando l' argomento valore opzionale di questa annotazione.

Poiché @Repository , @Service , @Configuration e @Controller sono tutte meta-annotazioni di @Component , condividono lo stesso comportamento di denominazione dei bean. Inoltre, Spring li raccoglie automaticamente durante il processo di scansione dei componenti.

4. @Repository

Le classi DAO o Repository di solito rappresentano il livello di accesso al database in un'applicazione e dovrebbero essere annotate con @Repository:

@Repository class VehicleRepository { // ... }

Un vantaggio dell'utilizzo di questa annotazione è che ha la traduzione automatica delle eccezioni di persistenza abilitata . Quando si utilizza un framework di persistenza come Hibernate, le eccezioni native generate all'interno di classi annotate con @Repository verranno automaticamente tradotte in sottoclassi di DataAccessExeption di Spring .

Per abilitare la traduzione delle eccezioni , dobbiamo dichiarare il nostro bean PersistenceExceptionTranslationPostProcessor :

@Bean public PersistenceExceptionTranslationPostProcessor exceptionTranslation() { return new PersistenceExceptionTranslationPostProcessor(); }

Nota che nella maggior parte dei casi Spring esegue automaticamente il passaggio precedente.

Oppure, tramite configurazione XML:

5. @Service

The business logic of an application usually resides within the service layer – so we'll use the @Service annotation to indicate that a class belongs to that layer:

@Service public class VehicleService { // ... }

6. @Controller

@Controller is a class level annotation which tells the Spring Framework that this class serves as a controller in Spring MVC:

@Controller public class VehicleController { // ... }

7. @Configuration

Configuration classes can contain bean definition methods annotated with @Bean:

@Configuration class VehicleFactoryConfig { @Bean Engine engine() { return new Engine(); } }

8. Stereotype Annotations and AOP

When we use Spring stereotype annotations, it's easy to create a pointcut that targets all classes that have a particular stereotype.

For example, suppose we want to measure the execution time of methods from the DAO layer. We'll create the following aspect (using AspectJ annotations) taking advantage of @Repository stereotype:

@Aspect @Component public class PerformanceAspect { @Pointcut("within(@org.springframework.stereotype.Repository *)") public void repositoryClassMethods() {}; @Around("repositoryClassMethods()") public Object measureMethodExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable { long start = System.nanoTime(); Object returnValue = joinPoint.proceed(); long end = System.nanoTime(); String methodName = joinPoint.getSignature().getName(); System.out.println( "Execution of " + methodName + " took " + TimeUnit.NANOSECONDS.toMillis(end - start) + " ms"); return returnValue; } }

In this example, we created a pointcut that matches all methods in classes annotated with @Repository. We used the @Around advice to then target that pointcut and determine the execution time of the intercepted methods calls.

Using this approach, we may add logging, performance management, audit, or other behaviors to each application layer.

9. Conclusion

In this article, we have examined the Spring stereotype annotations and learned what type of semantics these each represent.

Abbiamo anche imparato come utilizzare la scansione dei componenti per dire al contenitore dove trovare le classi annotate.

Infine, abbiamo visto come queste annotazioni portino a un design pulito e stratificato e alla separazione tra le preoccupazioni di un'applicazione. Riducono anche la configurazione, poiché non è più necessario definire esplicitamente i bean manualmente.

Come al solito, gli esempi sono disponibili su GitHub.

« Precedenti annotazioni sui dati di primavera