Anotación @Value de Spring

Primavera La anotación @Value se utiliza para asignar valores predeterminados a variables y argumentos de métodos. Podemos leer variables de entorno de Spring así como variables del sistema utilizando la anotación @Value. La anotación @Value de Spring también admite SpEL. Veamos algunos ejemplos de cómo utilizar la anotación @Value.

Primavera @Value – Valor predeterminado

Podemos asignar un valor predeterminado a una propiedad de clase utilizando la anotación @Value.

@Value("Default DBConfiguration")
private String defaultName;

@Value El argumento de la anotación solo puede ser una cadena, pero Spring intenta convertirlo al tipo especificado. El siguiente código funcionará correctamente y asignará los valores booleanos e enteros a la variable.

@Value("true")
private boolean defaultBoolean;

@Value("10")
private int defaultInt;

Primavera @Value – Propiedad del entorno de Spring

@Value("${APP_NAME_NOT_FOUND}")
private String defaultAppName;

Si la clave no se encuentra en las propiedades del entorno de spring, entonces el valor de la propiedad será ${APP_NAME_NOT_FOUND}. Podemos asignar un valor predeterminado que se asignará si falta la clave de las propiedades del entorno de spring.

@Value("${APP_NAME_NOT_FOUND:Default}")
private String defaultAppName;

Spring @Value – Entorno del sistema

Cuando se carga el entorno de Spring, lee todas las variables del entorno del sistema y las almacena como propiedades. Por lo tanto, también podemos asignar variables del sistema usando la anotación @Value.

@Value("${java.home}")
private String javaHome;
	
@Value("${HOME}")
private String homeDir;

Spring @Value – SpEL

También podemos usar el Lenguaje de Expresión Spring con la anotación @Value. Por lo tanto, también podemos leer la propiedad del sistema java home usando SpEL.

@Value("#{systemProperties['java.home']}")
private String javaHome;

Spring @Value con métodos

Cuando se encuentra la anotación @Value en un método, el contexto de Spring lo invocará cuando se estén cargando todas las configuraciones y beans de Spring. Si el método tiene múltiples argumentos, entonces cada valor de argumento se mapea desde la anotación del método. Si queremos diferentes valores para diferentes argumentos, entonces podemos usar la anotación @Value directamente con el argumento.

@Value("Test")
public void printValues(String s, String v){} //both 's' and 'v' values will be 'Test' 

@Value("Test")
public void printValues(String s, @Value("Data") String v){}
// s=Test, v=Data

Spring @Value Ejemplo

Vamos a crear una aplicación Spring simple donde usaremos la anotación @Value para leer propiedades y asignarlas a variables de clase. Cree un proyecto Maven y agregue las dependencias principales de Spring.

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.0.6.RELEASE</version>
</dependency>

Nuestra estructura final del proyecto se verá como en la imagen de abajo, veremos cada uno de los componentes uno por uno. Cree una clase de componente donde inyectaremos valores de variables mediante la anotación @Value.

package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Value;

public class DBConnection {

	@Value("${DB_DRIVER_CLASS}")
	private String driverClass;
	@Value("${DB_URL}")
	private String dbURL;
	@Value("${DB_USERNAME}")
	private String userName;
	@Value("${DB_PASSWORD}")
	private char[] password;

	public DBConnection() {
	}

	public void printDBConfigs() {
		System.out.println("Driver Class = " + driverClass);
		System.out.println("DB URL = " + dbURL);
		System.out.println("User Name = " + userName);

		// Nunca haga lo siguiente en un entorno de producción :D
		System.out.println("Password = " + String.valueOf(password));
	}
}

Ahora tenemos que crear una clase de configuración y proporcionar un método @Bean para la clase DBConnection.

package com.journaldev.spring;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource("classpath:db.properties")
@PropertySource(value = "classpath:root.properties", ignoreResourceNotFound = true)
public class DBConfiguration {

	@Value("Default DBConfiguration")
	private String defaultName;

	@Value("true")
	private boolean defaultBoolean;

	@Value("10")
	private int defaultInt;

	@Value("${APP_NAME_NOT_FOUND:Default}")
	private String defaultAppName;

	// @Value("#{systemProperties['java.home']}")
	@Value("${java.home}")
	private String javaHome;

	@Value("${HOME}")
	private String homeDir;

	@Bean
	public DBConnection getDBConnection() {
		DBConnection dbConnection = new DBConnection();
		return dbConnection;
	}

	@Value("Test")
	public void printValues(String s, @Value("another variable") String v) {
		System.out.println("Input Argument 1 =" + s);
		System.out.println("Input Argument 2 =" + v);

		System.out.println("Home Directory = " + homeDir);
		System.out.println("Default Configuration Name = " + defaultName);
		System.out.println("Default App Name = " + defaultAppName);
		System.out.println("Java Home = " + javaHome);
		System.out.println("Boolean = " + defaultBoolean);
		System.out.println("Int = " + defaultInt);

	}

}

Aquí está nuestra clase principal donde creamos un contexto de Spring basado en anotaciones.

package com.journaldev.spring;

import java.sql.SQLException;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class SpringMainClass {

	public static void main(String[] args) throws SQLException {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
		context.scan("com.journaldev.spring");
		context.refresh();
		System.out.println("Refreshing the spring context");
		DBConnection dbConnection = context.getBean(DBConnection.class);

		dbConnection.printDBConfigs();
		
		// cierra el contexto de Spring
		context.close();
	}

}

Cuando ejecutes la clase, producirá la siguiente salida.

Input Argument 1 =Test
Input Argument 2 =another variable
Home Directory = /Users/pankaj
Default Configuration Name = Default DBConfiguration
Default App Name = Default
Java Home = /Library/Java/JavaVirtualMachines/jdk-10.0.1.jdk/Contents/Home
Boolean = true
Int = 10
Refreshing the spring context
Driver Class = com.mysql.jdbc.Driver
DB URL = jdbc:mysql://localhost:3306/Test
User Name = journaldev
Password = journaldev

Observa que el método printValues() de la clase de configuración se llama antes de que nuestro contexto esté listo para atender las solicitudes de usuario. Eso es todo para el ejemplo de la anotación @Value de Spring, puedes descargar el código de ejemplo desde nuestro repositorio de GitHub.

Proyecto de Anotación Spring @Value