Lettura del file delle proprietà in Java

Ho il seguente codice cercando di leggere un file delle proprietà:

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

Ottengo un'eccezione nell'ultima riga. In particolare:

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)

grazie, Nikos

In base alla tua eccezione, InputStreamè null, significa che il programma di caricamento classi non trova il tuo file delle proprietà. Immagino che myProp.properties sia nella radice del tuo progetto, in tal caso, hai bisogno di una barra precedente:

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

Puoi trovare informazioni su questa pagina:
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();
}

È possibile utilizzare ResourceBundleclass per leggere il file delle proprietà.

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 sulla directory radice del progetto

Non puoi utilizzare questa parola chiave come:

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

in un contesto statico.

La cosa migliore sarebbe entrare in possesso del contesto dell'applicazione come:

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

quindi puoi caricare il file di risorse dal classpath -

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

Funzionerà sia per il contesto statico che non statico e la parte migliore è che questo file delle proprietà può essere in qualsiasi pacchetto / cartella inclusa nel percorso di classe dell'applicazione.

Il tuo file dovrebbe essere disponibile come com/example/foo/myProps.propertiesin classpath. Quindi caricalo come:

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

se il tuo config.properties non è nella directory src / main / resource ed è nella directory root del progetto, allora devi fare qualcosa come di seguito: -

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

Assicurati che il nome del file sia corretto e che il file sia effettivamente nel percorso della classe. getResourceAsStream()restituirà null se questo non è il caso che fa sì che l'ultima riga generi l'eccezione.

Se myProp.properties si trova nella directory principale del progetto, utilizza /myProp.propertiesinvece.

È possibile utilizzare java.io.InputStream per leggere il file come mostrato di seguito:

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

Dato il contesto loader.getResourceAsStream("myPackage/myProp.properties")dovrebbe essere utilizzato.

La leadership '/'non funziona con il ClassLoader.getResourceAsStream(String)metodo.

In alternativa è possibile utilizzare il Class.getResourceAsStream(String)metodo, che utilizza '/'per determinare se il percorso è assoluto o relativo alla posizione della classe.

Esempi:

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

Se il percorso del file delle proprietà e il percorso della classe java sono gli stessi, dovresti farlo.

Per esempio:

src / pacchetto / MyClass.java

src / mypackage / MyFile.properties

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

Nessuna delle risposte correnti mostra la InputStreamchiusura (questo farà perdere un descrittore di file) e / o non si occuperà della .getResourceAsStream()restituzione di null quando la risorsa non viene trovata (questo porterà a un NullPointerExceptionmessaggio confuso, "inStream parameter is null"). Hai bisogno di qualcosa come il seguente:

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

Per il file delle proprietà di lettura con il suo ordine originale:

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

Molte risposte qui descrivono metodi pericolosi in cui istanziano un flusso di input di file ma non ottengono un riferimento al flusso di input per chiudere il flusso in un secondo momento. Ciò si traduce in flussi di input penzolanti e perdite di memoria. Il modo corretto di caricare le proprietà dovrebbe essere simile al seguente:

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

Notare la creazione di istanze del flusso di input del file in try-with-resourcesblocco. Poiché a FileInputStreamè chiudibile automaticamente, verrà chiuso automaticamente dopo l' try-with-resourcesuscita dal blocco. Se vuoi usare un tryblocco semplice , devi chiuderlo esplicitamente usando fis.close();nel finallyblocco.

Vedo che la domanda è vecchia. Se qualcuno si imbatte in questo in futuro, penso che questo sia un modo semplice per farlo. Conserva il file delle proprietà nella cartella del progetto.

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

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

Specificare il percorso a partire da src come di seguito:

src/main/resources/myprop.proper