141 votes

Lire le fichier de propriétés en dehors du fichier JAR

J'ai un fichier JAR où tout mon code est archivé pour être exécuté. Je dois accéder à un fichier de propriétés qui doit être changé/édité avant chaque exécution. Je veux garder le fichier de propriétés dans le même répertoire que le fichier JAR. Existe-t-il un moyen de dire à Java d'aller chercher le fichier de propriétés dans ce répertoire ?

Note : Je ne veux pas garder le fichier de propriétés dans le répertoire personnel ou passer le chemin du fichier de propriétés dans l'argument de ligne de commande.

3 votes

Ver cette réponse - "Au lieu de cela, stockez le fichier 'default' dans le Jar. S'il est modifié, stockez le fichier modifié à un autre endroit. Un endroit courant est un sous-répertoire de user.home . Lors de la vérification du fichier, il faut d'abord vérifier l'existence d'un fichier modifié sur le système de fichiers, et s'il n'existe pas, charger le fichier par défaut." BTW "Je ne veux pas.." Ce que vous voulez est moins important que ce qui fonctionne et est pratique. Le stockage des paramètres de l'application dans le répertoire de l'application est fortement déconseillé par Oracle et MS (et probablement par d'autres).

5 votes

La raison pour laquelle j'ai besoin de conserver le fichier de propriétés dans le répertoire jar est qu'il est préférable de les conserver ensemble lorsque le répertoire entier (y compris jar et property) est copié sur une autre machine et exécuté.

1 votes

Et si j'oblige l'utilisateur à transmettre le chemin d'accès au fichier de propriétés, il doit le modifier chaque fois qu'il exécute le fichier batch à partir d'une autre machine.

157voto

eee Points 1832

Donc, vous voulez traiter votre .properties dans le même dossier que le jar main/runnable comme un fichier plutôt que comme une ressource du jar main/runnable. Dans ce cas, ma propre solution est la suivante :

Tout d'abord, l'architecture des fichiers de votre programme doit être la suivante (en supposant que votre programme principal est main.jar et que son fichier de propriétés principal est main.properties) :

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

Avec cette architecture, vous pouvez modifier n'importe quelle propriété du fichier main.properties en utilisant n'importe quel éditeur de texte avant ou pendant l'exécution de votre main.jar (selon l'état actuel du programme) puisqu'il s'agit simplement d'un fichier texte. Par exemple, votre fichier main.properties peut contenir :

app.version=1.0.0.0
app.name=Hello

Ainsi, lorsque vous exécutez votre programme principal à partir de son dossier Root/base, vous le lancerez normalement comme ceci :

java -jar ./main.jar

ou, tout de suite :

java -jar main.jar

Dans votre main.jar, vous devez créer quelques méthodes utilitaires pour chaque propriété trouvée dans votre fichier main.properties ; disons que la méthode app.version La propriété aura getAppVersion() comme suit :

/**
 * Gets the app.version property value from
 * the ./main.properties file of the base folder
 *
 * @return app.version string
 * @throws IOException
 */

import java.util.Properties;

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

Dans toute partie du programme principal qui a besoin de l'option app.version nous appelons sa méthode comme suit :

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

9 votes

Cette solution fonctionne. J'ai vérifié que le fichier de propriétés n'est pas à l'intérieur du fichier jar mais il peut quand même accéder au fichier à partir du même répertoire où se trouve le fichier jar. De cette façon, il n'y a pas besoin d'un code dur de chemin absolu. Les deux fichiers jar et properties peuvent maintenant être copiés dans n'importe quel répertoire et être exécutés indépendamment.

5 votes

Le fichier ne sera pas trouvé si vous exécutez la commande depuis l'extérieur, par exemple : {{java -jar build/main.jar}}. Avez-vous une solution pour cela, @eee ?

1 votes

Darian Il n'y a rien à corriger ici ; cela ne fonctionne que comme prévu où le jar et le fichier de propriétés doivent être sur le même disque dur. ./ Dossier racine (même niveau de répertoire) selon ce que j'ai décrit dans l'architecture d'organisation des fichiers. (selon les exigences définies par le posteur d'origine)

48voto

Ninad Pingale Points 2191

Je l'ai fait d'une autre manière.

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. Obtenir le chemin du fichier Jar.
  2. Obtenez le dossier parent de ce fichier.
  3. Utilisez ce chemin dans InputStreamPath avec le nom de votre fichier de propriétés.

0 votes

J'ai dû laisser tomber la partie getParentFile() et j'ai donc utilisé à la place : String propertiesPath=jarPath.getAbsolutePath() ; mais tout dépend de l'emplacement du fichier.

4 votes

Remplacez simplement "jarPath.getParentFile().getAbsolutePath() ;" par "jarPath.getParent()". Cela fonctionne comme un charme.

1 votes

C'est le même problème dans mon cas, mais j'ai un projet de base Spring. Comment dire à Spring que le fichier est à côté du fichier jar ? une idée ?

3voto

sethu Points 1978

Il y a toujours un problème pour accéder aux fichiers de votre répertoire de fichiers à partir d'un fichier jar. Fournir le classpath dans un fichier jar est très limité. Essayez plutôt d'utiliser un fichier bat ou un fichier sh pour démarrer votre programme. De cette façon, vous pouvez spécifier votre classpath comme vous le souhaitez, en faisant référence à n'importe quel dossier n'importe où sur le système.

Consultez également ma réponse à cette question :

création d'un fichier .exe pour un projet java contenant sqlite

2voto

ddaaggeett Points 45

J'ai un cas similaire : je veux que mon *.jar pour accéder à un fichier dans un répertoire situé à côté du dit fichier *.jar fichier. Se référer à CETTE RÉPONSE également.

La structure de mes fichiers est la suivante :

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

Je suis capable de charger un fichier (disons, some.txt ) vers un InputStream à l'intérieur du *.jar avec ce qui suit :

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

Ensuite, faites ce que vous voulez avec le stream

0voto

Spencer Kormos Points 3082

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X