studio programacion libros libro desarrollo desarrollar con aprende aplicaciones java xml json cross-platform configuration-files

java - libros - manual de programacion android pdf



Archivos de configuración de la aplicación (15)

Primero: este es un tema de debate realmente grande, no un rápido Q + A.

Mi favorito ahora es simplemente incluir a Lua , porque

  • Puedo permitir cosas como width = height * (1 + 1/3)
  • Puedo hacer que las funciones personalizadas estén disponibles
  • Puedo prohibir cualquier otra cosa. (imposible en, por ejemplo, Python (incluidos los encurtidos))
  • Probablemente quiera un lenguaje de scripting en otro lugar en el proyecto de todos modos.

Otra opción, si hay una gran cantidad de datos es usar sqlite3 , porque tienen razón al reclamar

  • Pequeña.
  • Rápido.
  • De confianza.

Elija cualquier tres.

A lo que me gustaría agregar:

  • las copias de seguridad son muy fáciles. (solo copie el archivo db)
  • más fácil cambiar a otro db, ODBC, lo que sea. (que es de archivo fugly)

Pero, de nuevo, este es un problema mayor. Una respuesta "grande" a esto probablemente involucre algún tipo de matriz de funciones o una lista de situaciones como:

Cantidad de datos, o tiempo de ejecución corto

  • Para grandes cantidades de datos, es posible que desee un almacenamiento eficiente, como un db.
  • Para tiradas cortas (a menudo), es posible que desee algo que no necesita analizar mucho, considere algo que puede ser mmap: ed in directamente.

¿Con qué se relaciona la configuración?

  • Anfitrión:
    • Me gusta YAML en / etc. ¿Eso se vuelve a implementar en Windows?
  • Usuario:
    • ¿Permite a los usuarios editar la configuración con el editor de texto?
    • ¿Debería ser centralmente manejable? Registro / gconf / remote db?
    • ¿Puede el usuario tener varios perfiles diferentes?
  • Proyecto:
    • Archivo (s) en el directorio del proyecto? (El control de versiones generalmente sigue este modelo ...)

Complejidad

  • ¿Hay solo unos pocos valores planos? Considera YAML.
  • ¿Los datos están anidados o son dependientes de alguna manera? (Aquí es donde se pone interesante.)
  • ¿Podría ser una característica deseable permitir alguna forma de scripting?
  • Las plantillas se pueden ver como un tipo de archivos de configuración.

OK, entonces no quiero comenzar una guerra santa aquí, pero estamos en el proceso de tratar de consolidar la forma en que manejamos nuestros archivos de configuración de aplicaciones y estamos luchando para tomar una decisión sobre el mejor enfoque para tomar . Por el momento, cada aplicación que distribuimos utiliza sus propios archivos de configuración ad-hoc, ya sean archivos de propiedades (estilo ini), XML o JSON (¡uso interno solo en este momento!).

La mayor parte de nuestro código es Java en este momento, por lo que hemos estado buscando Apache Commons Config , pero hemos encontrado que es bastante detallado. También hemos analizado XMLBeans , pero parece que hay muchos problemas. También siento que estoy siendo empujado hacia XML como formato, pero mis clientes y colegas temen probar otra cosa. Puedo entenderlo desde la perspectiva del cliente, todo el mundo ha oído hablar de XML, pero al final del día, ¿no debería usar la herramienta adecuada para el trabajo?

¿Qué formatos y bibliotecas usa la gente en los sistemas de producción actualmente? ¿Alguien más está tratando de evitar el impuesto de paridad angular ?

Edición: realmente necesita ser una solución multiplataforma: Linux, Windows, Solaris, etc. y la elección de la biblioteca utilizada para interactuar con los archivos de configuración es tan importante como la elección del formato.

¿En qué plataforma estás trabajando? Recomiendo tratar de usar el método preferido / común para ello.

  1. MacOSX - plists
  2. Win32 - Registry (o hay uno nuevo aquí, hace mucho tiempo que desarrollé en él)
  3. Linux / Unix - ~ / .apprc (nombre-valor tal vez)

@Chico

Pero la configuración de la aplicación no siempre es solo pares clave / valor. Mire algo así como la configuración de tomcat para qué puertos escucha. Aquí hay un ejemplo:

<Connector port="80" maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" /> <Connector port="8009" enableLookups="false" redirectPort="8443" protocol="AJP/1.3" />

Puede tener cualquier cantidad de conectores. Define más en el archivo y existen más conectores. No definas más y ya no existes. No hay una buena manera (imho) de hacer eso con pares simples de clave / valor.

Si la configuración de su aplicación es simple, entonces algo simple como un archivo INI que se lee en un diccionario probablemente esté bien. Pero para algo más complejo como la configuración del servidor, un archivo INI sería muy difícil de mantener, y algo más estructural como XML o YAML sería mejor. Todo depende del problema establecido.

