Una de las anotaciones más importantes de Spring es la anotación @Value, que se utiliza para asignar valores predeterminados a variables y argumentos de métodos. Podemos leer las variables de entorno de Spring, así como las variables del sistema usando la anotación @Value. También es compatible con Spring Expression Language (SpEL). Generalmente se usa para inyectar valores en las variables de configuración, que mostraremos y explicaremos en el siguiente ejemplo.
Implementación: Proyecto
Requisitos previos :
- Spring: inyección de valores literales mediante inyección Setter
- Spring: cómo cargar valores literales desde el archivo de propiedades
Paso 1: Primero, creemos una aplicación Spring simple e inyectemos los valores literales mediante inyección de setter. Por lo tanto, cree una clase simple Student que tenga tres atributos rollNo, name y age. Cree métodos setter para estos dos atributos y un método simple para imprimir los detalles del estudiante.
Archivo: Student.java
Java
// Java Program to Illustrate Student Class
// Class
public class Student {
// Class data members
private int rollNo;
private String name;
private int age;
// Setter
public void setRollNo(int rollNo)
{
// this keyword refers to current instance itself
this.rollNo = rollNo;
}
// Setter
public void setName(String name) { this.name = name; }
// Setter
public void setAge(int age) { this.age = age; }
// Method
public void display()
{
// Printing attributes of corresponding student
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Paso 2: Vamos a crear un archivo de propiedades en su classpath y nombrarlo como student-info.properties (para este ejemplo lo llamamos así, puede nombrarlo según sus necesidades). Y en este archivo, vamos a escribir algo como lo siguiente:
student.rollNo = 101 student.name = Sagar student.age = 20
Paso 3: Ahora vamos a crear un Student Bean en el archivo beans.xml y dentro del bean, debe agregar el nombre de su propiedad y sus valores correspondientes dentro de la etiqueta <property>. Por ejemplo, para este proyecto, podemos escribir algo como esto
<context:property-placeholder location="classpath:student-info.properties"/>
<bean id="student" class="Student">
<property name="rollNo" value="${student.rollNo}"/>
<property name="name" value="${student.name}"/>
<property name="age" value="${student.age}"/>
</bean>
Archivo: beans.xml
XML
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder location="classpath:student-info.properties"/>
<bean id="student" class="Student">
<property name="rollNo" value="${student.rollNo}"/>
<property name="name" value="${student.name}"/>
<property name="age" value="${student.age}"/>
</bean>
</beans>
Paso 4: Ahora nuestro frijol está listo. Ahora vamos a crear una clase y definir el método main() dentro de esa clase. Supongamos que hemos creado una clase llamada Main y hemos definido el método main() dentro de esta clase.
Archivo: Main.java
Java
// Java Program to Illustrate Application Class
// Importing require classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Application class
public class Main {
// Main driver method
public static void main(String[] args)
{
// Using ApplicationContext tom implement Spring IoC
ApplicationContext context
= new ClassPathXmlApplicationContext(
"beans.xml");
// Getting the bean student
Student student
= context.getBean("student", Student.class);
// Calling display() method
// inside main() method
student.display();
}
}
Paso 5: Ahora ejecuta tu método main() y el resultado será así.
Producción:
Roll No: 101 Name: Sagar Age: 20
Explicación del código: Entonces la aplicación funciona bien. Ahora vuelve al archivo beans.xml . Y en este archivo, no queremos establecer un valor como este como lo hemos hecho. Queremos usar alguna anotación para hacer lo mismo. Y aquí entra en escena @Value Annotation. Entonces podemos modificar nuestro archivo Student.java algo como esto
Archivo: Student.java
Java
// Java Program to Illustrate Student Class
// Importing required classes
import org.springframework.beans.factory.annotation.Value;
// Class
public class Student {
// Class data members
private int rollNo;
private String name;
private int age;
@Value("101")
// Setter
public void setRollNo(int rollNo)
{
this.rollNo = rollNo;
}
@Value("Anshul")
// Setter
public void setName(String name)
{
this.name = name;
}
@Value("25")
// Setter
public void setAge(int age)
{
this.age = age;
}
// Method
public void display()
{
// Print statement
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Paso 6: agregue la siguiente línea dentro de su archivo beans.xml
<context:annotation-config/>
Archivo: beans.xml
XML
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <bean id="student" class="Student"> </bean> </beans>
Paso 7: Ejecute su método main() y el resultado será así.
Producción:
Roll No: 101 Name: Anshul Age: 25
Nota: O también puede establecer los valores dinámicamente desde el archivo de propiedades. Podemos modificar nuestro archivo Student.java algo como esto
Archivo: Student.java
Java
// Java Program to Illustrate Student Class
// Importing required classes
import org.springframework.beans.factory.annotation.Value;
// Class
public class Student {
// Class data members
private int rollNo;
private String name;
private int age;
@Value("${student.rollNo}")
// Setter
public void setRollNo(int rollNo)
{
// this keyword refers to current instance itself
this.rollNo = rollNo;
}
@Value("${student.name}")
// Setter
public void setName(String name)
{
this.name = name;
}
@Value("${student.age}")
// Setter
public void setAge(int age)
{
this.age = age;
}
// Method
public void display()
{
// Printing attributes corresponding to student
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Sugerencia: no olvide agregar la siguiente línea dentro de su archivo beans.xml
<context:property-placeholder location="classpath:student-info.properties"/>
Archivo: beans.xml
XML
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> <context:property-placeholder location="classpath:student-info.properties"/> <bean id="student" class="Student"> </bean> </beans>
Ejecute su método main() y el resultado será así.
Producción:
Roll No: 101 Name: Sagar Age: 20
Ahora analicemos un concepto más interesante en la anotación Spring @Value. También podemos usar la anotación @Value antes de los campos. No es necesario crear el método setter. Podemos modificar nuestro archivo Student.java algo como esto
Archivo: Student.java
Java
// Java Program to Illustrate Student Class
// Importing required classes
import org.springframework.beans.factory.annotation.Value;
// Class
public class Student {
// Class data members
@Value("${student.rollNo}") private int rollNo;
@Value("${student.name}") private String name;
@Value("${student.age}") private int age;
// Method
public void display()
{
// Printing attributes corresponding to student
System.out.println("Roll No: " + rollNo);
System.out.println("Name: " + name);
System.out.println("Age: " + age);
}
}
Todas las demás cosas deben permanecer sin cambios. Ejecute su método main() nuevamente y el resultado será así.
Producción:
Roll No: 101 Name: Sagar Age: 20
Publicación traducida automáticamente
Artículo escrito por AmiyaRanjanRout y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA