Ler arquivo de propriedades fora do arquivo JAR

Eu tenho um arquivo JAR no qual todo o meu código está arquivado para execução. Eu tenho que acessar um arquivo de propriedades que precisa ser alterado / editado antes de cada execução. Eu quero manter o arquivo de propriedades no mesmo diretório em que o arquivo JAR está. Existe alguma maneira de dizer ao Java para pegar o arquivo de propriedades desse diretório?

Nota: Não quero manter o arquivo de propriedades no diretório inicial nem passar o caminho do arquivo de propriedades no argumento da linha de comandos.

Portanto, você deseja tratar seu .propertiesarquivo na mesma pasta que o jar principal / executável como um arquivo, e não como um recurso do jar principal / executável. Nesse caso, minha própria solução é a seguinte:

Primeiro, a arquitetura do arquivo do programa deve ser assim (assumindo que o programa principal seja main.jar e seu arquivo de propriedades principal seja main.properties):

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

Com essa arquitetura, você pode modificar qualquer propriedade no arquivo main.properties usando qualquer editor de texto antes ou enquanto o main.jar estiver em execução (dependendo do estado atual do programa), pois é apenas um arquivo baseado em texto. Por exemplo, seu arquivo main.properties pode conter:

app.version=1.0.0.0
app.name=Hello

Portanto, quando você executa o programa principal a partir da pasta raiz / base, normalmente o executa da seguinte maneira:

java -jar ./main.jar

ou imediatamente:

java -jar main.jar

No seu main.jar, você precisa criar alguns métodos utilitários para todas as propriedades encontradas no seu arquivo main.properties; vamos dizer que a app.versionpropriedade terá o getAppVersion()método da seguinte maneira:

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

Em qualquer parte do programa principal que precise do app.versionvalor, chamamos seu método da seguinte maneira:

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

Eu fiz de outra maneira.

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. Obtenha o caminho do arquivo Jar.
2. Obtenha a pasta pai desse arquivo.
3. Use esse caminho no InputStreamPath com o nome do arquivo de propriedades.

Sempre há um problema ao acessar arquivos no diretório de arquivos a partir de um arquivo jar. Fornecer o caminho de classe em um arquivo jar é muito limitado. Em vez disso, tente usar um arquivo bat ou um arquivo sh para iniciar seu programa. Dessa forma, você pode especificar seu caminho de classe da maneira que desejar, fazendo referência a qualquer pasta em qualquer lugar do sistema.

Verifique também minha resposta sobre esta pergunta:

criando arquivo .exe para projeto java contendo sqlite

Eu tenho um caso semelhante: querer que meu *.jararquivo acesse um arquivo em um diretório próximo ao *.jararquivo. Consulte ESTA RESPOSTA também.

Minha estrutura de arquivos é:

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

Consigo carregar um arquivo (digamos some.txt) para um InputStream dentro do *.jararquivo com o seguinte:

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

Então faça o que quiser com o stream

Eu tenho um exemplo de fazer tanto por caminho de classe ou de configuração externa com log4j2.properties

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

Isso funciona para mim. Carregue seu arquivo de propriedades decurrent directory

Properties properties = new Properties();
properties.load(new FileReader(new File(".").getCanonicalPath() + File.separator + "java.properties"));
properties.forEach((k, v) -> {
            System.out.println(k + " : " + v);
        });

Certifique-se de que java.propertiesestá no current directory. Você pode escrever um pequeno script de inicialização que muda para o diretório certo antes, como

#! /bin/bash
scriptdir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" 
cd $scriptdir
java -jar MyExecutable.jar
cd -

No seu projeto, basta colocar o java.propertiesarquivo na raiz do projeto, para que esse código funcione também no seu IDE.

Aqui, se você mencionar .getPath(), isso retornará o caminho do Jar e acho que você precisará do pai para se referir a todos os outros arquivos de configuração colocados no jar. Este código funciona no Windows. Adicione o código na classe principal.

File jarDir = new File(MyAppName.class.getProtectionDomain().getCodeSource().getLocation().getPath());
String jarDirpath = jarDir.getParent();

System.out.println(jarDirpath);