Come eseguire l'escape del segno di uguale nei file delle proprietà

Come posso sfuggire al segno di uguale ( =) nei file delle proprietà Java? Vorrei inserire qualcosa come il seguente nel mio file:

table.whereclause=where id=100

Inoltre, fare riferimento al metodo di caricamento (Reader Reader) dalla Propertyclasse su javadoc

Nella load(Reader reader)documentazione del metodo si dice

La chiave contiene tutti i caratteri nella riga che iniziano con il primo carattere di spazio non vuoto e fino al primo carattere di spazio vuoto o senza caratteri di escape '=', ma non incluso, ':'diverso da un terminatore di riga. Tutti questi caratteri di terminazione chiave possono essere inclusi nella chiave facendo l'escape con un carattere barra rovesciata precedente; per esempio,

\:\=

sarebbe la chiave di due caratteri ":=". I caratteri del terminatore di riga possono essere inclusi utilizzando \red \nescono sequenze. Qualsiasi spazio bianco dopo che la chiave è stata ignorata; se il primo carattere di spazio non vuoto dopo la chiave è '=' o ':', viene ignorato e anche qualsiasi carattere di spazio vuoto dopo di esso viene saltato. Tutti i caratteri rimanenti sulla riga diventano parte della stringa dell'elemento associato; se non ci sono caratteri rimanenti, l'elemento è la stringa vuota "". Una volta identificate le sequenze di caratteri grezzi che costituiscono la chiave e l'elemento, l'elaborazione dell'escape viene eseguita come descritto sopra.

Spero possa aiutare.

Nel tuo esempio specifico non è necessario eseguire l'escape degli uguali: devi solo eseguire l'escape se fa parte della chiave. Il formato del file delle proprietà tratterà tutti i caratteri dopo il primo uguale senza caratteri di escape come parte del valore.

Il carattere di escape predefinito in Java è "\".
Tuttavia, il file delle proprietà Java ha il formato chiave = valore, dovrebbe considerare tutto ciò che è dopo il primo uguale come valore.

Il modo migliore per evitare questo tipo di problemi è creare proprietà a livello di codice e quindi archiviarle. Ad esempio, utilizzando un codice come questo:

java.util.Properties props = new java.util.Properties();
props.setProperty("table.whereclause", "where id=100");
props.store(System.out, null);

Questo restituirà a System.out la versione con escape corretto.

Nel mio caso l'output era:

#Mon Aug 12 13:50:56 EEST 2013
table.whereclause=where id\=100

Come puoi vedere, questo è un modo semplice per generare contenuto di file .properties che è garantito per essere corretto. E puoi mettere tutte le proprietà che vuoi.

Nel mio caso, due "\\" iniziali funzionano bene per me.

Ad esempio: se la tua parola contiene il carattere "#" (ad esempio aa # 100, puoi eseguire l'escape con due "\\" iniziali

   key= aa\\#100

Puoi guardare qui La chiave in una proprietà Java può includere un carattere vuoto?

per escape uguale a '=' \ u003d

table.whereclause = dove id = 100

chiave: [table.whereclause] valore: [where id = 100]

table.whereclause \ u003dwhere id = 100

chiave: [table.whereclause = where] valore: [id = 100]

table.whereclause \ u003dwhere \ u0020id \ u003d100

chiave: [table.whereclause = where id = 100] valore: []

In Spring o Spring avviare il file application.properties qui è il modo per sfuggire ai caratteri speciali;

table.whereclause = dove id '\ =' 100

Questo metodo dovrebbe aiutare a generare a livello di codice valori garantiti per essere compatibili al 100% con i .propertiesfile:

public static String escapePropertyValue(final String value) {
    if (value == null) {
        return null;
    }

    try (final StringWriter writer = new StringWriter()) {
        final Properties properties = new Properties();
        properties.put("escaped", value);
        properties.store(writer, null);
        writer.flush();

        final String stringifiedProperties = writer.toString();
        final Pattern pattern = Pattern.compile("(.*?)escaped=(.*?)" + Pattern.quote(System.lineSeparator()) + "*");
        final Matcher matcher = pattern.matcher(stringifiedProperties);

        if (matcher.find() && matcher.groupCount() <= 2) {
            return matcher.group(matcher.groupCount());
        }

        // This should never happen unless the internal implementation of Properties::store changed
        throw new IllegalStateException("Could not escape property value");
    } catch (final IOException ex) {
        // This should never happen. IOException is only because the interface demands it
        throw new IllegalStateException("Could not escape property value", ex);
    }
}

Puoi chiamarlo così:

final String escapedPath = escapePropertyValue("C:\\Users\\X");
writeToFile(escapedPath); // will pass "C\\:\\\\Users\\\\X"

Questo metodo è un po 'costoso, ma la scrittura di proprietà su un file è comunque un'operazione sporadica.

Sono stato in grado di inserire valori all'interno del carattere ":

db_user="postgresql"
db_passwd="this,is,my,password"