Lettura file di proprietà all'esterno del file JAR

Question

Ho un file JAR in cui tutto il mio codice è archiviato per l'esecuzione. Devo accedere a un file delle proprietà che deve essere modificato/modificato prima di ogni corsa. Voglio mantenere il file delle proprietà nella stessa directory in cui si trova il file JAR. C'è comunque da dire a Java di prendere il file delle proprietà da quella directory?

Nota: non desidero mantenere il file delle proprietà nella directory principale o passare il percorso del file delle proprietà nell'argomento della riga di comando.

Answer 1

Quindi, si vuole trattare il file .properties sulla stessa cartella del vaso principale/eseguibile come un file piuttosto che come una risorsa della barattolo principale/eseguibile. In tal caso, la mia soluzione è la seguente:

Per prima cosa: l'architettura di file di programma deve essere simile a questo (supponendo che il programma principale è main.jar e il file le sue proprietà principali è main.properties):

Con questa architettura, è possibile modificare qualsiasi proprietà nel file main.properties utilizzando qualsiasi editor di testo prima o mentre il file main.jar è in esecuzione (a seconda dello stato corrente del programma) poiché si tratta solo di un testo file. Ad esempio, il file può contenere main.properties:

app.version=1.0.0.0 
app.name=Hello 

Così, quando si esegue il programma principale dalla sua cartella principale/base, normalmente vi imbatterete in questo modo:

java -jar ./main.jar 

o, subito:

java -jar main.jar 

nella tua main.jar, è necessario creare un paio di metodi di utilità per ogni proprietà trovata in file main.properties; diciamo la proprietà app.version avrà getAppVersion() metodo come segue:

/** 
* Gets the app.version property value from 
* the ./main.properties file of the base folder 
* 
* @return app.version string 
* @throws IOException 
*/ 
public static String getAppVersion() throws IOException{ 

    String versionString = null; 

    //to load application's properties, we use this class 
    Properties mainProperties = new Properties(); 

    FileInputStream file; 

    //the base folder is ./, the root of the main.properties file 
    String path = "./main.properties"; 

    //load the file handle for main.properties 
    file = new FileInputStream(path); 

    //load all the properties from this file 
    mainProperties.load(file); 

    //we have loaded the properties, so close the file handle 
    file.close(); 

    //retrieve the property we are intrested, the app.version 
    versionString = mainProperties.getProperty("app.version"); 

    return versionString; 
} 

In ogni parte del programma principale che ha bisogno il valore app.version, abbiamo chiamare il suo metodo come segue:

String version = null; 
try{ 
    version = getAppVersion(); 
} 
catch (IOException ioe){ 
    ioe.printStackTrace(); 
} 

Answer 2

C'è sempre un problema nell'accedere ai file nella directory dei file da un file jar. Fornire il classpath in un file jar è molto limitato. Prova invece a utilizzare un file bat o un file sh per avviare il programma. In questo modo è possibile specificare il classpath in ogni caso, facendo riferimento a qualsiasi cartella in qualsiasi punto del sistema.

Controllare anche la mia risposta su questa questione:

making .exe file for java project containing sqlite

Answer 3

ho fatto da altro modo.

Properties prop = new Properties(); 
    try { 

     File jarPath=new File(MyClass.class.getProtectionDomain().getCodeSource().getLocation().getPath()); 
     String propertiesPath=jarPath.getParentFile().getAbsolutePath(); 
     System.out.println(" propertiesPath-"+propertiesPath); 
     prop.load(new FileInputStream(propertiesPath+"/importer.properties")); 
    } catch (IOException e1) { 
     e1.printStackTrace(); 
    } 

1. ottenere il percorso del file Jar.
2. Ottieni cartella principale di quel file.
3. Utilizzare quel percorso in InputStreamPath con il nome del file delle proprietà.

Answer 4

Ho un caso simile: volendo il mio file *.jar per accedere a un file in una directory accanto a detto file *.jar.Fare riferimento allo THIS ANSWER.

La mia struttura del file è:

./ - the root of your program 
|__ *.jar 
|__ dir-next-to-jar/some.txt 

sono in grado di caricare un file (ad esempio, some.txt) per un InputStream all'interno del file *.jar con il seguente:

InputStream stream = null; 
    try{ 
     stream = ThisClassName.class.getClass().getResourceAsStream("/dir-next-to-jar/some.txt"); 
    } 
    catch(Exception e) { 
     System.out.print("error file to stream: "); 
     System.out.println(e.getMessage()); 
    } 

Poi fare qualsiasi cosa con il stream