Come usare i file di proprietà Java?

Ho una lista di coppie chiave / valore di valori di configurazione che voglio memorizzare come file di proprietà Java, e successivamente caricare e scorrere.

Domande:

  • Devo memorizzare il file nello stesso pacchetto della class che li caricherà, o c’è qualche posizione specifica in cui dovrebbe essere collocato?
  • Il file deve terminare con qualsiasi estensione specifica o è .txt OK?
  • Come posso caricare il file nel codice
  • E come posso scorrere i valori all’interno?

È ansible passare un InputStream alla proprietà, in modo che il file possa essere ovunque e chiamare qualsiasi cosa.

 Properties properties = new Properties(); try { properties.load(new FileInputStream("path/filename")); } catch (IOException e) { ... } 

Iterare come:

 for(String key : properties.stringPropertyNames()) { String value = properties.getProperty(key); System.out.println(key + " => " + value); } 
  • Puoi archiviare il file ovunque tu voglia. Se vuoi conservarlo nel tuo file jar, ti consigliamo di utilizzare Class.getResourceAsStream() o ClassLoader.getResourceAsStream() per accedervi. Se è sul file system è leggermente più semplice.

  • Qualsiasi estensione va bene, anche se .properties è più comune nella mia esperienza

  • Carica il file usando Properties.load , passando un InputStream o uno StreamReader se stai usando Java 6. (Se stai usando Java 6, probabilmente userò UTF-8 e un Reader invece del predefinito ISO-8859- 1 codifica per un stream.)

  • keySet() attraverso la normale iterazione (da cui derivano le Properties ), ad esempio utilizzando keySet() . In alternativa, è ansible utilizzare l’enumerazione restituita da propertyNames() .

Se metti il ​​file delle proprietà nello stesso pacchetto della class Foo, puoi caricarlo facilmente con

 new Properties().load(Foo.class.getResourceAsStream("file.properties")) 

Dato che Properties estende Hashtable puoi iterare sui valori nello stesso modo in cui faresti in un Hashtable.

Se si utilizza l’estensione * .properties è ansible ottenere il supporto dell’editor, ad esempio, Eclipse ha un editor di file di proprietà.

Esistono molti modi per creare e leggere i file delle properties :

  1. Salva il file nello stesso pacchetto.
  2. Consiglia .properties estensione .properties tuttavia puoi scegliere la tua.
  3. Utilizzare queste classi situate in java.util package => Properties , ListResourceBundle , ResourceBundle classs.
  4. Per leggere le proprietà, utilizzare iteratore o enumeratore o metodi diretti di Properties o class java.lang.System .

Classe ResourceBundle :

  ResourceBundle rb = ResourceBundle.getBundle("prop"); // prop.properties System.out.println(rb.getString("key")); 

Classe Properties :

 Properties ps = new Properties(); ps.Load(new java.io.FileInputStream("my.properties")); 

Questo carica il file delle proprietà:

 Properties prop = new Properties(); InputStream stream = ...; //the stream to the file try { prop.load(stream); } finally { stream.close(); } 

Io uso per mettere il file .properties in una directory in cui ho tutti i file di configurazione, non lo metto insieme alla class che lo accede, ma qui non ci sono restrizioni.

Per il nome … Io uso .proprietà per l’amor della verbosità, non penso che dovresti nominarlo .proprietà se non vuoi.

Esempio:

 Properties pro = new Properties(); FileInputStream in = new FileInputStream("D:/prop/prop.properties"); pro.load(in); String temp1[]; String temp2[]; // getting values from property file String username = pro.getProperty("usernamev3");//key value in prop file String password = pro.getProperty("passwordv3");//eg. username="zub" String delimiter = ","; //password="abc" temp1=username.split(delimiter); temp2=password.split(delimiter); 

In ordine:

  1. È ansible memorizzare il file praticamente ovunque.
  2. nessuna estensione è necessaria.
  3. Montecristo ha illustrato come caricare questo. Questo dovrebbe funzionare bene.
  4. propertyNames () ti fornisce un’enumerazione per scorrere.

Per impostazione predefinita, Java lo apre nella directory di lavoro dell’applicazione (questo comportamento dipende in realtà dal sistema operativo utilizzato). Per caricare un file, fare:

 Properties props = new java.util.Properties(); FileInputStream fis new FileInputStream("myfile.txt"); props.load(fis) 

Come tale, qualsiasi estensione di file può essere utilizzata per il file di proprietà. Inoltre, il file può anche essere memorizzato ovunque, purché sia ​​ansible utilizzare FileInputStream .

Su una nota correlata se si utilizza un framework moderno, il framework può fornire ulteriori modi di aprire un file di proprietà. Ad esempio, Spring fornisce ClassPathResource per caricare un file di proprietà utilizzando un nome pacchetto all’interno di un file JAR.

