java - relativa - Leer el archivo de propiedades fuera del archivo JAR

leer datos de un properties java

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

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

Answer 2

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

Primero lo primero: su arquitectura de archivo de programa será así (suponiendo que su programa principal es main.jar y su archivo de propiedades principal 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 es solo un archivo de texto. Por ejemplo, su archivo main.properties puede contener:

app.version=1.0.0.0
app.name=Hello

Entonces, cuando ejecuta su programa principal desde su carpeta raíz / base, normalmente lo ejecutará así:

java -jar ./main.jar

o, de inmediato:

java -jar main.jar

En main.jar, necesita crear algunos métodos de utilidad para cada propiedad que se encuentre en su archivo main.properties; supongamos que la propiedad app.version tendrá el método getAppVersion() 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 necesite el valor de la app.version la app.version , llamamos a su método de la siguiente manera:

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

Answer 3

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 verifique mi respuesta sobre esta pregunta:

haciendo el archivo .exe para el proyecto de Java que contiene sqlite

Answer 4

Tengo un caso similar: querer que mi archivo *.jar acceda a un archivo en un directorio al lado de dicho archivo *.jar . Consulte también ESTA RESPUESTA .

Mi estructura de archivos es:

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

Puedo cargar un archivo (digamos, 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 haz lo que quieras con la stream