¿Es una mala práctica incluir propiedades / archivos de configuración dentro de los tarros?

https://stackoverflow.com/questions/1208848

05-07-2019
|

Pregunta

Por ejemplo:

MyApp es una aplicación web que contiene un archivo de propiedades (server.properties) que describe datos de configuración (por ejemplo, nombres de servidor) para la aplicación. En la fase de desarrollo, server.properties se encuentra en su propia carpeta de proyectos IDE (un lugar lógico para ello).

Ahora es el momento de implementar MyApp. El IDE hace que sea bastante trivial agrupar los archivos de clase así como los archivos de configuración compatibles. Ahora simplemente colocamos el Jar en el contenedor web apropiado y nos vamos ...

Una semana más tarde ... los datos de configuración del servidor que utiliza MyApp deben cambiar. ¿Qué tiene más sentido?

A. Modifique el archivo server.properties de nuevo en el terreno IDE y genere un archivo jar completamente nuevo. Volver a desplegar (lo que significa rebotar la aplicación para un cambio de configuración simple).

B. ¿Abrir crack el Jar ya desplegado y modificar el archivo server.properties? (puede que tenga que llamar a una función de actualización en MyApp si server.properties está en caché ... pero no debe requerir un rebote completo de la aplicación. También debe recordar modificar la fuente de server.properties para que las implementaciones futuras no reviertan server.properties a los antiguos nombres de servidor).

C. Haga server.properties externo al archivo jar en primer lugar. Muy similar al proceso de B, con la pequeña diferencia de mantener los datos de configuración externos al contenedor (introduce diferentes rutas entre los despliegues de desarrollo y producción)

D. Otros:

¡Gracias!

Solución

Iría con D.

Intente cargar los archivos de propiedades desde fuera del archivo .jar y luego, si eso falla, cargue las propiedades integradas en el jar.

Esto le permite sacar un " listo hecho " configuración con cada compilación (también reduce la complejidad de una implementación, aunque solo sea por un archivo), a la vez que hace que las configuraciones de reemplazo sean posibles y razonablemente simples.

Otros consejos

Si está utilizando Spring, entonces puede hacer uso del marcador de posición de propiedad para hacer el trabajo.

<!-- try and resolve the config from the filesystem first and then fallback to the classpath -->
<context:property-placeholder location="file:config.properties, classpath:config.properties"
                              ignore-resource-not-found="true"/>

Puede especificar un recurso en el sistema de archivos y también en la ruta de clase, Spring primero intentará resolver todas las propiedades del sistema de archivos y luego volverá a la ruta de clase. Al especificar " ignore-resource-not-found " atributo como " verdadero " evitará que Spring lance una excepción si el archivo no está presente en el sistema de archivos y le permite resolver las propiedades de la ruta de clase en su lugar.

El uso de esta combinación también le permite dividir las propiedades en dos archivos, por ejemplo, es posible que nunca desee especificar contraseñas en el archivo en la ruta de clase y esperar que se especifiquen externamente en el sistema de archivos. Cualquier propiedad que falte en el sistema de archivos se resolverá desde la ruta de clase.

En una carpeta que contiene:

application.jar
config.properties

Debes poder utilizar:

java -jar application.jar

Este es un ejemplo de config.properties para referencia:

# This file contains properties that are used to configure the application
database.url=127.0.0.1
database.port=3306
database.user=root
database.pass=p4ssw0rd

Depende. Si el archivo de propiedades contiene datos que deben ser modificados por el usuario de su aplicación o biblioteca, estos deben residir fuera.

Si contiene datos estáticos y usted creó los archivos de propiedades solo para evitar la codificación de los valores en el código fuente o si los archivos son cadenas localizadas, los dejo en el contenedor. Al menos porque un archivo de propiedades invita a las personas a cambiar valores;)

Cargar las propiedades en el jar. Luego cree una nueva propiedad usando las propiedades de jarra como las predeterminadas. A continuación, cargar desde el exterior de la jarra. Esto permite seleccionar la personalización de las propiedades.

Recuerde que, en J2EE, NO se le garantiza que pueda acceder a archivos desde fuera del entorno J2EE (sin acceso directo a archivos).

Tendría que usar JNDI para apuntar a una fuente de datos que contenga sus datos, o un archivo de propiedades en sus artefactos de implementación.

Websphere, por ejemplo, no permite el acceso directo a archivos de forma predeterminada.

