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);
Je reçois 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 variable InputStream
a la valeur null, ce qui signifie que le chargeur de classes ne trouve pas votre fichier de propriétés. J'imagine 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 classe ResourceBundle
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 this mot clé tel que -
props.load(this.getClass().getResourceAsStream("myProps.properties"));
dans un contexte statique.
La meilleure chose à faire serait de mettre la main sur le contexte d'application tel que -
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:/META-INF/spring/app-context.xml");
alors vous pouvez charger le fichier de ressources à partir du classpath -
//load a properties file from class path, inside static method
prop.load(context.getClassLoader().getResourceAsStream("config.properties"));
Cela fonctionnera pour les contextes statiques et non statiques et la meilleure partie est que ce fichier de propriétés peut se trouver dans n'importe quel package/dossier inclus dans le chemin de classe de l'application.
Votre fichier devrait être disponible en tant que com/example/foo/myProps.properties
dans classpath. Puis chargez-le en tant que:
props.load(this.getClass().getResourceAsStream("myProps.properties"));
Étant donné le contexte, loader.getResourceAsStream("myPackage/myProp.properties")
devrait être utilisé.
Le '/'
principal ne fonctionne pas avec la méthode ClassLoader.getResourceAsStream(String)
.
Vous pouvez également utiliser la méthode Class.getResourceAsStream(String)
, qui utilise '/'
pour 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")
Vous pouvez utiliser Java.io.InputStream pour lire le fichier comme indiqué ci-dessous:
InputStream inputStream = getClass().getClassLoader().getResourceAsStream(myProps.properties);
Assurez-vous que le nom de 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, ce qui fera que la dernière ligne lève l'exception.
Si myProp.properties se trouve dans le répertoire racine de votre projet, utilisez plutôt /myProp.properties
.
Aucune des réponses actuelles n'indique que la variable InputStream
est fermée (cela produira un descripteur de fichier) et/ou ne traitera pas .getResourceAsStream()
renvoyant la valeur null lorsque la ressource n'est pas trouvée (cela entraînera une NullPointerException
avec le message 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);
}
Beaucoup de réponses ici décrivent des méthodes dangereuses où elles instancient un flux de fichier mais n'obtiennent pas de référence au flux d'entrée afin de fermer le flux ultérieurement. Cela se traduit par des flux d’entrée et des fuites de mémoire. La manière correcte de charger les propriétés doit être semblable à celle-ci:
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 de fichier dans le bloc try-with-resources
. Etant donné qu'une FileInputStream
est autoclosable, elle sera automatiquement fermée après la sortie du bloc try-with-resources
. Si vous souhaitez utiliser un simple bloc try
, vous devez le fermer explicitement à l'aide de fis.close();
dans le bloc finally
.
si votre fichier config.properties ne se trouve pas dans le répertoire src/main/resource et s'il se trouve dans le répertoire racine du projet, vous devez procéder comme suit: -
Properties prop = new Properties();
File configFile = new File(myProp.properties);
InputStream stream = new FileInputStream(configFile);
prop.load(stream);
Pour le fichier de propriétés de lecture avec sa commande 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>");
}
Si votre chemin de fichier de propriétés et votre chemin de 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);