Lecture du fichier de propriétés en Java

J'ai le code suivant essayant de lire un fichier de propriétés:

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

J'obtiens une exception à la dernière ligne. Plus précisément:

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)

merci Nikos

En fonction de votre exception, la valeur InputStreamest nulle, cela signifie que le chargeur de classe ne trouve pas votre fichier de propriétés. Je suppose que myProp.properties est à la racine de votre projet, si c'est le cas, vous avez besoin d'une barre oblique précédente:

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

Vous pouvez trouver des informations sur cette page:
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();
}

Vous pouvez utiliser la ResourceBundleclasse pour lire le fichier de propriétés.

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 sur le répertoire racine du projet

Vous ne pouvez pas utiliser ce mot - clé comme -

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

dans un contexte statique.

La meilleure chose à faire serait de saisir le contexte de l'application comme -

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

alors vous pouvez charger le fichier de ressources à partir du chemin de classe -

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

Cela fonctionnera à la fois pour le contexte statique et non statique et la meilleure partie est que ce fichier de propriétés peut être dans n'importe quel package / dossier inclus dans le chemin de classe de l'application.

Votre fichier doit être disponible comme com/example/foo/myProps.propertiesdans classpath. Puis chargez-le comme:

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

si votre config.properties n'est pas dans le répertoire src / main / resource et qu'il est dans le répertoire racine du projet, vous devez faire quelque chose comme ci-dessous: -

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

Assurez-vous que le nom du fichier est correct et que le fichier se trouve réellement dans le chemin de classe. getResourceAsStream()retournera null si ce n'est pas le cas qui provoque la levée de l'exception par la dernière ligne.

Si myProp.properties se trouve dans le répertoire racine de votre projet, utilisez à la /myProp.propertiesplace.

Vous pouvez utiliser java.io.InputStream pour lire le fichier comme indiqué ci-dessous:

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

Compte tenu du contexte loader.getResourceAsStream("myPackage/myProp.properties")doit être utilisé.

Le leadership '/'ne fonctionne pas avec la ClassLoader.getResourceAsStream(String)méthode.

Vous pouvez également utiliser la Class.getResourceAsStream(String)méthode, qui permet '/'de déterminer si le chemin est absolu ou relatif à l'emplacement de la classe.

Exemples:

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

Si le chemin de votre fichier de propriétés et le chemin de votre classe java sont identiques, vous devriez le faire.

Par exemple:

src / myPackage / MyClass.java

src / myPackage / MyFile.properties

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

Aucune des réponses actuelles ne montre la InputStreamfermeture (cela entraînera une fuite d'un descripteur de fichier), et / ou ne traite pas du .getResourceAsStream()retour de null lorsque la ressource n'est pas trouvée (cela conduira à un NullPointerExceptionmessage déroutant, "inStream parameter is null"). Vous avez besoin de quelque chose comme ce qui suit:

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

Pour lire le fichier de propriétés avec son ordre d'origine:

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

De nombreuses réponses ici décrivent des méthodes dangereuses où elles instancient un flux d'entrée de fichier mais n'obtiennent pas de référence au flux d'entrée afin de fermer le flux plus tard. Cela entraîne des flux d'entrée suspendus et des fuites de mémoire. La manière correcte de charger les propriétés doit être similaire à la suivante:

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

Notez l'instanciation du flux d'entrée du fichier en try-with-resourcesbloc. Puisqu'une FileInputStreamest autoclosable, elle sera automatiquement fermée après la try-with-resourcessortie du bloc. Si vous souhaitez utiliser un trybloc simple , vous devez le fermer explicitement en utilisant fis.close();dans le finallybloc.

Je vois que la question est ancienne. Si quelqu'un tombe sur cela à l'avenir, je pense que c'est une façon simple de le faire. Conservez le fichier de propriétés dans votre dossier de projet.

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

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

Spécifiez le chemin à partir de src comme ci-dessous:

src/main/resources/myprop.proper