Opción D. En diferentes entornos, es posible que deba especificar que desea especificar las propiedades del entorno, como la conexión a la base de datos o el proxy, etc.

Otra cosa que vale la pena mencionar es que en producción es posible que desee cambiar rápidamente una propiedad sin tener que empaquetar previamente un frasco o reemplazar el archivo de propiedades en el frasco.

Por ejemplo, El servidor de la base de datos se ha caído y debe apuntar a un servidor diferente (si no utiliza un equilibrador de carga de las bases de datos). Así que todo lo que necesita hacer es reemplazar las propiedades de la base de datos y reiniciar. Ahorrarás mucho tiempo allí.

Con frecuencia, es un criterio que el código debe migrarse SIN CAMBIAR de la prueba a la producción. Esto implica que no puede editar archivos de configuración incrustados. También puede terminar en una situación en la que necesite cambiar una configuración implementada, lo que con frecuencia es muy engorroso. Por lo tanto, dejamos la configuración fuera de los frascos.

Para aplicaciones Java EE, considere JNDI o un archivo de propiedades en la ruta de clase.

Tengo una aplicación web donde la configuración se recupera de una aplicación web vecina simplemente para separar los dos. Eso resultó ser mucho más fácil.

Uso archivos de propiedades en webapps (WAR), pero principalmente para valores predeterminados y cosas más o menos inmutables (ya que las webapps no deberían actualizar sus WAR incluso cuando pueden).

Sin embargo, para cosas como de las que estás hablando, uso JNDI. Puede definir las propiedades como recursos en su archivo web.xml. De esa manera, en el peor de los casos, actualiza web.xml y no la aplicación en sí.

Para algunos servidores, hay formas de anular estos valores de recursos sin tocar el WAR en absoluto. Por ejemplo, en Tomcat.

Normalmente hago un WAR para prueba, Q / A y producción, y anulo los recursos sensibles al medio ambiente exactamente con el uso de los archivos xml Context de Tomcat. Considero que esto es mucho mejor que tener que crear múltiples WAR o modificar WARS, ya que la aplicación que estoy probando es casi idéntica a la que está en producción.

Creo que la respuesta depende de si cree que necesita un control de versión para las configuraciones. (Podrían ser configuraciones de producción o configuraciones para pruebas de regresión ...)

Si no necesita el control de versiones, la opción D con un archivo de propiedades externo que invalida un archivo de propiedades es buena. Las opciones B y C están más abiertas a los problemas, pero si realmente te importara usarías el control de versiones :-)
Si necesita control de versiones, la opción A le brinda más control, pero si tiene la posibilidad de realizar múltiples implementaciones, también puede querer / necesitar el control de versiones de las configuraciones para cada implementación. Un ejemplo son las implementaciones separadas para las plataformas de prueba y producción.

Así es como lo hacemos utilizando los módulos de Maven y el archivo WAR de Maven " superposiciones " ;.

Tenemos varios módulos para los componentes de código Java. Estos son módulos JAR.
Tenemos " base webapp " Módulo para el contenido estático, JSP y datos de configuración del núcleo (cableado Spring, propiedades predeterminadas). Este es un módulo WAR, por lo que el resultado de la construcción es un WAR que contiene lo anterior + todos los archivos JAR.
Cada " configuración de sitio " " es un módulo WAR que contiene anulaciones específicas de sitio para propiedades, archivos de cableado y contenido. La anulación se describe mediante la superposición WAR de Maven " " " mecanismo, y da como resultado un nuevo WAR que se ensambla desde la base " base " WAR y las anulaciones.

Todo esto está incluido en el control de versiones, y necesitas hacer una implementación de Maven y WAR para realizar cambios en la configuración.

He hecho una pregunta similar. Aún no lo hemos resuelto todo. Pero estamos buscando en los recursos de URL. Donde el archivo de propiedad se lee directamente desde SVN. No es necesario actualizar nada más que el archivo de propiedades.

Desarrollo aplicaciones J2EE usando Spring. Corría con el mismo problema durante bastante tiempo y luego encontré una solución. Mi problema fue especificar las propiedades de la base de datos en un archivo de propiedades fuera del archivo war que implemento. La solución que encontré para esto es usar PropertyPlaceholderConfigurer y especificar la propiedad de ubicación para ubicar la ubicación de su sistema como esta,

¡Esto fue bastante simple y funcionó bien!

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow