Anotaciones de primavera

Spring Annotations nos permite configurar dependencias e implementar la inyección de dependencias a través de programas Java.

Anotaciones de primavera

• El marco Spring implementa y promueve el principio de inversión de control (IOC) o inyección de dependencia (DI) y, de hecho, es un contenedor de IOC.
• Tradicionalmente, Spring permite a un desarrollador administrar las dependencias de los beans mediante el uso de una configuración basada en XML.
• Existe una forma alternativa de definir los beans y sus dependencias. Este método es una configuración basada en Java.
• A diferencia del enfoque XML, la configuración basada en Java permite gestionar los componentes de los beans mediante programación. Por eso se introdujeron las anotaciones de Spring.

En este artículo exploraremos las anotaciones de Spring más utilizadas y también veremos algunos programas de ejemplo.

Lista de anotaciones de primavera

Algunas de las anotaciones del marco principal de Spring son:

1. @Configuration: Se utiliza para indicar que una clase declara uno o más @Beanmétodos. Estas clases son procesadas por el contenedor Spring para generar definiciones de beans y solicitudes de servicio para esos beans en tiempo de ejecución.

2. @Bean: Indica que un método produce un bean que será administrado por el contenedor Spring. Esta es una de las anotaciones de Spring más importantes y utilizadas. La anotación @Bean también se puede utilizar con parámetros como name, initMethod y destroyMethod.

   • nombre – le permite darle un nombre al bean
   • initMethod: le permite elegir el método que se invocará en el registro de contexto
   • destroyMethod: le permite elegir el método que se invocará al apagar el contexto

   Por ejemplo:

   @Configurationpublic class AppConfig {    @Bean(name = "comp", initMethod = "turnOn", destroyMethod = "turnOff")    Computer computer(){        return new Computer();    }}

   public class Computer {    public void turnOn(){        System.out.println("Load operating system");    }    public void turnOff(){        System.out.println("Close all programs");    }}

3. @PreDestroyy @PostConstructson una forma alternativa de utilizar los métodos initMethod y destroyMethod del bean. Se pueden utilizar cuando la clase del bean la definimos nosotros. Por ejemplo:

    public class Computer {    @PostConstruct    public void turnOn(){        System.out.println("Load operating system");    }    @PreDestroy    public void turnOff(){        System.out.println("Close all programs");    }}

4. @ComponentScan: Configura las directivas de escaneo de componentes para usar con las clases @Configuration . Aquí podemos especificar los paquetes base que se escanearán en busca de componentes de Spring.

5. @Component: Indica que una clase anotada es un “componente”. Dichas clases se consideran candidatas para la detección automática cuando se utiliza la configuración basada en anotaciones y el escaneo de rutas de clases.

6. @PropertySource: proporciona un mecanismo declarativo simple para agregar una fuente de propiedad al entorno de Spring. Existe una anotación similar para agregar una matriz de archivos de fuente de propiedad, es decir @PropertySources.

7. @Service: Indica que una clase anotada es un “Servicio”. Esta anotación funciona como una especialización de @Component , lo que permite que las clases de implementación se detecten automáticamente mediante el escaneo de rutas de clases.

8. @Repository: Indica que una clase anotada es un “Repositorio”. Esta anotación sirve como especialización de @Component y se recomienda utilizarla con clases DAO .

9. @Autowired: La anotación Spring @Autowired se utiliza para la inyección automática de beans. La anotación Spring @Qualifier se utiliza junto con Autowired para evitar confusiones cuando tenemos dos o más beans configurados para el mismo tipo.

Anotaciones de Spring MVC

Algunas de las anotaciones importantes de Spring MVC son:

1. @Controlador
2. @RequestMapping
3. @VariableDePath
4. @RequestParam
5. @Atributo de modelo
6. @RequestBody y @ResponseBody
7. @RequestHeader y @ResponseHeader

Puede obtener más información sobre ellos en el Tutorial Spring MVC .

Anotaciones de gestión de transacciones de Spring

@Transactionales la anotación de gestión de transacciones declarativas de primavera, lea más en Spring MVC Hibernate .

