开发中properties文件的使用

ゞ浴缸里的玫瑰 2022-07-24 12:11 145阅读 0赞

一：介绍：   
properties文件在java开发中使用的比较多，主要是一些配置不希望在[程序][Link 1]中写死，而采用   
properties文件这样在不同的地方使用只需要修改properties文件而不用修改程序，最平常的   
是使用在数据库配置中或信息配置中，在开发多语言版本的时候也很有用处，你不同的语言版本   
使用不同的配置文件，这样你就可以不修改程序也不用在程序中在判断，只需要把文件放在   
不同的地方就可以使用。

二：准备   
使用properties文件你需要使用java.util.ResourceBundle充分了解，同时你需要把properties   
文件放在classpath中，这样系统启动是才能加载文件。

三：加载properties文件   
ResourceBundle msgBundle=ResourceBundle.getBundle(msgResource,Locale.CHINA);   
使用上面的语句你就可以加载properties文件文件了，但你必须保证properties 文件放   
在classpath中。   
同时请参考Java API java.util.ResourceBundle;

四:使用properties   
现在你需要取到properties文件中的内容，使用ResourceBundle里面的getString() 方法就可以了。   
但需要注意的是getString取到的是ISO字符串，你可能根据需要转换为不同的字符串。

五：具体实现

Java [代码][Link 1]   [![收藏代码][Image 1]][Image 1 1]

1.  jdbc.properties  
2.  =============================================  
3.  jdbc.driverClassName=com.microsoft.jdbc.sqlserver.SQLServerDriver  
4.  jdbc.url=jdbc:microsoft:sqlserver://127.0.0.1:1433;databasename=EVA\_MEMBER  
5.  jdbc.username=sa  
6.  jdbc.password=sa  
7.    
8.  MessageBundle.java  
9.  =============================================  
10. **import** java.io.UnsupportedEncodingException;  
11. **import** java.util.Locale;  
12. **import** java.util.MissingResourceException;  
13. **import** java.util.ResourceBundle;  
14.   
15. **public** **class** MessageBundle \{  
16.   
17.     **private** **static** ResourceBundle msgBundle = **null**;  
18.   
19.       
20.     **public** MessageBundle(String msgResource) \{  
21.         msgBundle = ResourceBundle.getBundle(msgResource, Locale.CHINA);  
22.     \}  
23.   
24.       
25.     **public** **static** String getMessage(String \_key) \{  
26.         String message = **null**;  
27.         **try** \{  
28.             message = **new** String(msgBundle.getString(\_key)  
29.                     .getBytes("ISO8859\_1"), "gb2312");  
30.         \} **catch** (MissingResourceException ex) \{  
31.             ex.printStackTrace();  
32.         \} **catch** (UnsupportedEncodingException ex) \{  
33.             ex.printStackTrace();  
34.         \}  
35.         **return** message;  
36.     \}  
37.       
38.     **public** **static** **void** main(String\[\] args) \{  
39.           
40.   
41.          MessageBundle msg=**new** MessageBundle("jdbc");  
42.          String driver   = msg.getMessage("jdbc.driverClassName");  
43.          String url      = msg.getMessage("jdbc.url");  
44.          String username =msg.getMessage("jdbc.username");  
45.          String password =msg.getMessage("jdbc.password");  
46.   
47.          System.out.println(driver);  
48.          System.out.println(url);  
49.          System.out.println(username);  
50.          System.out.println(password);  
51.           
52.           
53.     \}  
54.   
55. \}

六：具体运用   
1：)连接数据库   
在jsp开发中通常连接数据库都是由JavaBean去实现，但你由不希望下次使用这个javabean   
去修改.这时候properties文件就很有作用了。你可以把数据库配置放在properties文件中。   
这样就可以只修改properties而继续使用JavaBean了。   
2网页风格   
建设一个网站通常是需要统一的风格，也就以为着需要统一的背景色等等，这个时候你把   
网页风格涉及的要素放在peoperties文件中，需要修改一次性修改几可以了，或者下次还   
有大概相同的网站是不是可以省修改页面的时间啊。   
3：）信息提示   
在开发一个Appaction中出错提示或者信息提示是必须的，而很多时候你的提示信息，用户   
未必能理解，一开始你又不知道如何用户可以理解，这个时候把所有的提示信息放在   
properties文件中是一个不错的提示。   
4：）和系统有关的属性   
因为java是可以在不同的平台上运行的，而很多时候开发和实际运行是在不同的平台，这个

