Spring: cómo cargar valores literales desde el archivo de propiedades

Los literales en Java son una representación sintética de datos booleanos, numéricos, de caracteres o de string. Es un medio para expresar valores particulares en el programa, como una variable entera llamada »/count se le asigna un valor entero en la siguiente instrucción.

int x = 100; 
// Here 100 is a constant/literal.

Ilustración: String literal.

String s = "Hello";

Archivo de propiedades

El archivo de propiedades se utiliza para escribir la propiedad relacionada con la aplicación en ese archivo. Este archivo contiene la configuración diferente que se requiere para ejecutar la aplicación en un entorno diferente, y cada entorno tendrá una propiedad diferente definida por él. Dentro del archivo de propiedades de la aplicación, definimos cada tipo de propiedad, como cambiar el puerto, la conectividad de la base de datos, la conexión al servidor eureka y muchas más. Ahora veamos cómo cargar valores literales desde el archivo de propiedades en una aplicación Spring. 

Requisito previo : Spring – Inyectar valores literales mediante inyección Setter

Implementación: Proyecto

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.

Ejemplo:

// Java Program to Illustrate Student Class
  
// Class
public class Student {
  
    // Class data members
    private int rollNo;
    private String name;
    private int age;
  
    // Getters and setters
  
    public void setRollNo(int rollNo)
    {
        this.rollNo = rollNo;
    }
  
    public void setName(String name)
    {
  
        // This keyword refers to current instance itself
        this.name = name;
    }
  
    public void setAge(int age) { this.age = age; }
  
    // Method
    public void display()
    {
        System.out.println("Roll No: " + rollNo);
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

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

<bean id="student" class="Student">
   <property name="rollNo" value="101"/>
   <property name="name" value="Sagar"/>
   <property name="age" value="20"/>
</bean>

Ejemplo: archivo beans.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd">
  
    <bean id="student" class="Student">
        <property name="rollNo" value="101"/>
        <property name="name" value="Sagar"/>
        <property name="age" value="20"/>
    </bean>
  
</beans>

Así que 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. A continuación se muestra el código de la clase Main.java . Los comentarios se agregan dentro del código para una mejor comprensión.

Ejemplo

// Java Program to Illustrate Application File
  
// Importing required 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)
    {
        // Implementing Spring IoC
        // using ApplicationContext
        ApplicationContext context
            = new ClassPathXmlApplicationContext(
                "beans.xml");
  
        // Getting the bean student
        Student student
            = context.getBean("student", Student.class);
  
        // Calling the methods
        // inside main() method
        student.display();
    }
}

Ahora ejecuta tu método main() y el resultado será así.

Producción:

Roll No: 101
Name: Sagar
Age: 20

Así que hemos visto este ejemplo antes también. Es un ejemplo simple de inyección de dependencia basada en setter. Pero ahora, aquí está lo interesante. Aquí está el concepto que vamos a discutir y es bastante útil. Así que volvamos al archivo beans.xml de nuevo.

<bean id="student" class="Student">
   <property name="rollNo" value="101"/>
   <property name="name" value="Sagar"/>
   <property name="age" value="20"/>
</bean>

Los valores declarados dentro del archivo de propiedades son valores estáticos (101, Sagar, 20). Ahora queremos cargar estos valores particulares desde un archivo de propiedades. Así que ahora vamos a crear un archivo de propiedades en su classpath y nombrar el archivo como student-info.properties (para este ejemplo lo llamamos así, puede nombrarlo de acuerdo a sus necesidades). Y en este archivo, vamos a escribir algo como esto

student.rollNo = 101
student.name = Sagar
student.age = 20

Ahora nuestro archivo de propiedades está listo y tenemos que cargar estos valores desde el archivo de propiedades al archivo beans.xml. ¿Cómo hacerlo? Entonces 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>

Nota:

• Para cargar los valores dinámicos, la sintaxis estándar es: “${ }”
• ¿Por qué esta línea “<context:property-placeholder location=”classpath:student-info.properties”/>”?. Esta línea se usa para decirle a Spring que queremos cargar el valor de las propiedades del archivo student-info.properties .

Ejemplo: Archivo: beans.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>

Vuelva a ejecutar su método main() y el resultado será así.

Producción:

Roll No: 101
Name: Sagar
Age: 20

Así que hemos visto que nuestra aplicación funciona bien. Y así es como se pueden cargar valores literales desde el archivo de propiedades.