Anotaciones de Primavera

Las anotaciones de Spring nos permiten configurar dependencias e implementar la inyección de dependencias a través de programas Java.

Anotaciones de Spring

• El framework de Spring implementa y promueve el principio de inversión de control (IOC) o inyección de dependencias (DI) y, de hecho, es un contenedor IOC.
• Tradicionalmente, Spring permite a un desarrollador gestionar las dependencias de los beans mediante la configuración basada en XML.
• Existe una forma alternativa de definir 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 te permite gestionar los componentes de los beans programáticamente. Por eso se introdujeron las anotaciones de Spring.

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

Lista de Anotaciones de Spring

Algunas de las anotaciones principales del framework de Spring son:

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

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

   • name: permite dar un nombre al bean
   • initMethod: te permite elegir el método que se invocará en el registro del contexto
   • destroyMethod: te permite elegir el método que se invocará en el apagado del contexto

   Por ejemplo:

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

   public class Computer {
   
       public void turnOn(){
           System.out.println("Cargar sistema operativo");
       }
       public void turnOff(){
           System.out.println("Cerrar todos los programas");
       }
   }
   

3. @PreDestroy y @PostConstruct son formas alternativas para initMethod y destroyMethod de un bean. Pueden utilizarse cuando la clase del bean está definida por nosotros. Por ejemplo;

   public class Computer {
   
       @PostConstruct
       public void encender(){
           System.out.println("Cargar sistema operativo");
       }
   
       @PreDestroy
       public void apagar(){
           System.out.println("Cerrar todos los programas");
       }
   }
   

4. @ComponentScan: Configura directivas de escaneo de componentes para su uso con clases @Configuration. Aquí podemos especificar los paquetes base para escanear componentes de Spring.

5. @Component: Indica que una clase anotada es un “componente”. Estas clases se consideran candidatas para la detección automática al utilizar configuración basada en anotaciones y escaneo en el classpath.

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

7. @Service: Indica que una clase anotada es un “Servicio”. Esta anotación sirve como una especialización de @Component, lo que permite la detección automática de clases de implementación mediante el escaneo del classpath.

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

9. @Autowired: La anotación Spring @Autowired se utiliza para la inyección automática de beans. La anotación @Qualifier de Spring se utiliza en conjunto 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. @Controller
2. @RequestMapping
3. @PathVariable
4. @RequestParam
5. @ModelAttribute
6. @RequestBody y @ResponseBody
7. @RequestHeader y @ResponseHeader

Puedes aprender más sobre ellos en Tutorial de Spring MVC.

Spring Transaction Management Annotations

@Transactional es la anotación de gestión de transacciones declarativa de Spring, lee más en Spring MVC Hibernate.

Spring Security Annotations

@EnableWebSecurity se utiliza con la clase @Configuration para definir la configuración de Spring Security, más información en Ejemplo de Spring Security.

Anotaciones de Spring Boot

1. @SpringBootApplication
2. @EnableAutoConfiguration

Lee más en Ejemplo de Spring Boot.

Ejemplo de Anotaciones de Spring

Echemos un vistazo a un ejemplo sencillo donde utilizaremos anotaciones de Spring en nuestra aplicación. La siguiente imagen ilustra mi proyecto de Ejemplo de Anotaciones de Spring.

Dependencias del Framework Spring

I have created the maven project and added Spring Core Framework dependencies.

<project xmlns="https://maven.apache.org/POM/4.0.0" 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">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring</groupId>
	<artifactId>spring-annotations</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Spring Annotations</name>

	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>

	</dependencies>

</project>

Esto incluirá todos los archivos JAR principales de Spring para nuestro proyecto.

Clases de Componentes

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

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver es 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 +
                " ]";
    }
}

Observa el uso de la anotación @Component para indicar al marco de Spring que trate esta clase como un componente. También estamos utilizando las anotaciones @PropertySource y @Value, Spring las usará en tiempo de ejecución para inyectar y establecer los valores de estas variables desde el archivo de propiedades especificado. A continuación se muestran las propiedades declaradas en el archivo mysqldatabase.properties.

databaseName=school
disableStatementPooling=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 +
                " ] ";
    }
}

OracleDriver es un bean simple, usaremos una clase de servicio para inyectar propiedades en este bean.

Clase de Servicio de Spring

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;

@Service
public class UserService {

    @Autowired
    @Qualifier("oracleDriver")
    private DataBaseDriver dataBaseDriver;

    public String getDriverInfo(){
        return dataBaseDriver.getInfo();
    }
}

Aquí estamos utilizando la anotación @Service para indicar al marco de Spring que trate esto como una clase de servicio. Luego estamos usando las anotaciones @Autowired y @Qualifier("oracleDriver") para decirle al marco de Spring que inyecte el bean llamado oracleDriver en la propiedad de clase dataBaseDriver. Observa que aún no hemos creado este bean de Spring.

Beans de Spring

El paso final es crear nuestros beans de Spring 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;
	
	@Bean
	DataBaseDriver 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;

	}

	@Bean
	DataBaseDriver mysqlDriver() {
		return new MySqlDriver();
	}
}

Observa la definición del bean para oracleDriver. En este método, estamos leyendo propiedades del archivo oracledatabase.properties que está siendo establecido en la variable environment por el marco de Spring. Aquí están las propiedades definidas en el archivo oracledatabase.properties.

db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name

Nuestro proyecto de ejemplo de anotaciones de primavera está listo para probar. Como resumen, realizamos los siguientes pasos:

1. Creamos un proyecto Maven y agregamos las dependencias de primavera requeridas.
2. Creamos clases de componentes e inyectamos propiedades desde un archivo de recursos en sus variables.
3. Si tenemos un componente de terceros, podemos usar la clase de Servicio para inyectar dependencias en él. Tal como lo hicimos para OracleDriver a través de la clase UserService.
4. Finalmente, creamos una clase de configuración para definir beans de primavera y establecer el paquete base para escanear las clases de componentes de primavera y configurarlas.

Prueba de ejemplo 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 a continuación muestra la salida producida. Observe que no hemos configurado ningún marco de registro, por lo que todo el registro del marco de primavera se imprime en la consola en color rojo. Eso es todo para una breve introducción a las anotaciones de primavera. 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 primavera desde el enlace a continuación.

Descargar Proyecto de Ejemplo de Anotaciones de Spring

Referencia: Documentación de API