时候你就可以使用properties文件保存系统属性，移植也可以省一些时间。

转：[/images/20220722/2e99f8f83bc54908a6febaddea6e54bb.png][Image 1 1]

=====================================================================

# [Java读取Properties文件的六种方法][Java_Properties] #

1.使用java.util.Properties类的load()方法

示例： InputStream in = lnew BufferedInputStream(new FileInputStream(name));

Properties p = new Properties();

p.load(in);

2。使用java.util.ResourceBundle类的getBundle()方法

示例： ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());

3。使用java.util.PropertyResourceBundle类的构造函数

示例： InputStream in = new BufferedInputStream(new FileInputStream(name));

ResourceBundle rb = new PropertyResourceBundle(in);

4。使用class变量的getResourceAsStream()方法

示例： InputStream in = JProperties.class.getResourceAsStream(name);

Properties p = new Properties();

p.load(in);

5。使用class.getClassLoader()所得到的java.lang.ClassLoader的getResourceAsStream()方法

示例： InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);

Properties p = new Properties();

p.load(in);

6。使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法

示例： InputStream in = ClassLoader.getSystemResourceAsStream(name);

Properties p = new Properties();

p.load(in);

补充

Servlet中可以使用javax.servlet.ServletContext的getResourceAsStream()方法

示例：InputStream in = context.getResourceAsStream(path);

Properties p = new Properties();

p.load(in);

JProperties.java文件