@Herms

Lo que realmente quise decir es que sigamos con la forma recomendada en que el software debe almacenar valores de configuración para cualquier plataforma determinada.

Lo que a menudo obtienes entonces es también la forma recomendada en que estos deben / pueden ser modificados. Como un menú de configuración en un programa o un panel de configuración en una aplicación "system prefs" (para softwares de servicios del sistema, por ejemplo). No permitiendo que los usuarios finales los modifiquen directamente a través de RegEdit o NotePad ...

¿Por qué?

  1. Los usuarios finales (= clientes) están acostumbrados a sus plataformas
  2. El sistema de copias de seguridad puede guardar mejor las "configuraciones seguras", etc.

@ninesided

Acerca de " elección de la biblioteca ", intente vincular en (enlace estático) cualquier biblioteca seleccionada para reducir el riesgo de entrar en una guerra de versiones-conflictos en las máquinas de los usuarios finales.

Estamos usando archivos de configuración de estilo ini. Usamos la biblioteca Nini para administrarlos. Nini lo hace muy fácil de usar. Nini era originalmente para .NET pero ha sido portado a otras plataformas usando Mono.

Estamos utilizando archivos de propiedades, simplemente porque Java los admite de forma nativa. Hace un par de meses vi que SpringSource Application Platform usa JSON para configurar su servidor y se ve muy interesante. Comparé varias anotaciones de configuración y llegué a la conclusión de que XML parece ser la mejor opción en este momento. Tiene buen soporte de herramientas y es bastante independiente de la plataforma.

Por lo que yo sé, el registro de Windows ya no es la forma preferida de almacenar la configuración si está utilizando .NET: la mayoría de las aplicaciones ahora hacen uso de System.Configuration [1, 2]. Como esto también está basado en XML, parece ser que todo se está moviendo en el sentido de usar XML para la configuración.

Si quieres mantenerte multiplataforma, diría que usar algún tipo de archivo de texto sería la mejor ruta. En cuanto al formato de dicho archivo, es posible que desee tener en cuenta si un humano lo va a manipular o no. XML parece ser un poco más amigable con la manipulación manual que los archivos INI debido a la estructura visible del archivo.

En cuanto al impuesto sobre el paréntesis angular, no me preocupo demasiado porque las bibliotecas XML se encargan de abstraerlo. El único momento en que podría ser una consideración es si tiene muy poco espacio de almacenamiento para trabajar y cada byte cuenta.

[1] System.Configuration Namespace - http://msdn.microsoft.com/en-us/library/system.configuration.aspx

[2] Uso de los archivos de configuración de la aplicación en .NET - http://www.developer.com/net/net/article.php/3396111

Re: comentario de epatel

Creo que la pregunta original fue preguntar sobre la configuración de la aplicación que haría un administrador, no solo almacenar las preferencias del usuario. Las sugerencias que dio parecen más para las preferencias del usuario que para la configuración de la aplicación, y no son algo con lo que el usuario pueda tratar directamente (la aplicación debe proporcionar las opciones de configuración en la interfaz de usuario y luego actualizar los archivos). Realmente espero que nunca haga que el usuario tenga que ver / editar el Registro. :)

En cuanto a la pregunta real, diría que XML probablemente esté bien, ya que mucha gente estará acostumbrada a usarlo para la configuración. Siempre que organice los valores de configuración de una manera fácil de usar, entonces el "impuesto de escuadra" no debería ser tan malo.

Sin comenzar una nueva guerra santa, los sentimientos de la publicación del ''impuesto de paréntesis angulares'' es un área en la que mayormente estoy en desacuerdo con Jeff. No hay nada de malo con XML, es razonablemente legible (tanto como los archivos YAML o JSON o INI), pero recuerde que su intención es ser leído por las máquinas. La mayoría de los combos de lenguaje / framework vienen con un analizador XML de algún tipo de forma gratuita, lo que hace que XML sea una opción bastante buena.

Además, si está utilizando un buen IDE como Visual Studio, y si el XML viene con un esquema, puede darle el esquema a VS y mágicamente obtendrá intellisense (puede obtener uno para NHibernate, por ejemplo).

Ulimamente debe pensar en la frecuencia con la que tocará estos archivos una vez en producción, probablemente no tan a menudo.

Esto todavía lo dice todo sobre XML y por qué sigue siendo una opción válida para los archivos de configuración (de Tim Bray ):

