Lire le fichier de propriétés à l'extérieur du fichier JAR

j'ai un fichier JAR où tout mon code est archivé pour l'exécution. Je dois accéder à un fichier de propriétés qui doit être modifié avant chaque exécution. Je veux garder le fichier de propriétés dans le même répertoire que le fichier JAR. Y a-t-il un moyen de dire à Java de récupérer le fichier de propriétés de ce répertoire ?

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

102
demandé sur informatik01 2012-01-08 08:05:39

5 réponses

ainsi, vous voulez traiter votre fichier .properties sur le même dossier que le jar principal/exécutable comme un fichier plutôt que comme une ressource du jar principal/exécutable. Dans ce cas, ma solution est la suivante:

première chose: votre architecture de fichier de programme doit être comme ceci (en supposant que votre programme principal est principal.jar et son fichier de propriétés principal est main.les propriétés): 

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

avec cette architecture, vous pouvez modifier n'importe quelle propriété principal.fichier de propriétés en utilisant n'importe quel éditeur de texte avant ou pendant votre main.le pot est en cours d'exécution (en fonction de l'état actuel du programme) puisque c'est juste un fichier texte. Par exemple, votre principale.le fichier de propriétés peut contenir: 

app.version=1.0.0.0
app.name=Hello

ainsi, lorsque vous exécutez votre programme principal à partir de son dossier racine/base, normalement vous l'exécuterez comme ceci: 

java -jar ./main.jar

ou, tout de suite: 

java -jar main.jar

dans votre main.jar, toi besoin de créer quelques méthodes d'utilité pour chaque propriété trouvée dans votre main.fichier de propriétés; disons que la propriété app.version aura la méthode getAppVersion() comme suit: 

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

dans toute partie du programme principal qui nécessite la valeur app.version , nous appelons sa méthode comme suit: 

String version = null;
try{
     version = getAppVersion();
}
catch (IOException ioe){
    ioe.printStackTrace();
}
121
répondu ecle 2016-03-10 22:31:54

Je l'ai fait par un autre moyen. 

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. récupérez le dossier Parent de ce fichier.
  3. utilisez ce chemin dans InputStreamPath avec le nom de votre fichier de propriétés.
30
répondu Ninad Pingale 2014-01-15 08:27:26

il y a toujours un problème d'accès 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 référençant n'importe quel dossier n'importe où sur le système.

vérifiez aussi ma réponse à cette question:

.fichier exe pour le projet java contenant sqlite

1
répondu sethu 2017-05-23 12:34:36

j'ai un cas similaire: vouloir mon fichier *.jar pour accéder à un fichier dans un répertoire à côté dudit fichier *.jar . Se référer à cette réponse aussi.

ma structure de fichier est: 

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

je suis capable de charger un fichier (disons, some.txt ) à une entrée à l'intérieur du fichier *.jar avec le suivant: 

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

alors faites ce que vous voulez avec le stream

1
répondu ddaaggeett 2017-05-23 12:18:17

j'ai un exemple de faire à la fois par classpath ou de config externe avec log4j2.propriétés 

package org.mmartin.app1;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.LogManager;


public class App1 {
    private static Logger logger=null; 
    private static final String LOG_PROPERTIES_FILE = "config/log4j2.properties";
    private static final String  CONFIG_PROPERTIES_FILE = "config/config.properties";

    private Properties properties= new Properties();

    public App1() {
        System.out.println("--Logger intialized with classpath properties file--");
        intializeLogger1();
        testLogging();
        System.out.println("--Logger intialized with external file--");
        intializeLogger2();
        testLogging();
    }




    public void readProperties()  {
        InputStream input = null;
        try {
            input = new FileInputStream(CONFIG_PROPERTIES_FILE);
            this.properties.load(input);
        } catch (IOException e) {
            logger.error("Unable to read the config.properties file.",e);
            System.exit(1);
        }
    }

    public void printProperties() {
        this.properties.list(System.out);
    }

    public void testLogging() {
        logger.debug("This is a debug message");
        logger.info("This is an info message");
        logger.warn("This is a warn message");
        logger.error("This is an error message");
        logger.fatal("This is a fatal message");
        logger.info("Logger's name: "+logger.getName());
    }


    private void intializeLogger1() {
        logger = LogManager.getLogger(App1.class);
    }
    private void intializeLogger2() {
        LoggerContext context = (org.apache.logging.log4j.core.LoggerContext) LogManager.getContext(false);
        File file = new File(LOG_PROPERTIES_FILE);
        // this will force a reconfiguration
        context.setConfigLocation(file.toURI());
        logger = context.getLogger(App1.class.getName());
    }

    public static void main(String[] args) {
        App1 app1 = new App1();
        app1.readProperties();
        app1.printProperties();
    }
}


--Logger intialized with classpath properties file--
[DEBUG] 2018-08-27 10:35:14.510 [main] App1 - This is a debug message
[INFO ] 2018-08-27 10:35:14.513 [main] App1 - This is an info message
[WARN ] 2018-08-27 10:35:14.513 [main] App1 - This is a warn message
[ERROR] 2018-08-27 10:35:14.513 [main] App1 - This is an error message
[FATAL] 2018-08-27 10:35:14.513 [main] App1 - This is a fatal message
[INFO ] 2018-08-27 10:35:14.514 [main] App1 - Logger's name: org.mmartin.app1.App1
--Logger intialized with external file--
[DEBUG] 2018-08-27 10:35:14.524 [main] App1 - This is a debug message
[INFO ] 2018-08-27 10:35:14.525 [main] App1 - This is an info message
[WARN ] 2018-08-27 10:35:14.525 [main] App1 - This is a warn message
[ERROR] 2018-08-27 10:35:14.525 [main] App1 - This is an error message
[FATAL] 2018-08-27 10:35:14.525 [main] App1 - This is a fatal message
[INFO ] 2018-08-27 10:35:14.525 [main] App1 - Logger's name: org.mmartin.app1.App1
-- listing properties --
dbpassword=password
database=localhost
dbuser=user
0
répondu pitchblack408 2018-08-27 17:39:57