public class JProperties \{

public final static int BY\_PROPERTIES = 1;

public final static int BY\_RESOURCEBUNDLE = 2;

public final static int BY\_PROPERTYRESOURCEBUNDLE = 3;

public final static int BY\_CLASS = 4;

public final static int BY\_CLASSLOADER = 5;

public final static int BY\_SYSTEM\_CLASSLOADER = 6;

public final static Properties loadProperties(final String name, final int type) throws IOException \{

Properties p = new Properties();

InputStream in = null;

if (type == BY\_PROPERTIES) \{

in = new BufferedInputStream(new FileInputStream(name));

assert (in != null);

p.load(in);

\} else if (type == BY\_RESOURCEBUNDLE) \{

ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());

assert (rb != null);

p = new ResourceBundleAdapter(rb);

\} else if (type == BY\_PROPERTYRESOURCEBUNDLE) \{

in = new BufferedInputStream(new FileInputStream(name));

assert (in != null);

ResourceBundle rb = new PropertyResourceBundle(in);

p = new ResourceBundleAdapter(rb);

\} else if (type == BY\_CLASS) \{

assert (JProperties.class.equals(new JProperties().getClass()));

in = JProperties.class.getResourceAsStream(name);

assert (in != null);

p.load(in);

// return new JProperties().getClass().getResourceAsStream(name);

\} else if (type == BY\_CLASSLOADER) \{

assert (JProperties.class.getClassLoader().equals(new JProperties().getClass().getClassLoader()));

in = JProperties.class.getClassLoader().getResourceAsStream(name);

assert (in != null);

p.load(in);

// return new JProperties().getClass().getClassLoader().getResourceAsStream(name);

\} else if (type == BY\_SYSTEM\_CLASSLOADER) \{

in = ClassLoader.getSystemResourceAsStream(name);

assert (in != null);

p.load(in);

if (in != null) \{

in.close();

return p;

// ---------------------------------------------- servlet used

// ---------------------------------------------- support class

public static class ResourceBundleAdapter extends Properties \{

public ResourceBundleAdapter(ResourceBundle rb) \{

assert (rb instanceof java.util.PropertyResourceBundle);

this.rb = rb;

java.util.Enumeration e = rb.getKeys();

while (e.hasMoreElements()) \{

Object o = e.nextElement();

this.put(o, rb.getObject((String) o));

private ResourceBundle rb = null;

public ResourceBundle getBundle(String baseName) \{

return ResourceBundle.getBundle(baseName);

public ResourceBundle getBundle(String baseName, Locale locale) \{

return ResourceBundle.getBundle(baseName, locale);

public ResourceBundle getBundle(String baseName, Locale locale, ClassLoader loader) \{

return ResourceBundle.getBundle(baseName, locale, loader);

===============================================================================

在我们平时写程序的时候，有些参数是经常改变的，而这种改变不是我们预知的。比如说我们开发了一个操作数据库的模块，在开发的时候我们连接本地的数据库那么 IP ，数据库名称，表名称，数据库主机等信息是我们本地的，要使得这个操作数据的模块具有通用性，那么以上信息就不能写死在程序里。通常我们的做法是用配置文件来解决。

各种语言都有自己所支持的配置文件类型。比如 Python ，他支持 .ini 文件。因为他内部有一个 ConfigParser 类来支持 .ini 文件的读写，根据该类提供的方法程序员可以自由的来操作 .ini 文件。而在 Java 中， Java 支持的是 .properties 文件的读写。JDK 内置的 java.util.Properties 类为我们操作 .properties 文件提供了便利。

**一． .properties 文件的形式 **==========================================================

\# 以下为服务器、数据库信息

dbPort = localhost

databaseName = mydb

dbUserName = root

dbPassword = root

\# 以下为数据库表信息

dbTable = mytable

\# 以下为服务器信息

ip = 192.168.0.9

······

在上面的文件中我们假设该文件名为： test.properties 文件。其中 \# 开始的一行为注释信息；在等号“ = ”左边的我们称之为key ；等号“ = ”右边的我们称之为 value 。（其实就是我们常说的键 - 值对） key 应该是我们程序中的变量。而 value 是我们根据实际情况配置的。

**二． JDK 中的 Properties 类 **Properties 类存在于胞 Java.util 中，该类继承自 `Hashtable``，它提供了几个主要的方法：`1． `getProperty``(  String  key)``，`  用指定的键在此属性列表中搜索属性。也就是通过参数 key ，得到 key 所对应的 value 。

`2．``load``(  InputStream  inStream)`，从输入流中读取属性列表（键和元素对）。通过对指定的文件（比如说上面的 test.properties 文件）进行装载来获取该文件中的所有键 - 值对。以供 `getProperty``(  String  key)``来搜索。`  3． `setProperty``(  String  key,  String  value)`，调用 Hashtable 的方法 `put``。他通过调用基类的put方法来设置` 键 - 值对。

4． `store``(  OutputStream  out,  String  comments)`，   以适合使用 [`load`][load]方法加载到 `Properties`表中的格式，将此 `Properties`表中的属性列表（键和元素对）写入输出流。与 load 方法相反，该方法将键 - 值对写入到指定的文件中去。

5． `clear``()` `，清除所有装载的` 键 - 值对。该方法在基类中提供。

有了以上几个方法我们就可以对 .properties 文件进行操作了！

简单实例：

Java代码   [![收藏代码][Image 1]][Image 1 2]

1.  package cn.net.yans.common.util;  
2.    
3.  import java.io.FileInputStream;  
4.  import java.io.FileNotFoundException;  
5.  import java.io.FileOutputStream;  
6.  import java.io.IOException;  
7.  import java.util.Properties;  
8.    
9.  /\*\* 
10.  \* 读取properties文件 
11.  \*  
12.  \* @author yans 
13.  \*  
14.  \*/  
15. public class Configuration \{  
16.     private Properties propertie;  
17.     private FileInputStream inputFile;  
18.     private FileOutputStream outputFile;  
19.   
20.     /\*\* 
21.      \* 初始化Configuration类 
22.      \*/  
23.     public Configuration() \{  
24.         propertie = new Properties();  
25.     \}  
26.   
27.     /\*\* 
28.      \* 初始化Configuration类 
29.      \*  
30.      \* @param filePath 
31.      \*            要读取的配置文件的路径+名称 
32.      \*/  
33.     public Configuration(String filePath) \{  
34.         propertie = new Properties();  
35.         try \{  
36.             inputFile = new FileInputStream(this.getClass().getClassLoader()  
37.                     .getResource(filePath).getPath());  
38.             propertie.load(inputFile);  
39.             inputFile.close();  
40.         \} catch (FileNotFoundException ex) \{  
41.             System.out.println("读取属性文件--->失败！- 原因：文件路径错误或者文件不存在");  
42.             ex.printStackTrace();  
43.         \} catch (IOException ex) \{  
44.             System.out.println("装载文件--->失败!");  
45.             ex.printStackTrace();  
46.         \}  
47.     \}// end ReadConfigInfo(...)  
48.   
49.     /\*\* 
50.      \* 重载函数，得到key的值 
51.      \*  
52.      \* @param key 
53.      \*            取得其值的键 
54.      \* @return key的值 
55.      \*/  
56.     public String getValue(String key) \{  
57.         if (propertie.containsKey(key)) \{  
58.             String value = propertie.getProperty(key);// 得到某一属性的值  
59.             return value;  
60.         \} else  
61.             return "";  
62.     \}// end getValue(...)  
63.   
64.     /\*\* 
65.      \* 重载函数，得到key的值 
66.      \*  
67.      \* @param fileName 
68.      \*            properties文件的路径+文件名 
69.      \* @param key 
70.      \*            取得其值的键 
71.      \* @return key的值 
72.      \*/  
73.     public String getValue(String fileName, String key) \{  
74.         try \{  
75.             String value = "";  
76.             inputFile = new FileInputStream(fileName);  
77.             propertie.load(inputFile);  
78.             inputFile.close();  
79.             if (propertie.containsKey(key)) \{  
80.                 value = propertie.getProperty(key);  
81.                 return value;  
82.             \} else  
83.                 return value;  
84.         \} catch (FileNotFoundException e) \{  
85.             e.printStackTrace();  
86.             return "";  
87.         \} catch (IOException e) \{  
88.             e.printStackTrace();  
89.             return "";  
90.         \} catch (Exception ex) \{  
91.             ex.printStackTrace();  
92.             return "";  
93.         \}  
94.     \}// end getValue(...)  
95.   
96.     /\*\* 
97.      \* 清除properties文件中所有的key和其值 
98.      \*/  
99.     public void clear() \{  
100.         propertie.clear();  
101.     \}// end clear();  
102.   
103.     /\*\* 
104.      \* 改变或添加一个key的值，当key存在于properties文件中时该key的值被value所代替， 当key不存在时，该key的值是value 
105.      \*  
106.      \* @param key 
107.      \*            要存入的键 
108.      \* @param value 
109.      \*            要存入的值 
110.      \*/  
111.     public void setValue(String key, String value) \{  
112.         propertie.setProperty(key, value);  
113.     \}// end setValue(...)  
114.   
115.     /\*\* 
116.      \* 将更改后的文件数据存入指定的文件中，该文件可以事先不存在。 
117.      \*  
118.      \* @param fileName 
119.      \*            文件路径+文件名称 
120.      \* @param description 
121.      \*            对该文件的描述 
122.      \*/  
123.     public void saveFile(String fileName, String description) \{  
124.         try \{  
125.             outputFile = new FileOutputStream(fileName);  
126.             propertie.store(outputFile, description);  
127.             outputFile.close();  
128.         \} catch (FileNotFoundException e) \{  
129.             e.printStackTrace();  
130.         \} catch (IOException ioe) \{  
131.             ioe.printStackTrace();  
132.         \}  
133.     \}// end saveFile(...)  
134.   
135.     public static void main(String\[\] args) throws IOException \{  
136.         Configuration rc = new Configuration("powers.properties");  
137.         String\[\] powerList = rc.getValue("list").split(",");  
138.         for (String po : powerList) \{  
139.             System.out.println(po);  
140.         \}  
141.     \}  
142. \}

**路径相关问题：**

在java中使用相对路径  
　　无标题文档  
　　?  
　　在开发过程中，我们经常会遇到读取配置文件的情况，对于配置文件的读取，根据环境等情况又各有不同，一般情况下，如果从非jar包中使用相对/路径，比较简单，就不在累述了，而在很多  
　　情况下，我们需要把我们的class打包成jar文件，进行使用，这时就会发现，我们先前如果没有考虑到这些，可能就行不通了，那么，该如何解决呢？方法如下  
　　：  
　　有如下路径 ：  
　　Web-info--|-->classes--->conf-->config.properties  
　　|-->lib  
　　此时加入我们需要读取config.properties，在不使用jar包时，使用如下方式读取，不失为一种方法：  
　　File f = new File(this.getClass().getResource("/").getPath());  
　　f = new File(f.getPath() + "/conf/config.properties");

或者：（this.getClass().getClassLoader().getResource(fileName).getPath()）

注：f.getPath()即为当class所在的绝对路径。如：c:\\javasrc\\web-inf\\classes  
　　然后,对文件对象进行处理，就能把配置信息读取出来了，但是加入如上class被打包成jar文件，那么，在程序执行到这里时，就会无法找到配置文件，那么该如何处理呢？  
　　处理方法如下：  
　　String s\_config="conf/config.properties";  
　　InputStream in = ClassLoader.getSystemResourceAsStream(s\_config);  
　　if( in == null )\{  
　　System.out.println( " 打开 " + s\_config + "失败！" );  
　　\}else  
　　\{  
　　Properties properties = new Properties();  
　　properties.load(in);  
　　//  
　　//接下来就可以通过properties.getProperty(String obj)方法对进行配置信息读取了

1. System.getProperty （"user.dir" ）当前用户目录的相对路径。

2. this.getClass().getResource("") 到的也是当前ClassPath 的绝对URI 路径。

3. ClassLoader.getSystemResource("") 到的也是当前ClassPath 的绝对URI 路径。

4. Thread.currentThread().getContextClassLoader().getResource("") 到的也是当前ClassPath 的绝对URI 路径。

读取Properties 文件的方法

1. 使用java.util.Properties 类的load() 方法   
示例：  InputStream in = lnew BufferedInputStream(new FileInputStream(name));  
       Properties p = new Properties();  
       p.load(in);

2. 使用java.util.ResourceBundle 类的getBundle() 方法   
示例：  ResourceBundle rb = ResourceBundle.getBundle(name, Locale.getDefault());

3. 使用java.util.PropertyResourceBundle 类的构造函数   
示例：  InputStream in = new BufferedInputStream(new FileInputStream(name));  
       ResourceBundle rb = new PropertyResourceBundle(in);

4. 使用class 变量的getResourceAsStream() 方法   
示例：  InputStream in = JProperties.class.getResourceAsStream(name);  
       Properties p = new Properties();  
       p.load(in);

5. 使用class.getClassLoader() 所得到的java.lang.ClassLoader 的getResourceAsStream() 方法。

示例：

InputStream in = JProperties.class.getClassLoader().getResourceAsStream(name);  
       Properties p = new Properties();  
       p.load(in);

6. 使用java.lang.ClassLoader 类的getSystemResourceAsStream() 静态方法   
示例：  InputStream in = ClassLoader.getSystemResourceAsStream(name);  
       Properties p = new Properties();  
       p.load(in);

7.Servlet 中可以使用javax.servlet.ServletContext 的getResourceAsStream() 方法   
示例： InputStream in = context.getResourceAsStream(path);  
      Properties p = new Properties();

p.load(in);

空格

//获得文件路径,并对路径进行处理   
private static String getUrl()   
\{   
  String path = configLoad.class.getResource("config.properties").toString();   
  path = path.replace("%20", " "); //引号中有一个半角的空格   
  path = path.substring(6);   
  return path;   
\}   
\}   
那么这里返回了一个Properties类型的值,在这里就可以使用getProperty()来获得值   
如:Properties pro = configLoad.getConfig();   
String http = pro.getProperty("url").toString();

总 结：java的properties文件需要放到classpath下面，这样程序才能读取到，有关classpath实际上就是java类或者库的存放 路径，在java工程中，properties放到class文件一块。在web应用中，最简单的方法是放到web应用的WEB-INF/classes 目录下即可，也可以放在其他文件夹下面，这时候需要在设置classpath环境变量的时候，将这个文件夹路径加到classpath变量中，这样也也可 以读取到。在此，你需要对classpath有个深刻理解，classpath绝非系统中刻意设定的那个系统环境变量，WEB-INF/classes其  
实也是，java工程的class文件目录也是。

[Link 1]: http://www.xuebuyuan.com/
[Image 1]: 
[Image 1 1]: /images/20220722/2e99f8f83bc54908a6febaddea6e54bb.png
[Java_Properties]: http://www.cnblogs.com/tonyzhangtl/archive/2009/11/19/1606367.html
[load]: http://mce_host/admin/blogs/1123680/mk:@MSITStoreE:%5CBook%5CJava%5CJDK1.5API_%E4%B8%AD%E6%96%87%E7%89%88.CHM::
[Image 1 2]: /images/20220722/d940509549db481d90191b2bf40b4b98.png