Leer archivo de propiedades fuera del archivo JAR

Question

Tengo un archivo JAR donde todo mi código está archivado para ejecutarse. Tengo que acceder a un archivo de propiedades que debe modificarse/editarse antes de cada ejecución. Quiero mantener el archivo de propiedades en el mismo directorio donde está el archivo JAR. ¿Hay alguna forma de decirle a Java que recoja el archivo de propiedades de ese directorio?

Nota: No quiero mantener el archivo de propiedades en el directorio de inicio ni pasar la ruta del archivo de propiedades en el argumento de línea de comando.

Answer 1

Por lo tanto, usted quiere tratar su archivo .properties en la misma carpeta que el principal jar/ejecutable como un archivo en lugar de como un recurso de la jar principal/ejecutable. En ese caso, mi propia solución es la siguiente:

Primero lo primero: la arquitectura de archivo de programa será así (asumiendo que su programa principal es main.jar y presentar sus principales propiedades es main.properties):

./ - the root of your program 
|__ main.jar 
|__ main.properties 

Con esta arquitectura, puede modificar cualquier propiedad en el archivo main.properties usando cualquier editor de texto antes o mientras su main.jar se esté ejecutando (dependiendo del estado actual del programa) ya que solo está basado en texto archivo. Por ejemplo, el archivo puede contener main.properties:

app.version=1.0.0.0 
app.name=Hello 

Por lo tanto, cuando se ejecuta el programa principal de su carpeta raíz/base, normalmente se corre así:

java -jar ./main.jar 

o, enseguida:

java -jar main.jar 

en su main.jar, es necesario crear unos métodos de utilidad para todos los bienes que se encuentren en el archivo de main.properties; Digamos que la propiedad app.version tendrá getAppVersion() método de la siguiente manera:

/** 
* 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; 
} 

En cualquier parte del programa principal que necesita el valor app.version, llamamos a su método de la siguiente manera:

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

Answer 2

Siempre hay un problema al acceder a los archivos en su directorio de archivos desde un archivo jar. Proporcionar el classpath en un archivo jar es muy limitado. En su lugar, intente utilizar un archivo bat o un archivo sh para iniciar su programa. De esta forma, puede especificar su ruta de clases de todas formas, haciendo referencia a cualquier carpeta en cualquier lugar del sistema.

También puedes ver mi respuesta a esta pregunta:

making .exe file for java project containing sqlite

Answer 3

lo hice por Otra manera.

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. obtener la ruta de archivo Jar.
2. Obtiene la carpeta principal de ese archivo.
3. Use esa ruta en InputStreamPath con su nombre de archivo de propiedades.

Answer 4

Tengo un caso similar: quiero que mi archivo *.jar acceda a un archivo en un directorio al lado de dicho archivo *.jar.Consulte también THIS ANSWER.

Mi estructura de archivos es:

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

soy capaz de cargar un archivo (por ejemplo, some.txt) a un InputStream dentro del archivo *.jar con lo siguiente:

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()); 
    } 

Luego hacer lo lo harás con el stream