Spring Boot: Configuraci贸n de propiedades

    Introducci贸n

    En este art铆culo, nos sumergiremos en la configuraci贸n de propiedades de Spring Boot.

    Spring permite a los desarrolladores configurar una gran cantidad de propiedades para sus proyectos. Spring Boot, adem谩s de permitir a los desarrolladores comenzar con un proyecto desde cero con mucha m谩s facilidad y facilidad de uso que Spring, tambi茅n hace que sea mucho m谩s f谩cil configurar propiedades para sus aplicaciones.

    Hay varias formas de configurar un proyecto Spring:

    • Basado en Java
    • Basado en XML
    • Basado en propiedades

    La configuraci贸n de propiedades basada en Java y XML era una forma cl谩sica de configurar aplicaciones Spring antes de que Spring Boot nos presentara un application.properties archivo.

    Esta adici贸n nos permite configurar externamente la aplicaci贸n y acceder f谩cilmente a las propiedades definidas en el archivo.

    Por defecto, el application.properties El archivo se puede utilizar para almacenar pares de propiedades, aunque tambi茅n puede definir cualquier n煤mero de archivos de propiedades adicionales.

    Para registrar un archivo de propiedad, puede anotar un @Configuration clase con el adicional @PropertySource anotaci贸n:

    @Configuration
    @PropertySource("classpath:custom.properties")
    public class ConfigClass {
    // Configuration
    }
    

    Con este m茅todo, puede registrar cualquier cantidad de .properties archivos:

    @Configuration
    @PropertySource("classpath:custom.properties")
    @PropertySource("classpath:another.properties")
    public class ConfigClass {
    // Configuration
    }
    

    Inyecci贸n de propiedades de Spring Boot

    Configuraci贸n de la aplicaci贸n

    La forma m谩s f谩cil de comenzar con un proyecto esqueleto es usar Spring Initializr. Seleccione su versi贸n preferida de Spring Boot, agregue el Web dependencia y generarlo como un proyecto Maven:

    Si abre el proyecto, notar谩 que un archivo application.properties se mantiene en el src/main/resources camino.

    Este es el archivo predeterminado en el que se basa Spring para cargar las propiedades. Podemos escribir nuestras propiedades personalizadas o espec铆ficas de Spring como pares clave-valor aqu铆:

    message.default.welcome=Welcome...
    message.default.goodbye=Goodbye...
    

    En vez de properties archivo, tambi茅n podemos utilizar un .yml archivo y defina las mismas propiedades que:

    message:
      default:
        welcome: Welcome...
        goodbye: Goodbye...
    

    Esto funciona debido a la Serpiente Yaml jar presente en el classpath. Los archivos YAML son m谩s concisos y admiten mapas, listas, etc.

    Depende de usted y su equipo qu茅 tipo usar. Estaremos usando el .properties escriba en este tutorial.

    Inyectar propiedades usando @Value

    Veamos c贸mo podemos usar estas propiedades en una API REST simple:

    @RestController
    public class GreetController {
    
        @Value("${message.default.welcome}")
        private String welcomeMessage;
    
        @Value("${message.default.goodbye}")
        private String goodBye;
    
        @RequestMapping("/welcome")
        public String welcome() {
            return welcomeMessage;
        }
    
        @RequestMapping("/bye")
        public String bye() {
            return goodBye;
        }
    }
    

    Esto es bastante sencillo. Utilizando el @Value anotaci贸n, podemos inyectar los valores de la application.properties archivo en campos de clase en el bean administrado por Spring GreetController.

    Luego tenemos un par de puntos finales REST que simplemente devuelven estos valores:

    Utilizando @Value le permite establecer un valor predeterminado si el solicitado, por cualquier motivo, no est谩 disponible:

    @Value("${message.default.welcome:SomeDefaultValue}")
    private String welcomeMessage;
    

    Si el message.default.welcome el valor no est谩 presente, el valor se establecer谩 como SomeDefaultValue.

    Si desea leer m谩s sobre el @Value anotaci贸n, 隆tenemos un art铆culo detallado sobre eso!

    Inyectar propiedades usando @ConfigurationProperties

    Si nuestras propiedades tienen alg煤n contexto com煤n como el mismo prefijo, podemos usar el @ConfigurationProperties anotaci贸n que asignar谩 estas propiedades a los objetos Java:

    @Configuration
    @ConfigurationProperties(prefix = "message.default")
    public class MessageProperties {
    
        private String welcome;
        private String goodbye;
    
        // Getters and Setters
    }
    
    • @Configuration le dir谩 a Spring que cree un bean de esta clase.
    • @ConfigurationProperties inicializar谩 los campos con los nombres de propiedad correspondientes.

    Ahora podemos usar este bean en otros beans gestionados por Spring:

    @Autowired
    MessageProperties messageProperties;
    

    Propiedades primordiales

    Naturalmente, a medida que nuestro entorno de aplicaciones se expande y cambia (desarrollo, control de calidad, producci贸n, etc.), algunas de nuestras propiedades tambi茅n cambiar谩n. Estos pueden interferir entre s铆 si no los segregamos de alguna manera.

    Logramos esto manteniendo diferentes archivos u obteniendo los valores de las propiedades a trav茅s de variables de entorno.

    Usar perfiles de Spring

    La forma m谩s com煤n de escribir propiedades “cambiantes” es almacenarlas en diferentes archivos. Estos archivos son espec铆ficos del entorno y nuestra aplicaci贸n puede cargarlos en funci贸n de las variables del entorno.

    Spring Boot proporciona una forma muy elegante de manejar esto.

    Todo lo que tenemos que hacer es seguir una convenci贸n de nomenclatura: application-<environment>.properties para nuestros archivos de propiedad:

    • application-dev.properties
    • application-qa.properties
    • application-production.propertiesetc.

    Para notificar a Spring qu茅 archivos usar, tenemos que establecer una variable de entorno: spring.profiles.active.

    Dicho esto, si el valor de spring.profiles.active es dev, por ejemplo, Spring boot cargar谩 el application-dev.properties archivo e igualmente.

    Nota: application.properties siempre est谩 cargado, independientemente de la spring.profiles.active valor. Si hay el mismo valor-clave presente tanto en application.properties y application-<environment>.properties, este 煤ltimo anular谩 al primero.

    Normalmente escribimos todas las propiedades comunes de cada entorno en application.properties y anular las propiedades espec铆ficas del entorno utilizando el perfil espec铆fico application-<environment>.properties.

    Veamos esto creando un application-dev.properties:

    message.default.welcome = Welcome to DEV environment...
    

    Hay algunas formas de configurar spring.profiles.active variable.

    Si estamos ejecutando la aplicaci贸n a trav茅s de Eclipse, podemos configurar esto en argumentos de VM:

    Podemos configurarlo en las variables de entorno del sistema operativo, como en Windows:

    Comencemos nuestra aplicaci贸n y en los registros, puede ver el dev perfil que se est谩 cargando:

    Revisemos nuestros dos puntos finales REST anteriores:

    Como podemos ver, message.default.welcome el valor vino de application-dev.properties archivo y message.default.goodbye la propiedad vino de application.properties.

    Podemos tener varios valores en spring.profiles.active me gusta dev,qa:

    Cualquier clave duplicada ser铆a anulada por el 煤ltimo perfil, en el caso anterior siendo qa.

    Tambi茅n podemos pasar en el spring.profiles.active como un argumento de l铆nea de comandos como:

    java -jar -Dspring.profiles.active=dev greeting-service-0.0.1-SNAPSHOT.jar
    

    Crear application.properties desde la ubicaci贸n de la compilaci贸n

    Tambi茅n podemos anular las propiedades internas creando un application.properties archivo en el mismo nivel desde donde .jar es ejecutado. El contexto de Spring anular谩 las propiedades usando este archivo reci茅n creado.

    Esta es una excelente manera de distribuir su aplicaci贸n a otros, quienes pueden anular ciertas propiedades en funci贸n de su entorno, como configuraciones de bases de datos, por ejemplo.

    Tambi茅n hay otras formas de externalizar sus propiedades, como las variables de entorno del sistema operativo, los argumentos de la l铆nea de comandos, etc. El orden en el que Spring lo considera se puede encontrar aqu铆.

    Externalizaci贸n de propiedades mediante el servidor de configuraci贸n en la nube

    Muchas de las aplicaciones creadas hoy en d铆a se basan en la arquitectura de microservicios. Estas aplicaciones no solo se implementan por separado, sino que podr铆an tener varias instancias de s铆 mismas (seg煤n la carga) y el recuento total podr铆a superar f谩cilmente los 100.

    Gestionar propiedades en este estilo arquitect贸nico particular a trav茅s de m茅todos convencionales requiere demasiado esfuerzo. Adem谩s, para cambiar una propiedad, tenemos que volver a construir la aplicaci贸n e implementarla o, en el mejor de los casos, reiniciar la aplicaci贸n. Esto requiere tiempo de inactividad, lo que frustra todo el prop贸sito de los microservicios.

    Otro problema con el enfoque tradicional, especialmente si las propiedades se externalizaron a trav茅s de variables de archivo o entorno, es que no hay trazabilidad. Siempre se toman las 煤ltimas y no sabemos cu谩les eran las propiedades antes ni qui茅n las cambi贸.

    Configuraci贸n de Spring Cloud proporciona una forma centralizada, externalizada, segura y f谩cil de almacenar y servir configuraciones para aplicaciones para diferentes entornos:

    En resumen, tenemos un servidor de configuraci贸n ejecut谩ndose como una aplicaci贸n separada que se conecta a un repositorio de Git.

    Cuando iniciamos una nueva aplicaci贸n (Config Client), obtiene todas las propiedades necesarias del Config Server. No importa si la aplicaci贸n exist铆a cuando configuramos el servidor o no.

    Crear un servidor de configuraci贸n

    Como siempre, comenzamos usando Spring Initializr.

    Seleccione su versi贸n preferida de Spring Boot, agregue la dependencia del servidor de configuraci贸n y generela como un proyecto de Maven:

    Anotando nuestra clase principal con @EnableConfigServer, lo marcamos como un servidor de configuraci贸n:

    @SpringBootApplication
    @EnableConfigServer
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }
    

    Y ahora, tenemos que configurar algunas cosas en el application.properties archivo:

    server.port = 8888
    spring.cloud.config.server.git.uri = https://github.com/dhananjay12/spring-cloud-config
    spring.cloud.config.server.git.searchPaths = app-properties
    

    Aqu铆, definimos el puerto en el que se ejecutar谩 el servidor de configuraci贸n. Luego especificamos la URL de Git que necesita conectar para las propiedades.

    Nota: De forma predeterminada, Spring busca los archivos de propiedades en la ra铆z. Si tenemos que especificar una carpeta en particular, podemos proporcionar la ubicaci贸n a trav茅s de searchPaths.

    As铆 es como se ve el repositorio de Git:

    Podemos iniciar el servidor de configuraci贸n ahora. Si desea verificar la configuraci贸n del Spring Config Server, siguiendo la convenci贸n: http://localhost:8888/<application-name>/<spring-profiles> nos mostrar谩 toda la informaci贸n necesaria.

    En nuestro caso, ser铆a – http: // localhost: 8888 / greeting-service-cloud / default:

    Crear un cliente de configuraci贸n

    Creemos el mismo servicio de saludo pero con un par de dependencias adicionales:

    Aqu铆 creamos greeting-service-cloud servicio con Web, Config Clienty Actuator dependencias.

    Tiene las mismas asignaciones REST que antes, con la adici贸n de @RefreshScope anotaci贸n. Esta anotaci贸n permite que el bean se actualice din谩micamente en tiempo de ejecuci贸n:

    @RestController
    @RefreshScope
    public class GreetController {
    
        @Value("${message.default.welcome}")
        private String welcomeMessage;
    
        @Value("${message.default.goodbye}")
        private String goodBye;
    
        @RequestMapping("/welcome")
        public String welcome() {
            return welcomeMessage;
        }
        @RequestMapping("/bye")
        public String bye() {
            return goodBye;
        }
    }
    

    Aparte de application.properties ahora tenemos que crear bootstrap.properties, que se carga antes del application.properties.

    Por lo general, el cliente de configuraci贸n de Spring lo usa para obtener propiedades del servidor de configuraci贸n de Spring:

    spring.application.name = greeting-service-cloud
    spring.cloud.config.uri = http://localhost:8888
    

    Aqu铆, primero establecemos el nombre de la aplicaci贸n. Spring Config Server buscar谩 este nombre de archivo en el repositorio de Git y entregar谩 su contenido.

    Tambi茅n tenemos que mencionar d贸nde se est谩 ejecutando el servidor de configuraci贸n especific谩ndolo en spring.cloud.config.uri.

    Iniciemos este servicio y echemos un vistazo a los registros:

    Observe que primero obtuvo las propiedades del Spring Config Server.

    Nota: Si no se puede acceder al servidor de configuraci贸n, la aplicaci贸n no se iniciar谩.

    Ahora revisemos nuestros puntos finales REST:

    As铆 que externalizamos nuestras propiedades y tenemos una buena trazabilidad en nuestro repositorio de Git. Algunos puntos importantes a destacar:

    • Nosotros podemos usar spring-profiles-active aqu铆 tambi茅n. Si esta variable se establece en el entorno del cliente de configuraci贸n, por ejemplo. dev, se pasar谩 al servidor de configuraci贸n mientras se solicitan propiedades. El servidor de configuraci贸n buscar谩 greeting-service-cloud-dev.properties en el repositorio de Git y entregarlo al cliente.
    • Si hay un application.properties presente en el repositorio de Git, ser谩 servido a todos los clientes adem谩s de otros archivos.
    • Si el cliente de configuraci贸n solicita propiedades, por ejemplo, diga dev perfil, el servidor de configuraci贸n volver谩 application.properties, application-dev.properties y greeting-service-cloud-dev.properties. Las propiedades comunes ser谩n anuladas por la 煤ltima.

    Propiedades refrescantes sin reiniciar

    De forma predeterminada, los valores de configuraci贸n de los archivos de propiedades est谩n listos o se recuperan al inicio de la aplicaci贸n y no nuevamente. Si hay algunos cambios por hacer, a煤n tenemos que reiniciar la aplicaci贸n.

    Para resolver esto, agregamos la dependencia Actuator a nuestra aplicaci贸n. Proporciona algunos productos listos para la producci贸n puntos finales que puede brindar informaci贸n sobre nuestra aplicaci贸n que se puede utilizar con fines administrativos.

    Tenemos que habilitar estos puntos finales manualmente especificando management.endpoints.web.exposure.include = * en las propiedades de la aplicaci贸n.

    Agreguemos esto al repositorio de Git y reiniciemos la aplicaci贸n. Podemos comprobar muchos detalles de nuestra aplicaci贸n visitando puntos finales como http: // localhost: 8080 / actuator / env, http: // localhost: 8080 / actuator / mappingsetc.

    El que nos interesa es el /actuator/refresh. Podemos forzar a un bean a actualizar su configuraci贸n (es decir, a extraer la configuraci贸n de nuevo del servidor de configuraci贸n) anotando el bean con @RefreshScope.

    Nota: Si se actualiza un bean, la pr贸xima vez que se accede al bean (es decir, se ejecuta un m茅todo) se crea una nueva instancia.

    Esto se puede activar enviando una solicitud HTTP POST vac铆a al punto final de actualizaci贸n del cliente: http://<host:port>/actuator/refresh.

    Cambiemos el valor de uno en el repositorio de Git por otro:

    message.default.welcome = Welcome from cloud config server changed...
    message.default.goodbye = Goodbye...
    
    management.endpoints.web.exposure.include = *
    

    Ahora activemos el punto final de actualizaci贸n:

    curl localhost:8080/actuator/refresh -d {} -H "Content-Type: application/json"
    

    Comprobar el /welcome punto final:

    Entonces, pudimos actualizar la propiedad de una aplicaci贸n en ejecuci贸n sin reiniciarla.

    Conclusi贸n

    En este art铆culo, hemos cubierto c贸mo configurar propiedades en nuestra aplicaci贸n Spring Boot.

    En primer lugar, hemos discutido formas simples de inyectar propiedades a nuestra aplicaci贸n y luego cambiar / anular estas propiedades en funci贸n de diferentes entornos.

    En segundo lugar, hemos cubierto c贸mo obtener propiedades de Spring Config Server y c贸mo actualizar las propiedades sin una reconstrucci贸n o reinicio.

    Como siempre, el c贸digo de los ejemplos utilizados en este art铆culo se puede encontrar en Github.

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *