Cómo acceder a los valores del archivo de propiedades en Spring Boot

En este tutorial, veremos cómo acceder a los valores application.properties y application.yml en aplicaciones Spring Boot, con ejemplos prácticos.

Introducción

Las propiedades de la aplicación pueden variar en diferentes entornos, como la forma en que los hosts en su entorno de control de calidad pueden variar de sus entornos locales y de producción. Con Spring Boot, se pueden configurar y actualizar diferentes entornos por separado sin afectar a otros entornos con el uso de archivos de propiedades.

En este artículo, demostraremos formas de acceder a los valores definidos dentro de un archivo de propiedades en un proyecto de Spring Boot y formas de manipularlos en el código.

Archivos de propiedades de Spring Boot

Spring Boot proporciona una forma de externalizar configuraciones utilizando archivos de propiedades que se encuentran dentro de la ruta de clase del proyecto. Esto es muy útil para configuraciones de múltiples entornos, de modo que las propiedades se puedan configurar dinámicamente por entorno.

El archivo de propiedades predeterminado que genera Spring Boot se llama application.properties, que se encuentra en el directorio src/main/resources/ del proyecto. Al inicializar un proyecto, el archivo de propiedades predeterminado está en blanco.

Aquí hay un ejemplo de un archivo application.properties que contiene dos propiedades de muestra:

1
2
spring.datasource.username=user
logging.level.root=INFO

Este archivo de muestra contiene valores para el nombre de usuario de una fuente de datos y el nivel de registro raíz de la aplicación. Las propiedades siguen la misma sintaxis clave=valor.

Archivos de propiedades YAML

Alternativamente, en lugar de la sintaxis .properties predeterminada, Spring Boot también admite archivos de propiedades en formato YAML. Entonces, en lugar del archivo application.properties predeterminado, puede crear un nuevo archivo de propiedades application.yml si prefiere sus propiedades en formato YAML:

1
2
3
4
5
6
spring:
   datasource:
      username: user
logging:
    level: 
      root: INFO

La única diferencia que esto implicaría es el formato de los contenidos dentro del archivo, por lo que la elección se basa únicamente en la preferencia.

Spring Boot permite la declaración de múltiples archivos de propiedades usando @PropertySource anotación definida a través de una clase de configuración.

