java - relativa - ¿Cómo sobrescribir una propiedad en.properties sin sobrescribir todo el archivo?

manejo de archivos properties en java

Question

Básicamente, tengo que sobrescribir una determinada propiedad en un archivo .properties a través de una aplicación Java, pero cuando uso Properties.setProperty () y Properties.Store () sobrescribe el archivo completo en lugar de solo esa propiedad.

Intenté construir FileOutputStream con append = true, pero con eso agrega otra propiedad y no elimina / sobrescribe la propiedad existente.

¿Cómo puedo codificarlo para que el establecimiento de una propiedad sobrescriba esa propiedad específica, sin sobrescribir el archivo completo?

Editar: intenté leer el archivo y agregarlo. Aquí está mi código actualizado:

FileOutputStream out = new FileOutputStream("file.properties");
FileInputStream in = new FileInputStream("file.properties");
Properties props = new Properties();
props.load(in);
in.close();
props.setProperty("somekey", "somevalue");
props.store(out, null);
out.close();

Answer 1

Los archivos de propiedades son una manera fácil de proporcionar configuración para una aplicación, pero no necesariamente una buena forma de personalizar programáticamente el usuario específico por la razón que ha encontrado.

Para eso, usaría la API de Preferencias .

Answer 2

Otra respuesta me recordó la biblioteca de configuración de Apache Commons , específicamente las capacidades PropertiesConfigurationLayout .

Esto permite (más o menos) conservar el diseño original, los comentarios, el orden, etc.

Answer 3

import java.io.*;
import java.util.*;
class WritePropertiesFile
{
public static void main(String[] args) {
try {
Properties p = new Properties();
p.setProperty("1", "one");
p.setProperty("2", "two");
p.setProperty("3", "three");
File file = new File("task.properties");
FileOutputStream fOut = new FileOutputStream(file);
p.store(fOut, "Favorite Things");
fOut.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

Answer 4

public class PropertiesXMLExample {
public static void main(String[] args) throws IOException {
// get properties object
Properties props = new Properties();
// get path of the file that you want
String filepath = System.getProperty("user.home")
+ System.getProperty("file.separator") +"email-configuration.xml";
// get file object
File file = new File(filepath);
// check whether the file exists
if (file.exists()) {
// get inpustream of the file
InputStream is = new FileInputStream(filepath);
// load the xml file into properties format
props.loadFromXML(is);
// store all the property keys in a set
Set<String> names = props.stringPropertyNames();
// iterate over all the property names
for (Iterator<String> i = names.iterator(); i.hasNext();) {
// store each propertyname that you get
String propname = i.next();
// set all the properties (since these properties are not automatically stored when you update the file). All these properties will be rewritten. You also set some new value for the property names that you read
props.setProperty(propname, props.getProperty(propname));
}
// add some new properties to the props object
props.setProperty("email.support", "[email protected]");
props.setProperty("email.support_2", "[email protected]");
// get outputstream object to for storing the properties into the same xml file that you read
OutputStream os = new FileOutputStream(
System.getProperty("user.home")
+ "/email-configuration.xml");
// store the properties detail into a pre-defined XML file
props.storeToXML(os, "Support Email", "UTF-8");
// an earlier stored property
String email = props.getProperty("email.support_1");
System.out.println(email);
}
}
}

El resultado del programa sería:

[email protected]

Answer 5

Hago el siguiente método:

1. Lea el archivo y cargue el objeto de propiedades
2. Actualice o agregue nuevas propiedades usando el método ".setProperty". (El método setProperty es mejor que el método .put, ya que se puede usar para insertar y actualizar el objeto de propiedad)
3. Escriba el objeto de propiedad nuevamente en el archivo para mantener el archivo sincronizado con el cambio.

Answer 6

La API de Properties no proporciona ningún método para agregar / reemplazar / eliminar una propiedad en el archivo de propiedades. El modelo que admite la API es cargar todas las propiedades de un archivo, realizar cambios en el objeto Properties en memoria y luego almacenar todas las propiedades en un archivo (el mismo o uno diferente).

Pero la API de Properties no es inusual en el respeto. En realidad, la actualización in situ de un archivo de texto es difícil de implementar sin volver a escribir todo el archivo. Esta dificultad es una consecuencia directa de la forma en que los sistemas de archivos / archivos son implementados por un sistema operativo moderno.

Si realmente necesita hacer actualizaciones incrementales, entonces necesita usar algún tipo de base de datos para contener las propiedades, no un archivo ".properties".

Answer 7

Puede usar PropertiesConfiguration desde Apache Commons Configuration .

En la versión 1.X:

PropertiesConfiguration config = new PropertiesConfiguration("file.properties");
config.setProperty("somekey", "somevalue");
config.save();

De la versión 2.0:

Parameters params = new Parameters();
FileBasedConfigurationBuilder<FileBasedConfiguration> builder =
new FileBasedConfigurationBuilder<FileBasedConfiguration>(PropertiesConfiguration.class)
.configure(params.properties()
.setFileName("file.properties"));
Configuration config = builder.getConfiguration();
config.setProperty("somekey", "somevalue");
builder.save();

Answer 8

Sí, es posible. Si no desea eliminar su contenido del archivo de propiedad. Simplemente lea y reemplace la cadena del archivo.

 String file="D://path of your file/abc.properties";
Path path = Paths.get(file);
Charset charset = StandardCharsets.UTF_8;
String content = new String(Files.readAllBytes(path), charset);
content = content.replaceAll("name=anything", "name=anything1");
Files.write(path, content.getBytes(charset));

El código anterior no eliminará el contenido de su archivo. Simplemente reemplaza la parte del contenido del archivo.