Several Methods for java to read the. properties configuration file: java. properties

Several Methods for java to read the. properties configuration file: java. properties

Reading the. properties configuration file is much used in actual development. To sum up, there are several methods (I only know ):

1. java. util. Properties class provided by jdk

This class is inherited from java. util. hashTable implements the Map interface. Therefore, you can use corresponding methods to operate attribute files. However, we do not recommend using methods such as put and putAll, because the put method can not only store values of the String type, but also objects. Therefore, java. util. the Properties class provides the getProperty () and setProperty () Methods to operate on the property file, and uses store or save (obsolete) to save the property value (write the property value. properties configuration file ). Before using it, you also need to load the attribute file. It provides two methods: load and loadFromXML.

Load has two methods: load (InputStream inStream) and load (Reader reader). Therefore, you can load attribute files in different ways.

You can obtain InputStream in different ways, such:

1. Get it through the getResourceAsStream method of the current Class Loader

Java code

1. InputStream inStream = TestProperties. class. getClassLoader (). getResourceAsStream ("test. properties ");

2. Get from File

Java code

1. InputStream inStream = new FileInputStream (new File ("filePath "));

3. It is also obtained through the class loader, which is the same as the first one.

Java code

1. InputStream in = ClassLoader. getSystemResourceAsStream ("filePath ");

4. In servlet, you can also use context to obtain InputStream

Java code

1. InputStream in = context. getResourceAsStream ("filePath ");

5. Get through URL

Java code

1. URL url = new URL ("path ");
2. InputStream inStream = url. openStream ();

The read method is as follows:

Java code

1. Properties prop = new Properties ();
2. Prop. load (inStream );
3. String key = prop. getProperty ("username ");
4. // String key = (String) prop. get ("username ");

 

Ii. Read through java. util. ResourceBundle class

This method is more convenient than using Properties.

1. Obtain it through the ResourceBundle. getBundle () Static Method

ResourceBundle is an abstract class. To obtain the properties attribute file in this way, you do not need to add a. properties suffix, but only need the file name.

Java code

1. ResourceBundle resource = ResourceBundle. getBundle ("com/mmq/test"); // test is the attribute file name, which is placed under the package com. mmq. If it is placed under src, use test directly.
2. String key = resource. getString ("username ");

2. Read from InputStream

The method for getting InputStream is the same as above.

Java code

1. ResourceBundle resource = new PropertyResourceBundle (inStream );

Note: The biggest problem encountered during use may be the path of the configuration file. If the configuration file is included in the package of the current class, use the package name limitation, for example, test. properties. in the mmq package, use com/mmq/test. properties (obtained through Properties) or com/mmq/test (obtained through ResourceBundle). If the property file is in the src root directory, use test directly. properties or test.

 

Iii. Instances

ResourceLoader. java

Java code

1. Package com. bijian. study;
3. Import java. io. File;
4. Import java. io. FileInputStream;
5. Import java. util. HashMap;
6. Import java. util. Map;
7. Import java. util. Properties;
9. Public final class ResourceLoader {
11. Private static ResourceLoader loader = new ResourceLoader ();
12. Private static Map <String, Properties> loaderMap = new HashMap <String, Properties> ();
14. Private ResourceLoader (){
15. }
17. Public static ResourceLoader getInstance (){
18. Return loader;
19. }
21. Public Properties getPropFromProperties (String fileName) throws Exception {
23. Properties prop = loaderMap. get (fileName );
24. If (prop! = Null ){
25. Return prop;
26. }
27. String filePath = null;
28. String configPath = System. getProperty ("configurePath ");
30. If (configPath = null ){
31. FilePath = this. getClass (). getClassLoader (). getResource (fileName). getPath ();
32. } Else {
33. FilePath = configPath + "/" + fileName;
34. }
35. Prop = new Properties ();
36. Prop. load (new FileInputStream (new File (filePath )));
38. LoaderMap. put (fileName, prop );
39. Return prop;
40. }
41. }

PropertiesUtil. java

Java code

1. Package com. bijian. study;
3. Import java. util. Properties;
4. Import java. util. concurrent. ConcurrentHashMap;
5. Import java. util. concurrent. ConcurrentMap;
7. /**
8. * Use ConcurrentMap to cache the key-value of the property File
9. */
10. Public class PropertiesUtil {
12. Private static ResourceLoader loader = ResourceLoader. getInstance ();
13. Private static ConcurrentMap <String, String> configMap = new ConcurrentHashMap <String, String> ();
14. Private static final String DEFAULT_CONFIG_FILE = "test. properties ";
16. Private static Properties prop = null;
18. Public static String getStringByKey (String key, String propName ){
19. Try {
20. Prop = loader. getPropFromProperties (propName );
21. } Catch (Exception e ){
22. Throw new RuntimeException (e );
23. }
24. Key = key. trim ();
25. If (! ConfigMap. containsKey (key )){
26. If (prop. getProperty (key )! = Null ){
27. ConfigMap. put (key, prop. getProperty (key ));
28. }
29. }
30. Return configMap. get (key );
31. }
33. Public static String getStringByKey (String key ){
34. Return getStringByKey (key, DEFAULT_CONFIG_FILE );
35. }
37. Public static Properties getProperties (){
38. Try {
39. Return loader. getPropFromProperties (DEFAULT_CONFIG_FILE );
40. } Catch (Exception e ){
41. E. printStackTrace ();
42. Return null;
43. }
44. }
45. }

Constant. java

Java code

1. Package com. bijian. study;
3. Public class Constant {
5. Public static final String TEST = PropertiesUtil. getStringByKey ("test", "test. properties ");
6. }

Main. java

Java code

1. Package com. bijian. study;
3. Public class Main {
5. Public static void main (String [] args ){
7. System. out. println (Constant. TEST );
8. }
9. }