"Si quieres proporcionar datos de propósito general con los que el receptor podría querer hacer cosas extrañas e inesperadas, o si quieres ser realmente paranoico y exigente con i18n, o si lo que estás enviando es más como un documento que una estructura, o si el orden de los datos importa, o si los datos son potencialmente de larga duración (como en, más de segundos) XML es el camino a seguir. También me parece que la combinación de XML y XPath golpea una punto ideal para formatos de datos que deben ser extensibles, es decir, es bastante fácil escribir código de procesamiento XML que no fallará en presencia de cambios en el formato de mensaje que no toquen la pieza que le importa. "

Tal vez un poco de tangente aquí, pero mi opinión es que el archivo de configuración debe leerse en una tabla de valores clave / hash de clave cuando la aplicación se inicia por primera vez y siempre se accede a través de este objeto para acelerar. Por lo general, la tabla de clave / valor comienza como cadena a cadena, pero las funciones de ayuda en el objeto hacen cosas tales como DateTime GetConfigDate (clave de cadena), etc.

XML, JSON, INI.
Todos ellos tienen sus fortalezas y debilidades.
En un contexto de aplicación, siento que la capa de abstracción es lo importante.
Si puede elegir una forma de estructurar los datos que es un buen término medio entre la legibilidad humana y la forma en que desea acceder / abstraer los datos en el código, es oro.

Usamos principalmente XML donde trabajo, y realmente no puedo creer que un archivo de configuración cargado en un caché como objetos cuando se leyó por primera vez o después de que se haya escrito, y luego se haya abstraído del resto del programa, realmente es mucho de un golpe ni en la CPU ni en el espacio del disco.
Y es bastante legible también, siempre y cuando estructure el archivo correctamente.

Y todos los idiomas en todas las plataformas admiten XML a través de algunas bibliotecas bastante comunes.

YAML, por la sencilla razón de que crea archivos de configuración muy legibles en comparación con XML.

XML:

<user id="babooey" on="cpu1"> <firstname>Bob</firstname> <lastname>Abooey</lastname> <department>adv</department> <cell>555-1212</cell> <address password="xxxx">[email protected]</address> <address password="xxxx">[email protected]</address> </user>

YAML:

babooey: computer : cpu1 firstname: Bob lastname: Abooey cell: 555-1212 addresses: - address: [email protected] password: xxxx - address: [email protected] password: xxxx

Los ejemplos fueron tomados de esta página: http://www.kuro5hin.org/story/2004/10/29/14225/062

XML XML XML XML. Estamos hablando de archivos de configuración aquí . No hay un "impuesto de paréntesis angular" si no está serializando objetos en una situación de rendimiento intenso.

Los archivos de configuración deben ser legibles por humanos y comprensibles para los humanos, además de ser legibles por máquina. XML es un buen compromiso entre los dos.

Si su tienda tiene personas que le temen a la tecnología XML de última generación, me siento mal por ti.

Creo que lo único importante es elegir un formato que prefiera y pueda navegar rápidamente. XML y JSON son buenos formatos para las configuraciones y son ampliamente compatibles. La implementación técnica no está en el quid de la cuestión, creo. Es 100% más fácil para usted la tarea de los archivos de configuración.

Empecé a usar JSON, porque trabajo bastante como formato de transporte de datos y los serializadores facilitan la carga en cualquier marco de desarrollo. Encuentro que JSON es más fácil de leer que XML, lo que hace que el manejo de múltiples servicios, cada uno usando un archivo de configuración que se modifica con bastante frecuencia, ¡sea mucho más fácil para mí!

Si su archivo de configuración es de escritura única, de solo lectura en el arranque, y sus datos son un conjunto de pares de valores de nombre, su mejor opción es la que el desarrollador puede obtener trabajando primero.

Si sus datos son un poco más complicados, con anidación, etc., probablemente esté mejor con YAML, XML o SQLite.

Si necesita datos anidados y / o la capacidad de consultar los datos de configuración después del inicio, use XML o SQLite. Ambos tienen lenguajes de consulta bastante buenos (XPATH y SQL) para datos estructurados / anidados.

Si sus datos de configuración están altamente normalizados (por ejemplo, la quinta forma normal), estará mejor con SQLite porque SQL es mejor para manejar datos altamente normalizados.

Si planea escribir en el conjunto de datos de configuración durante la operación del programa, entonces es mejor que vaya con SQLite. Por ejemplo, si está descargando datos de configuración desde otra computadora, o si está basando las decisiones futuras de ejecución del programa en los datos recopilados en la ejecución previa del programa. SQLite implementa un motor de almacenamiento de datos muy robusto que es extremadamente difícil de corromper cuando tiene cortes de energía o programas que están colgados en un estado incoherente debido a errores. Los datos corruptos conducen a altos costos de soporte de campo, y SQLite lo hará mucho mejor que cualquier solución local o incluso bibliotecas populares en torno a XML o YAML.

Consulte mi página para obtener más información sobre SQLite.