¿Cómo crear y modificar el archivo de propiedades del programa Java en formato de texto y XML?

El archivo de propiedades es un valor clave orientado a texto, un par de contenidos presentes en un proyecto Java con extensión .properties . Línea por línea, el par de contenidos clave-valor está presente y generalmente se preparan mediante el bloc de notas, Wordpad, EditPlus, etc. Los archivos de propiedades suelen ser útiles para almacenar información confidencial importante y en este artículo, veamos cómo para crear un archivo de propiedades usando programas Java.

La API de Java obtuvo la clase java.util.Properties y tiene varios métodos de almacenamiento de utilidades () para almacenar propiedades en formato de texto o XML . Para almacenar propiedades en formato de texto , se puede usar el método Store() . storeToXML() se utiliza para hacer  en formato XML .

El método store() tomó dos parámetros como Output Stream y Comments.

Creación de formato de texto:

Veamos cómo crear un archivo de propiedades en formato de texto. Como estamos creando contenido de propiedades, se debe proporcionar una ubicación de ruta de archivo válida.

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
  
public class CreationOfTextOrientedProperties {
  
    public static void main(String args[])
        throws FileNotFoundException, IOException
    {
  
        // Creating properties files from Java program
        Properties properties = new Properties();
        
        // In the name of userCreated.properties, in the
        // current directory location, the file is created
        FileOutputStream fileOutputStream
            = new FileOutputStream(
                "userCreated.properties");
  
        // As an example, given steps how
        // to keep username and password
        properties.setProperty("username", "value1");
        properties.setProperty("password", "value2");
  
        // writing properties into properties file
        // from Java As we are writing text format,
        // store() method is used
        properties.store(
            fileOutputStream,
            "Sample way of creating Properties file from Java program");
  
        fileOutputStream.close();
    }
}

Producción:

Estamos usando store() para guardar el archivo de propiedades en formato de texto. Como pares clave-valor, se establecen. es decir clave = valor. Aparte de eso, todos se consideran comentarios y, por lo tanto, con el símbolo #, se colocan comentarios.

El uso de propiedades en formato de texto es útil en muchos casos cuando el contenido de las propiedades es menor, el equipo de desarrolladores cambia con frecuencia y los usuarios finales no son de TI.

Creación de formato XML:

En muchos casos, se necesita XML, que proporciona un formato eficiente y fácil de entender para almacenar información confidencial importante. El lenguaje de marcado extensible (XML) es un lenguaje de marcado y tiene un conjunto de reglas para codificar documentos, y son comprensibles tanto en formato legible por humanos como por máquina. Aquí, veamos cómo crear a través del programa Java.

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
  
public class CreationOfXMLOrientedProperties {
  
    public static void main(String args[])
        throws FileNotFoundException, IOException
    {
  
        // Creating properties files from Java program
        Properties properties = new Properties();
  
        // In the name of userCreated.xml, in the current
        // directory location, the file is created
        FileOutputStream fileOutputStream
            = new FileOutputStream("userCreated.xml");
  
        // As an example, given steps how to keep username
        // and password
        properties.setProperty("username", "value1");
        properties.setProperty("password", "value2");
  
        // writing properties into properties file
        // from Java As we are writing in XML format,
        // storeToXML() method is used
        properties.storeToXML(
            fileOutputStream,
            "Sample way of creating Properties file from Java program");
  
        fileOutputStream.close();
    }
}

Producción:

Si revisamos la salida de XML, tiene la misma apertura y cierre de entradas.

El creado a través de programas Java también tiene la misma estructura. Ha comenzado a tener con <properties> y termina con </properties>. Aparte de los conjuntos de pares clave-valor, el texto se trata como comentarios y, por lo tanto, están dentro de las etiquetas de comentarios. Los archivos de propiedades solo tienen valores clave y aquí también se declara dentro de las etiquetas de «entrada» junto con «clave =», lo que significa que se proporcionan entradas separadas para cada par clave-valor.

Siempre que el contenido del archivo de propiedades sea enorme y tenga información confidencial como transacciones bancarias, datos financieros, etc., es mejor ir solo en formato XML. 

Una forma conveniente de convertir contenido XML a modo de texto de solo lectura

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.InvalidPropertiesFormatException;
import java.util.Properties;
  
public class ConvertXMLToTextOrientedProperties {
    public static void main(String[] args)
        throws InvalidPropertiesFormatException, IOException
    {
        String outputPropertiesFile
            = "sampleapplication.properties";
        String inputXmlFile
            = "sampleapplicationProperties.xml";
  
        // Input XML File which contains
        // necessary information
        InputStream inputStream
            = new FileInputStream(inputXmlFile);
  
        // Output properties File
        OutputStream outputStream
            = new FileOutputStream(outputPropertiesFile);
  
        Properties properties = new Properties();
  
        // Load XML file that has necessary information
        properties.loadFromXML(inputStream);
  
        // Store to properties file via this way
        properties.store(
            outputStream,
            "Converted from sampleapplicationProperties.xml");
  
        // For sample testing let us get username--It is
        // nothing but "Geek"
  
        // As it is converted to .properties file,
        // we can get the values in this way
        System.out.println(properties.get("username"));
    }
}

Archivo de entrada (sampleapplicationProperties.xml)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>Elegant way of converting sampleapplicationProperties.xml 
  to Sampleapplication.properties</comment>
<entry key="username">Geek</entry>
  <entry key="password">XXXXWeldoneXXXX</entry>
</properties>

Archivo de salida generado (sampleapplication.properties)

Y también como tenemos, System.out.println(properties.get(“username”)); , muestra

«Geek» como salida. Por lo tanto, loadFromXML() ayuda a cargar el archivo XML y lo convierte en un archivo de propiedades orientado a texto por medio de store() y también, una vez convertido, podemos obtener los valores de propiedad fácilmente.

Conclusión :

En este artículo, hemos visto las formas de creación de archivos de propiedades desde programas java. Disfrútalos a tu conveniencia. Son útiles en cualquier parte del proyecto de software, ya que los archivos de propiedades son archivos clave que contienen información confidencial y también como están en pares clave-valor, ya sea como texto o formato XML, se ve el uso dinámico y, en cualquier momento, podemos puede modificarlos fácilmente también.