Acceso a valores dentro de archivos de propiedades en Spring Boot {#acceso a valores dentro de archivos de propiedades en Spring Boot}

Ahora pasamos al tema principal, que es: cómo acceder a los valores dentro de los archivos de propiedades antes mencionados.

Usando la anotación @Value

La anotación @Value es una anotación predefinida que se utiliza para leer valores de cualquier archivo de propiedades en la ruta de clase del proyecto.

Para acceder al valor de una sola propiedad desde un archivo de propiedades usando esta anotación, proporcione el nombre de la propiedad como argumento:

1
@Value("${spring.sample.property}")

Siguiendo esta sintaxis, echemos un vistazo a un ejemplo en el que establecemos el valor de una variable de cadena en datasource.username definido dentro del archivo de propiedades en el ejemplo anterior:

1
2
@Value("${spring.datasource.username}")
String username;

Si imprimimos la variable anterior sin más manipulación, la salida debería ser el valor de la propiedad especificada declarada en la anotación @Value. En este caso, debería imprimir la cadena usuario:

1
2
System.out.println(username);
// user

Si la propiedad declarada en la anotación no existe dentro de ningún archivo de propiedades, se observará la inicialización predeterminada del tipo de datos. En este caso, la variable nombre de usuario se establecería en null.

Actualizar el valor de la variable anotada con la anotación @Value también cambia el valor real de la propiedad inyectada en la variable durante el tiempo de ejecución:

1
username = "new_user"   

Esto cambia el valor de la variable nombre de usuario y cambia temporalmente el valor de la propiedad spring.datasource.username.

Tenga en cuenta que los cambios realizados durante el tiempo de ejecución se eliminarán una vez que el programa deje de ejecutarse, por lo que los cambios no se reflejarán en el archivo de propiedades real. Esto implica que los valores de propiedad son más dinámicos en lugar de ser solo un valor constante.

Aquí hay un enlace a nuestra guía completa sobre la @anotación de valor si desea obtener más información al respecto.

Usando el objeto de entorno

Otro método para acceder a los valores definidos en Spring Boot es mediante el cableado automático de Ambiente y llamar al método getProperty() para acceder al valor de un archivo de propiedades.

El método getProperty() acepta un solo parámetro requerido que es una cadena que contiene el nombre de la propiedad y devuelve el valor de esa propiedad si existe. Si la propiedad no existe, el método devolverá un valor nulo.

Para este ejemplo, accedamos a la propiedad logging.level.root y almacenémosla dentro de un valor de cadena:

1
2
3
4
5
6
@Autowired
private Environment env;

public void getRootLogLevel() {
  return env.getProperty("logging.level.root");
}

Si se llama e imprime el método getRootLogLevel(), imprimirá el valor de la propiedad, si existe. Con el archivo de propiedades de ejemplo mencionado anteriormente, este método debería generar INFO.

Uso de la anotación @ConfigurationProperties {#uso de la anotación de propiedades de configuración}

La anotación @Propiedades de configuración es un enfoque más amplio que la anotación @Value y el objeto Environment.

Este método se usa para acceder a grupos relacionados de propiedades almacenando la configuración en un POJO (Plain Old Java Object) y usando el POJO para un mayor acceso, a diferencia de las soluciones anteriores donde se accede a las propiedades individualmente.

La anotación @ConfigurationProperties asignará valores dado el prefijo del grupo de propiedades.

Para esta solución, hagamos un nuevo archivo application.properties:

1
2
3
spring.demo.username=user
spring.demo.password=password
spring.demo.email=[correo electrónico protegido]

Las 3 propiedades configuradas en el archivo tienen el mismo prefijo spring.demo.

Ahora, creemos una clase de configuración para mapear los valores de estas propiedades usando la anotación @ConfigurationProperties.

Tenga en cuenta que además de anotar la clase con @ConfigurationProperties, también debe anotarla con @Configuration para informar al sistema que la clase es una clase de configuración.

Además, los nombres de las variables dentro de la clase deben ser los mismos que los nombres dentro del archivo de propiedades con el prefijo proporcionado. Hagamos una clase DemoProperties:

1
2
3
4
5
6
7
8
9
@ConfigurationProperties(prefix="spring.demo")
@Configuration
public class DemoProperties {
  private String username;
  private String password;
  private String email;
  
  // Getters, Setters, Constructors, etc...
}

Ahora que se declara la configuración, la instancia de DemoProperties se puede usar en cualquier lugar dentro de la capa de servicio para acceder a los valores de propiedad simplemente conectando automáticamente la clase:

1
2
3
4
5
6
7
8
@Autowired
private DemoProperties demoProperties;

public void printDemoProperties() {
  System.out.println("Username: " + demoProperties.getUsername());
  System.out.println("Password: " + demoProperties.getPassword());
  System.out.println("Email Address: " + demoProperties.getEmail());
}

Llamar al método printDemoProperties() generará:

1
2
3
Username: user
Password: password
Email Address: [correo electrónico protegido]

Conclusión

Este artículo cubrió tres formas diferentes de acceder a definiciones de valor en Spring Boot. ¡Todos los cuales son bastante fáciles de comprender y aplicar a sus proyectos!

La anotación @Value es la solución más utilizada para acceder a los valores de propiedad en Spring Boot. El objeto Environment no se usa con tanta frecuencia, pero sigue siendo una forma viable de acceder a un valor de propiedad.

La anotación @ConfigurationProperties es un poco más completa y solo debe usarse para grupos más grandes de propiedades que tienen el mismo prefijo y el mismo contexto, ya que necesitaría acomodar esta solución creando un POJO para almacenar el grupo de valores de propiedad.