Lendo o arquivo de propriedades em Java

Eu tenho o seguinte código tentando ler um arquivo de propriedades:

Properties prop = new Properties();
ClassLoader loader = Thread.currentThread().getContextClassLoader();           
InputStream stream = loader.getResourceAsStream("myProp.properties");
prop.load(stream);

Recebo uma exceção na última linha. Especificamente:

Exception in thread "main" java.lang.NullPointerException
at java.util.Properties$LineReader.readLine(Properties.java:418)
at java.util.Properties.load0(Properties.java:337)
at java.util.Properties.load(Properties.java:325)
at Assignment1.BaseStation.readPropertyFile(BaseStation.java:46)
at Assignment1.BaseStation.main(BaseStation.java:87)

obrigado Nikos

Com base em sua exceção, o InputStreamé nulo, isso significa que o carregador de classes não está localizando seu arquivo de propriedades. Suponho que myProp.properties está na raiz do seu projeto, se for esse o caso, você precisa de uma barra anterior:

InputStream stream = loader.getResourceAsStream("/myProp.properties");

Você pode encontrar informações nesta página:
http://www.mkyong.com/java/java-properties-file-examples/

Properties prop = new Properties();
try {
    //load a properties file from class path, inside static method
    prop.load(App.class.getClassLoader().getResourceAsStream("config.properties"));

    //get the property value and print it out
    System.out.println(prop.getProperty("database"));
    System.out.println(prop.getProperty("dbuser"));
    System.out.println(prop.getProperty("dbpassword"));

} 
catch (IOException ex) {
    ex.printStackTrace();
}

Você pode usar a ResourceBundleclasse para ler o arquivo de propriedades.

ResourceBundle rb = ResourceBundle.getBundle("myProp.properties");

Properties prop = new Properties();

try {
    prop.load(new FileInputStream("conf/filename.properties"));
} catch (IOException e) {
    e.printStackTrace();
}

conf/filename.properties base no diretório raiz do projeto

Você não pode usar essa palavra - chave como -

props.load(this.getClass().getResourceAsStream("myProps.properties"));

em um contexto estático.

A melhor coisa seria controlar o contexto do aplicativo como -

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:/META-INF/spring/app-context.xml");

então você pode carregar o arquivo de recursos do classpath -

//load a properties file from class path, inside static method
        prop.load(context.getClassLoader().getResourceAsStream("config.properties"));

Isso funcionará para contextos estáticos e não estáticos e a melhor parte é que esse arquivo de propriedades pode estar em qualquer pacote / pasta incluído no classpath do aplicativo.

Seu arquivo deve estar disponível como com/example/foo/myProps.propertiesno classpath. Em seguida, carregue-o como:

props.load(this.getClass().getResourceAsStream("myProps.properties"));

se o seu config.properties não está no diretório src / main / resource e está no diretório raiz do projeto, você precisa fazer algo como abaixo: -

Properties prop = new Properties();          
File configFile = new File(myProp.properties);
InputStream stream = new FileInputStream(configFile);
prop.load(stream);

Certifique-se de que o nome do arquivo esteja correto e que o arquivo esteja realmente no caminho da classe. getResourceAsStream()retornará null se este não for o caso que faz com que a última linha lance a exceção.

Se myProp.properties estiver no diretório raiz do seu projeto, use /myProp.properties.

Você pode usar java.io.InputStream para ler o arquivo conforme mostrado abaixo:

InputStream inputStream = getClass().getClassLoader().getResourceAsStream(myProps.properties); 

Dado o contexto loader.getResourceAsStream("myPackage/myProp.properties")deve ser usado.

Liderar '/'não funciona com ClassLoader.getResourceAsStream(String)método.

Como alternativa, você pode usar o Class.getResourceAsStream(String)método, que usa '/'para determinar se o caminho é absoluto ou relativo ao local da classe.

Exemplos:

myClass.class.getResourceAsStream("myProp.properties")
myClass.class.getResourceAsStream("/myPackage/myProp.properties")

Se o caminho do arquivo de propriedades e o caminho da classe java forem iguais, você deve fazer isso.

Por exemplo:

src / myPackage / MyClass.java

src / myPackage / MyFile.properties

Properties prop = new Properties();
InputStream stream = MyClass.class.getResourceAsStream("MyFile.properties");
prop.load(stream);

Nenhuma das respostas atuais mostra que InputStreamestá sendo fechado (isso vazará um descritor de arquivo) e / ou não trata do .getResourceAsStream()retorno de null quando o recurso não é encontrado (isso levará a um NullPointerExceptioncom a mensagem confusa, "inStream parameter is null"). Você precisa de algo como o seguinte:

String propertiesFilename = "server.properties";
Properties prop = new Properties();
try (var inputStream = getClass().getClassLoader().getResourceAsStream(propertiesFilename)) {
    if (inputStream == null) {
        throw new FileNotFoundException(propertiesFilename);
    }
    prop.load(inputStream);
} catch (IOException e) {
    throw new RuntimeException(
                "Could not read " + propertiesFilename + " resource file: " + e);
}

Para o arquivo de propriedades de leitura com sua ordem original:

    File file = new File("../config/edc.properties");
    PropertiesConfiguration config = new PropertiesConfiguration();
    PropertiesConfigurationLayout layout = new PropertiesConfigurationLayout(config);
    layout.load(new InputStreamReader(new FileInputStream(file)));

    for(Object propKey : layout.getKeys()){
        PropertiesConfiguration propval =  layout.getConfiguration();
        String value = propval.getProperty((String) propKey).toString();
        out.print("Current Key:" + propkey + "Current Value:" + propval + "<br>");
    }

Muitas respostas aqui descrevem métodos perigosos em que instanciam um fluxo de entrada de arquivo, mas não obtêm uma referência ao fluxo de entrada para fechar o fluxo posteriormente. Isso resulta em fluxos de entrada pendentes e vazamentos de memória. A maneira correta de carregar as propriedades deve ser semelhante a seguinte:

    Properties prop = new Properties();
    try(InputStream fis = new FileInputStream("myProp.properties")) {
        prop.load(fis);
    }
    catch(Exception e) {
        System.out.println("Unable to find the specified properties file");
        e.printStackTrace();
        return;
    }

Observe a instanciação do fluxo de entrada do arquivo em try-with-resourcesbloco. Uma vez FileInputStreamque a pode ser fechada automaticamente, ela será fechada automaticamente depois que o try-with-resourcesbloco for encerrado. Se você quiser usar um trybloco simples , deve fechá-lo explicitamente usando fis.close();no finallybloco.

Vejo que a pergunta é antiga. Se alguém topar com isso no futuro, acho que esta é uma maneira simples de fazer isso. Mantenha o arquivo de propriedades na pasta do projeto.

        FileReader reader = new FileReader("Config.properties");

        Properties prop = new Properties();
        prop.load(reader);

Especifique o caminho começando com src conforme abaixo:

src/main/resources/myprop.proper