Per quanto riguarda l’iterazione attraverso le proprietà, una volta caricate le proprietà vengono memorizzate nell’object java.util.Properties , che offre il metodo propertyNames() .

Le proprietà sono diventate legacy. La class di preferenze è preferibile a Proprietà.

Un nodo in una raccolta gerarchica di dati di preferenza. Questa class consente alle applicazioni di archiviare e recuperare le preferenze utente e di sistema e i dati di configurazione. Questi dati sono memorizzati in modo persistente in un backing store dipendente dall’implementazione. Le implementazioni tipiche includono file flat, registri specifici del sistema operativo, server di directory e database SQL. L’utente di questa class non deve preoccuparsi dei dettagli del backing store.

A differenza delle proprietà che sono coppie chiave-valore basate su String, la class Preferences ha diversi metodi utilizzati per ottenere e inserire dati primitivi nell’archivio dati Preferenze. Possiamo utilizzare solo i seguenti tipi di dati:

  1. Stringa
  2. booleano
  3. Doppio
  4. galleggiante
  5. int
  6. lungo
  7. array di byte

Per caricare il file delle proprietà, è ansible fornire un percorso assoluto oppure utilizzare getResourceAsStream() se il file delle proprietà è presente nel classpath.

 package com.mypack.test; import java.io.*; import java.util.*; import java.util.prefs.Preferences; public class PreferencesExample { public static void main(String args[]) throws FileNotFoundException { Preferences ps = Preferences.userNodeForPackage(PreferencesExample.class); // Load file object File fileObj = new File("d:\\data.xml"); try { FileInputStream fis = new FileInputStream(fileObj); ps.importPreferences(fis); System.out.println("Prefereces:"+ps); System.out.println("Get property1:"+ps.getInt("property1",10)); } catch (Exception err) { err.printStackTrace(); } } } 

file xml:

 < ?xml version="1.0" encoding="UTF-8"?> < !DOCTYPE preferences SYSTEM 'http://java.sun.com/dtd/preferences.dtd'>                  

Dai un’occhiata a questo articolo sugli interni del negozio di preferenze

Leggere un file di proprietà e caricarne il contenuto in Properties

 String filename = "sample.properties"; Properties properties = new Properties(); input = this.getClass().getClassLoader().getResourceAsStream(filename); properties.load(input); 

Il seguente è il modo efficace per iterare su una Properties

  for (Entry entry : properties.entrySet()) { System.out.println(entry.getKey() + " => " + entry.getValue()); } 

1) È bene avere il file delle proprietà in classpath ma è ansible posizionarlo ovunque nel progetto.

Di seguito viene mostrato come caricare il file delle proprietà da classpath e leggere tutte le proprietà.

 Properties prop = new Properties(); InputStream input = null; try { String filename = "path to property file"; input = getClass().getClassLoader().getResourceAsStream(filename); if (input == null) { System.out.println("Sorry, unable to find " + filename); return; } prop.load(input); Enumeration< ?> e = prop.propertyNames(); while (e.hasMoreElements()) { String key = (String) e.nextElement(); String value = prop.getProperty(key); System.out.println("Key : " + key + ", Value : " + value); } } catch (IOException ex) { ex.printStackTrace(); } finally { if (input != null) { try { input.close(); } catch (IOException e) { e.printStackTrace(); } } } 

2) I file di proprietà hanno l’estensione come .properties

In Java 8 per ottenere tutte le tue proprietà

 public static Map readPropertiesFile(String location) throws Exception { Map properties = new HashMap<>(); Properties props = new Properties(); props.load(new FileInputStream(new File(location))); props.forEach((key, value) -> { properties.put(key.toString(), value.toString()); }); return properties; } 

Ecco un altro modo per scorrere sulle proprietà:

 Enumeration eProps = properties.propertyNames(); while (eProps.hasMoreElements()) { String key = (String) eProps.nextElement(); String value = properties.getProperty(key); System.out.println(key + " => " + value); } 

Ho scritto su questo quadro di proprietà per l’ultimo anno. Fornirà molti modi per caricare le proprietà e le avrà anche fortemente digitate.

Dai un’occhiata a http://sourceforge.net/projects/jhpropertiestyp/

JHPropertiesTyped fornirà allo sviluppatore proprietà fortemente tipizzate. Facile da integrare nei progetti esistenti. Gestito da una grande serie per i tipi di proprietà. Fornisce la possibilità di inizializzare le proprietà su una riga tramite implementazioni IO della proprietà. Dà allo sviluppatore la possibilità di creare propri tipi di proprietà e proprietà io. È anche disponibile la demo Web, schermate mostrate sopra. Avere anche un’implementazione standard per un front-end Web per gestire le proprietà, se si sceglie di utilizzarlo.

La documentazione completa, tutorial, javadoc, faq ecc è disponibile nella pagina web del progetto.