• Anotaciones web de Spring
• Anotaciones de Spring Boot
• Anotaciones de programación de primavera
• Anotaciones de datos de primavera
• Anotaciones de Spring Bean (artículo actual)
1. Información general
En este artículo, discutiremos las anotaciones de beans de Spring más comunes que se utilizan para definir diferentes tipos de beans.
Hay varias formas de configurar beans en un contenedor Spring. Podemos declararlos usando la configuración XML. Podemos declarar beans usando la anotación @Bean en una clase de configuración.
O podemos marcar la clase con una de las anotaciones del paquete org.springframework.stereotype y dejar el resto para el escaneo de componentes.
2. Escaneo de componentes
Spring puede escanear automáticamente un paquete en busca de beans si el escaneo de componentes está habilitado.
@ComponentScan configura qué paquetes escanear en busca de clases con configuración de anotaciones . Podemos especificar los nombres de los paquetes base directamente con uno de los basePackages o valor argumentos ( el valor es un alias para basePackages ):
@Configuration @ComponentScan(basePackages = "com.baeldung.annotations") class VehicleFactoryConfig {}Además, podemos apuntar a clases en los paquetes base con el argumento basePackageClasses :
@Configuration @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {}Ambos argumentos son matrices para que podamos proporcionar varios paquetes para cada uno.
Si no se especifica ningún argumento, el escaneo ocurre desde el mismo paquete donde está presente la clase anotada @ComponentScan .
@ComponentScan aprovecha la función de anotaciones repetidas de Java 8, lo que significa que podemos marcar una clase con ella varias veces:
@Configuration @ComponentScan(basePackages = "com.baeldung.annotations") @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) class VehicleFactoryConfig {}Alternativamente, podemos usar @ComponentScans para especificar múltiples configuraciones de @ComponentScan :
@Configuration @ComponentScans({ @ComponentScan(basePackages = "com.baeldung.annotations"), @ComponentScan(basePackageClasses = VehicleFactoryConfig.class) }) class VehicleFactoryConfig {}Cuando se utiliza la configuración XML , la configuración del escaneo de componentes es igual de fácil:
3. @Componente
@Component es una anotación de nivel de clase. Durante el escaneo de componentes, Spring Framework detecta automáticamente las clases anotadas con @Component .
Por ejemplo:
@Component class CarUtility { // ... }De forma predeterminada, las instancias de bean de esta clase tienen el mismo nombre que el nombre de la clase con una inicial en minúscula. Además de eso, podemos especificar un nombre diferente usando el argumento de valor opcional de esta anotación.
Dado que @Repository , @Service , @Configuration y @Controller son todas meta-anotaciones de @Component , comparten el mismo comportamiento de denominación de beans . Además, Spring los detecta automáticamente durante el proceso de escaneo de componentes.
4. @Repositorio
Las clases DAO o Repository generalmente representan la capa de acceso a la base de datos en una aplicación y deben anotarse con @Repository:
@Repository class VehicleRepository { // ... }Una ventaja de usar esta anotación es que tiene habilitada la traducción automática de excepciones de persistencia . Cuando se usa un marco de persistencia como Hibernate, las excepciones nativas lanzadas dentro de las clases anotadas con @Repository se traducirán automáticamente en subclases de DataAccessExeption de Spring .
Para habilitar la traducción de excepciones , necesitamos declarar nuestro propio bean PersistenceExceptionTranslationPostProcessor :
@Bean public PersistenceExceptionTranslationPostProcessor exceptionTranslation() { return new PersistenceExceptionTranslationPostProcessor(); }Tenga en cuenta que, en la mayoría de los casos, Spring realiza el paso anterior automáticamente.
O, a través de la configuración XML:
5. @Servicio
La lógica empresarial de una aplicación generalmente reside dentro de la capa de servicio, por lo que usaremos la anotación @Service para indicar que una clase pertenece a esa capa:
@Service public class VehicleService { // ... }6. @Controller
@Controller es una anotación de nivel de clase que le dice a Spring Framework que esta clase sirve como controlador en Spring MVC :
@Controller public class VehicleController { // ... }7. @Configuración
Las clases de configuración pueden contener métodos de definición de beans anotados con @Bean :
@Configuration class VehicleFactoryConfig { @Bean Engine engine() { return new Engine(); } }8. Anotaciones de estereotipos y AOP
Cuando usamos las anotaciones de estereotipo de Spring, es fácil crear un punto de corte que se dirija a todas las clases que tienen un estereotipo particular.
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.
También aprendimos cómo utilizar el escaneo de componentes para indicarle al contenedor dónde encontrar clases anotadas.
Finalmente, vimos cómo estas anotaciones conducen a un diseño limpio y en capas y a una separación entre las preocupaciones de una aplicación. También reducen la configuración, ya que ya no necesitamos definir los beans de forma explícita de forma manual.
Como de costumbre, los ejemplos están disponibles en GitHub.
« Anotaciones de datos de Spring anteriores