Como usar arquivos de propriedade Java?

Eu tenho uma lista de pares chave / valor de valores de configuração que eu quero armazenar como arquivos de propriedade Java, e depois carregar e iterar através de.

Questões:

  • Preciso armazenar o arquivo no mesmo pacote da class que irá carregá-lo ou há algum local específico onde ele deve ser colocado?
  • O arquivo precisa terminar em qualquer extensão específica ou é .txt OK?
  • Como posso carregar o arquivo no código
  • E como posso percorrer os valores internos?

Você pode passar um InputStream para a propriedade, assim o seu arquivo pode praticamente estar em qualquer lugar, e chamar qualquer coisa.

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

Iterar como:

 for(String key : properties.stringPropertyNames()) { String value = properties.getProperty(key); System.out.println(key + " => " + value); } 
  • Você pode armazenar o arquivo em qualquer lugar que desejar. Se você quiser mantê-lo em seu arquivo jar, você vai querer usar Class.getResourceAsStream() ou ClassLoader.getResourceAsStream() para acessá-lo. Se estiver no sistema de arquivos, é um pouco mais fácil.

  • Qualquer extensão é boa, embora as propriedades sejam mais comuns na minha experiência

  • Carregue o arquivo usando Properties.load , transmitindo um InputStream ou um StreamReader se você estiver usando o Java 6. (Se você estiver usando o Java 6, provavelmente usaria o UTF-8 e um Reader vez do padrão ISO-8859- 1 codificação para um stream.)

  • Faça a iteração ao percorrer uma Hashtable normal (da qual derivam as Properties ), por exemplo, usando keySet() . Como alternativa, você pode usar a enumeração retornada por propertyNames() .

Se você colocar o arquivo de propriedades no mesmo pacote da class Foo, poderá carregá-lo facilmente com

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

Dado que Properties estende Hashtable você pode iterar sobre os valores da mesma maneira que faria em uma Hashtable.

Se você usar a extensão * .properties, poderá obter suporte ao editor, por exemplo, o Eclipse possui um editor de arquivos de propriedades.

Existem muitas maneiras de criar e ler arquivos de properties :

  1. Armazene o arquivo no mesmo pacote.
  2. Recomende extensão .properties no entanto, você pode escolher o seu próprio.
  3. Use essas classs localizadas em java.util package => Properties , ListResourceBundle , classs ResourceBundle .
  4. Para ler propriedades, use iterador ou enumerador ou methods diretos de Properties ou class java.lang.System .

Classe ResourceBundle :

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

Classe de Properties :

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

Isso carrega o arquivo de propriedades:

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

Eu uso para colocar o arquivo .properties em um diretório onde eu tenho todos os arquivos de configuração, eu não o coloco junto com a class que o acessa, mas não há restrições aqui.

Para o nome … eu uso .properties por causa de verbosidade, eu não acho que você deveria nomeá-lo .propriedades se você não quiser.

Exemplo:

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

Em ordem:

  1. Você pode armazenar o arquivo praticamente em qualquer lugar.
  2. nenhuma extensão é necessária.
  3. Montecristo ilustrou como carregar isso. Isso deve funcionar bem.
  4. propertyNames () fornece uma enumeração para iterar.

Por padrão, o Java abre no diretório de trabalho do seu aplicativo (esse comportamento, na verdade, depende do sistema operacional usado). Para carregar um arquivo, faça:

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

Como tal, qualquer extensão de arquivo pode ser usada para o arquivo de propriedades. Além disso, o arquivo também pode ser armazenado em qualquer lugar, desde que você possa usar um FileInputStream .

Em uma nota relacionada, se você usar uma estrutura moderna, a estrutura pode fornecer maneiras adicionais de abrir um arquivo de propriedades. Por exemplo, o Spring fornece um ClassPathResource para carregar um arquivo de propriedades usando um nome de pacote dentro de um arquivo JAR.

Quanto a percorrer as propriedades, uma vez carregadas as propriedades, elas são armazenadas no object java.util.Properties , que oferece o método propertyNames() .

Propriedades tornou-se legado. A class Preferences é preferida a Properties.

Um nó em uma coleção hierárquica de dados de preferência. Essa class permite que os aplicativos armazenem e recuperem dados de preferência e configuração do usuário e do sistema. Esses dados são armazenados persistentemente em um armazenamento de backup dependente de implementação. Implementações típicas incluem arquivos simples, registros específicos do sistema operacional, servidores de diretório e bancos de dados SQL. O usuário dessa class não precisa se preocupar com detalhes da loja de apoio.

Ao contrário das propriedades que são pares de valores-chave baseados em String, a class Preferences tem vários methods usados ​​para obter e colocar dados primitivos no armazenamento de dados de Preferências. Podemos usar apenas os seguintes tipos de dados:

  1. Corda
  2. boleano
  3. Duplo
  4. flutuador
  5. int
  6. longo
  7. matriz de bytes

Para carregar o arquivo de propriedades, você pode fornecer caminho absoluto ou usar getResourceAsStream() se o arquivo de propriedades estiver presente em seu caminho de class.

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

arquivo xml:

                    

Dê uma olhada neste artigo sobre internals de armazenamento de preferências

Lendo um arquivo de propriedades e carregando seu conteúdo para Properties

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

O seguinte é a maneira eficiente de iterar sobre as Properties

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

1) É bom ter seu arquivo de propriedades no classpath, mas você pode colocá-lo em qualquer lugar do projeto.

Abaixo está como você carrega o arquivo de propriedades do classpath e lê todas as propriedades.

 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) Arquivos de propriedades possuem a extensão como .properties

No Java 8 para obter todas as suas propriedades

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

Aqui está outra maneira de iterar sobre as propriedades:

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

Eu escrevi sobre esta estrutura de propriedade para o ano passado. Ele fornecerá várias maneiras de carregar as propriedades e as terá fortemente digitadas.

Dê uma olhada em http://sourceforge.net/projects/jhpropertiestyp/

JHPropertiesTyped dará ao desenvolvedor propriedades fortemente tipadas. Fácil de integrar em projetos existentes. Manipulado por uma série grande para tipos de propriedade. Dá a capacidade de uma linha inicializar propriedades através de implementações de propriedade IO. Dá ao desenvolvedor a capacidade de criar seus próprios tipos de propriedades e propriedades. A demonstração na Web também está disponível, capturas de canvas mostradas acima. Também tem uma implementação padrão para um front-end da web para gerenciar propriedades, se você optar por usá-lo.

Documentação completa, tutorial, javadoc, faq etc está disponível na página do projeto.