Lectura del archivo de propiedades en Java

Tengo el siguiente código intentando leer un archivo de propiedades:

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

Recibo una excepción en la última línea. Específicamente:

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)

gracias, Nikos

Según su excepción, InputStreames nulo, esto significa que el cargador de clases no encuentra su archivo de propiedades. Supongo que myProp.properties está en la raíz de su proyecto, si ese es el caso, necesita una barra anterior:

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

Puede encontrar información en esta 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();
}

Puede usar ResourceBundleclass para leer el archivo de propiedades.

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 en el directorio raíz del proyecto

No puede usar esta palabra clave como:

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

en un contexto estático.

Lo mejor sería hacerse con el contexto de la aplicación como:

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

luego puede cargar el archivo de recursos desde la ruta de clase -

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

Esto funcionará tanto para contextos estáticos como no estáticos y la mejor parte es que este archivo de propiedades puede estar en cualquier paquete / carpeta incluido en la ruta de clases de la aplicación.

Su archivo debe estar disponible como com/example/foo/myProps.propertiesclasspath. Luego cárguelo como:

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

si su config.properties no está en el directorio src / main / resource y está en el directorio raíz del proyecto, entonces debe hacer algo como a continuación:

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

Asegúrese de que el nombre del archivo sea correcto y que el archivo esté realmente en la ruta de clases. getResourceAsStream()devolverá nulo si este no es el caso que hace que la última línea arroje la excepción.

Si myProp.properties está en el directorio raíz de su proyecto, utilice /myProp.propertiesen su lugar.

Puede usar java.io.InputStream para leer el archivo como se muestra a continuación:

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

Dado el contexto, se loader.getResourceAsStream("myPackage/myProp.properties")debe utilizar.

Liderar '/'no funciona con el ClassLoader.getResourceAsStream(String)método.

Alternativamente, puede usar el Class.getResourceAsStream(String)método, que se usa '/'para determinar si la ruta es absoluta o relativa a la ubicación de la clase.

Ejemplos:

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

Si la ruta del archivo de propiedades y la ruta de clases de Java son las mismas, entonces debería hacerlo.

Por ejemplo:

src / myPackage / MyClass.java

src / myPackage / MyFile.properties

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

Ninguna de las respuestas actuales muestra que se InputStreamestá cerrando (esto filtrará un descriptor de archivo) y / o no se ocupa de .getResourceAsStream()devolver un valor nulo cuando no se encuentra el recurso (esto conducirá a un NullPointerExceptionmensaje confuso "inStream parameter is null"). Necesita algo como lo siguiente:

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 el archivo de propiedades de lectura con su orden 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>");
    }

Muchas respuestas aquí describen métodos peligrosos en los que crean una instancia de un flujo de entrada de archivo pero no obtienen una referencia al flujo de entrada para cerrar el flujo más tarde. Esto da como resultado flujos de entrada colgantes y pérdidas de memoria. La forma correcta de cargar las propiedades debería ser similar a la siguiente:

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

Tenga en cuenta la instanciación del flujo de entrada del archivo en try-with-resourcesbloque. Dado FileInputStreamque a se puede cerrar automáticamente, se cerrará automáticamente después de try-with-resourcessalir del bloque. Si desea usar un trybloque simple , debe cerrarlo explícitamente usando fis.close();en el finallybloque.

Veo que la pregunta es antigua. Si alguien se encuentra con esto en el futuro, creo que esta es una forma sencilla de hacerlo. Mantenga el archivo de propiedades en la carpeta de su proyecto.

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

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

Especifique la ruta a partir de src como se muestra a continuación:

src/main/resources/myprop.proper