Anotaciones de seguridad de primavera

@EnableWebSecurityse utiliza con la clase @Configuration para tener definida la configuración de Spring Security, lea más en Ejemplo de Spring Security .

Anotaciones de arranque de primavera

1. @AplicaciónSpringBoot
2. @Habilitar configuración automática

Lea más en Ejemplo de Spring Boot .

Ejemplo de anotaciones de primavera

Veamos un ejemplo sencillo en el que utilizaremos anotaciones de Spring en nuestra aplicación. La siguiente imagen ilustra mi proyecto de ejemplo de anotaciones de Spring.

Dependencias de Spring Framework

He creado el proyecto maven y he añadido dependencias de Spring Core Framework.

project  xmlns_xsi="https://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"modelVersion4.0.0/modelVersiongroupIdcom.journaldev.spring/groupIdartifactIdspring-annotations/artifactIdversion0.0.1-SNAPSHOT/versionnameSpring Annotations/namepropertiesspring.framework4.3.0.RELEASE/spring.framework/propertiesdependenciesdependencygroupIdorg.springframework/groupIdartifactIdspring-context/artifactIdversion${spring.framework}/version/dependencydependencygroupIdorg.springframework/groupIdartifactIdspring-core/artifactIdversion${spring.framework}/version/dependency/dependencies/project

Esto extraerá todos los frascos con núcleos de resorte para nuestro proyecto.

Clases de componentes

El siguiente paso es crear clases de componentes. Aquí estoy imitando varios componentes de base de datos, uno para MySQL y otro para Oracle.

package com.journaldev.drivers;public interface DataBaseDriver {    public String getInfo();}

DataBaseDriveres la interfaz base que implementaremos.

package com.journaldev.drivers;import org.springframework.beans.factory.annotation.Value;import org.springframework.context.annotation.PropertySource;import org.springframework.stereotype.Component;@Component@PropertySource("classpath:mysqldatabase.properties")public class MySqlDriver implements DataBaseDriver {    @Value("${databaseName}")    private String databaseName;    @Value("${disableStatementPooling}")    private String disableStatementPooling;    public String getInfo() {        return "[ Driver: mySql" +                ", databaseName: " + databaseName +                ", disableStatementPooling: " + disableStatementPooling +                " ]";    }}

Observe el uso de @Componentanotaciones para indicarle a Spring Framework que trate esta clase como un componente. También estamos usando anotaciones @PropertySourcey @ValueSpring las usará en tiempo de ejecución para inyectar y establecer estos valores de variable desde el archivo de propiedades especificado. A continuación se muestran las propiedades declaradas en mysqldatabase.propertiesel archivo.

databaseName=schooldisableStatementPooling=true

package com.journaldev.drivers;public class OracleDriver implements DataBaseDriver {    protected String url;    protected String user;    protected String password;    protected String driver;    protected Integer port;    public String getUrl() {        return url;    }    public String getUser() {        return user;    }    public void setUser(String user) {        this.user = user;    }    public String getPassword() {        return password;    }    public void setPassword(String password) {        this.password = password;    }    public String getDriver() {        return driver;    }    public void setDriver(String driver) {        this.driver = driver;    }    public Integer getPort() {        return port;    }    public void setPort(Integer port) {        this.port = port;    }    public void setUrl(String url) {        this.url = url;    }    public String getInfo() {        return "[ Driver: Oracle" +                ", url: " + url +                ", port; " + port +                ", user: " + user +                ", password: " + password  +                ", driver: " + driver +                " ] ";    }}

OracleDriveres un bean simple, usaremos la clase de servicio para inyectar propiedades a este bean.

Clase de servicio de primavera

package com.journaldev.service;import com.journaldev.drivers.DataBaseDriver;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.beans.factory.annotation.Qualifier;import org.springframework.stereotype.Service;@Servicepublic class UserService {    @Autowired    @Qualifier("oracleDriver")    private DataBaseDriver dataBaseDriver;    public String getDriverInfo(){        return dataBaseDriver.getInfo();    }}

