[PGI-Bis]

Con ogni probabilità il secondo file config.xml lo crei quando vai ad aggiornare le proprietà contenute nel file config.xml.

E' un po' curiosa come faccenda perchè in genere uno sa con certezza quali file crea la sua applicazione e dove li crea .

Nota che se un programma non funziona quando è impacchettato in un Jar allora il suo funzionamento in versione non-jar è meramente accidentale nel senso che dipende dal valore di una variabile di sistema - che in quanto variabile varia da "evviva" a "braghe di tela".

Ciò premesso, puoi scrivere nel jar eliminando il vecchio e sostituendolo con un jar nuovo - in cui il vecchio file config.xml risulti sovrascritto.

Puoi scrivere il tuo file config.xml in una delle cartelle predefinite del sistema operativo dedicata ai file delle applicazioni: tieni quello che hai nel jar come base e lo carichi solo se manchi quell'altro.

Puoi scrivere il tuo file config.xml nella cartella in cui si trova il jar.

Personalmente uso l'ultima opzione, con questo strumento:

package it.tukano.datacoat;

import java.net.*;
import java.io.*;

/** Determina il percorso di base del programma. Il percorso di base è la
 cartella in cui si trova il file .jar che contiene questa classe o la radice
 del package a cui appartiene questa classe. */
class PathFinder {
    private static final PathFinder instance = new PathFinder();

    /** Restituisce un'istanza condivisa di PathFinder. */
    public static final PathFinder getInstance() {
        return instance;
    }

    private final String BASE_PATH;

    /** Costruisce un PathFinder inizializzando il percorso di base */
    public PathFinder() {
        BASE_PATH = computeBasePath();
    }

    /** Restituisce il percorso di base del programma. */
    public String getBasePath() {
        return BASE_PATH;
    }

    /** Restituisce un file il cui percorso è relativo alla cartella di base del
     programma. */
    public File getRelativeFile(String relativeName) {
        return new File(BASE_PATH + File.separator + relativeName);
    }

    /** Computa il percorso della cartella di base del programma. */
    private String computeBasePath() {
        Class<?> thisClass = PathFinder.class;
        String name = thisClass.getSimpleName() + ".class";
        String classPath = thisClass.getResource(name).toString();
        String fullName = thisClass.getCanonicalName().replace('.', '/');
        classPath = classPath.substring(0, classPath.indexOf(fullName));
        try {
            classPath = URLDecoder.decode(classPath, "utf-8");
        } catch(UnsupportedEncodingException ex) {
            throw new InternalError("utf-8 unsupported?"); //utf-8 deve essere supportato
        }
        if(classPath.startsWith("jar")) {
            return parseJarPath(classPath);
        } else if(classPath.startsWith("file")) {
            return parseFilePath(classPath);
        } else {
            return null;
        }
    }

    private String parseFilePath(String path) {
        path = path.substring("file:/".length(), path.length());
        if(path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }
        path = path.replace('/', File.separatorChar);
        return path;
    }

    private String parseJarPath(String path) {
        path = path.substring("jar:file:/".length(), path.length());
        int exIndex = path.lastIndexOf('!');
        path = path.substring(0, exIndex);
        int slashIndex = path.lastIndexOf('/');
        path = path.substring(0, slashIndex);
        path = path.replace('/', File.separatorChar);
        return path;
    }
}

Quando mi serve il percorso di un file relativo alla posizione del programma nel filesystem ospite, dico:

File file = PathFinder.getInstance().getRelativeFile("config.xml");

e "file" risulterà essere un file nella cartella in cui si trova il jar, a prescindere da qualsiasi variabile d'ambiente.


L'approccio standard è tuttavia quello di usare cartelle di sistema, tipo "application data" o quel che è.