Aquí usamos @Serviceuna anotación para indicarle a Spring Framework que trate esto como una clase de servicio. Luego usamos las anotaciones @Autowiredy @Qualifier("oracleDriver")para indicarle a Spring Framework que inyecte el bean llamado oracleDrivera la propiedad de clase dataBaseDriver. Tenga en cuenta que aún no hemos creado este bean de Spring.

Judías de primavera

El paso final es crear nuestros beans de resorte y clases de configuración para unir todo.

package com.journaldev.config;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.ComponentScan;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.PropertySource;import org.springframework.core.env.Environment;import com.journaldev.drivers.DataBaseDriver;import com.journaldev.drivers.MySqlDriver;import com.journaldev.drivers.OracleDriver;@Configuration@ComponentScan("com.journaldev")@PropertySource("classpath:oracledatabase.properties")public class AppConfig {@Autowired        Environment environment;@BeanDataBaseDriver oracleDriver() {        OracleDriver oracleDriver = new OracleDriver();oracleDriver.setDriver(environment.getProperty("db.driver"));        oracleDriver.setUrl(environment.getProperty("db.url"));        oracleDriver.setPort(Integer.parseInt(environment.getProperty("db.port")));        oracleDriver.setUser(environment.getProperty("db.user"));        oracleDriver.setPassword(environment.getProperty("db.password"));        return oracleDriver;}@BeanDataBaseDriver mysqlDriver() {return new MySqlDriver();}}

Observe la definición del bean para oracleDriver. En este método, leemos propiedades del archivo que Spring Framework oracledatabase.propertiesestablece como variable. Aquí se encuentran las propiedades definidas en el archivo.environmentoracledatabase.properties

db.url=localhostdb.port=4444db.user=vasiliydb.password=yilisavdb.driver=driver_name

Nuestro proyecto de ejemplo de anotaciones de primavera está listo para probarse. A modo de resumen, realizamos los siguientes pasos:

1. Se creó el proyecto Maven y se agregaron las dependencias de Spring necesarias.
2. Creó clases de componentes e inyectó propiedades desde un archivo de recursos en su variable.
3. Si tenemos un componente de terceros, podemos usar la clase Service para inyectarle dependencias, tal como hicimos con OracleDriver a través de la clase UserService.
4. Finalmente, creamos la clase de configuración para definir los beans de Spring y configurar el paquete base para buscar clases de componentes de Spring y configurarlas.

Ejemplo de prueba de anotaciones de primavera

Aquí está nuestra clase principal para probar nuestro proyecto de ejemplo de anotaciones de Spring.

package com.journaldev;import org.springframework.context.annotation.AnnotationConfigApplicationContext;import org.springframework.context.support.AbstractApplicationContext;import com.journaldev.config.AppConfig;import com.journaldev.drivers.DataBaseDriver;import com.journaldev.service.UserService;public class Main {public static void main(String[] args) {AbstractApplicationContext appContext = new AnnotationConfigApplicationContext(AppConfig.class);DataBaseDriver oracle = appContext.getBean("oracleDriver", DataBaseDriver.class);DataBaseDriver mysql = appContext.getBean("mysqlDriver", DataBaseDriver.class);        System.out.println("Oracle driver info:");        System.out.println(oracle.getInfo());                System.out.println("MySQL driver info:");        System.out.println(mysql.getInfo());        System.out.println("UserService Information");UserService userService = appContext.getBean(UserService.class);System.out.println(userService.getDriverInfo());appContext.close();}}

La imagen de abajo muestra el resultado obtenido. Ten en cuenta que no hemos configurado ningún marco de registro, por lo que todos los registros del marco de Spring se imprimen en la consola en color rojo. Eso es todo para una breve introducción a las anotaciones de Spring. He enumerado aquí la mayoría de las anotaciones importantes, pero hay muchas más para tareas específicas. Puedes descargar mi proyecto de ejemplo de anotaciones de Spring desde el siguiente enlace.

Descargar Descargar Proyecto de ejemplo de anotaciones de primavera

Referencia: Documentación de la API