使用单例模式加载配置文件

在javaWeb项目中，一般会用单例模式来加载配置文件以及数据字典，有三种方法：

方式一：懒汉方式（到第一次使用实例时，才加载实例）好处是只有到第一次调用getInstance才生成对象，节省了空间。不足之处在于同步锁导致有可能执行过慢。

方式二：饿汉方式  由于BasicConfiguration的实例是static，因此，当类被加载时就会初始化，但这样即使并不需要使用此实例，也会被初始化，导致内存空间的浪费；

方式三：内部类方式 由于初始化放在内部类中，只有当此内部类被使用时，才会进行初始化。从而既节省了空间，也无需同步代码。

先准备测试程序：

[java]  view plain  copy

 

1. package org.jediael.util;  
2. import static org.junit.Assert.*;  
3. import org.junit.Test;  
4.   
5. public class BasicConfigurationTest {  
6.     @Test  
7.     public void testGetValue(){  
8.         BasicConfiguration configuration = BasicConfiguration.getInstance();  
9.         assertTrue(configuration.getValue("key").equals("value"));  
10.     }  
11. }  

其中properties文件中有一行如下：

key=value

优先选择方案三

方式一：懒汉方式

到第一次使用实例时，才加载实例

[java]  view plain  copy

 

1. package org.jediael.util;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.util.Properties;  
8.   
9. public class BasicConfiguration {  
10.   
11.     private static BasicConfiguration configuration = null;  
12.     private Properties pros = null;  
13.       
14.     public static synchronized BasicConfiguration getInstance(){  
15.         if(configuration == null){  
16.             configuration = new BasicConfiguration();  
17.         }  
18.         return configuration;  
19.     }  
20.       
21.     public String getValue(String key){  
22.         return pros.getProperty(key);  
23.     }  
24.       
25.     private BasicConfiguration(){  
26.         readConfig();  
27.     }  
28.   
29.     private void readConfig() {  
30.         pros = new Properties();          
31.         InputStream in = null;  
32.         try {  
33.             in = new FileInputStream(Thread.currentThread().getContextClassLoader().getResource("")  
34.                     .getPath() + "search.properties");  
35.             pros.load(in);  
36.         } catch (FileNotFoundException e) {  
37.             e.printStackTrace();  
38.         }catch (IOException e) {  
39.             e.printStackTrace();  
40.         }finally{  
41.             try {  
42.                 in.close();  
43.             } catch (IOException e) {  
44.                 e.printStackTrace();  
45.             }  
46.         }  
47.     }  
48. }  

上述程序中，产生了BasicConfiguration的一个单例。

好处是只有到第一次调用getInstance才生成对象，节省了空间。不足之处在于同步锁导致有可能执行过慢。

2、饿汉方式

[java]  view plain  copy

 

1. package org.jediael.util;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.util.Properties;  
8.   
9. public class BasicConfiguration {  
10.   
11.     private static BasicConfiguration configuration = new BasicConfiguration();  
12.     private Properties pros = null;  
13.       
14.     public static BasicConfiguration getInstance(){  
15.         return configuration;  
16.     }  
17.       
18.     public String getValue(String key){  
19.         return pros.getProperty(key);  
20.     }  
21.       
22.     private BasicConfiguration(){  
23.         readConfig();  
24.     }  
25.   
26.     private void readConfig() {  
27.         pros = new Properties();          
28.         InputStream in = null;  
29.         try {  
30.             in = new FileInputStream(Thread.currentThread().getContextClassLoader().getResource("")  
31.                     .getPath() + "search.properties");  
32.             pros.load(in);  
33.         } catch (FileNotFoundException e) {  
34.             e.printStackTrace();  
35.         }catch (IOException e) {  
36.             e.printStackTrace();  
37.         }finally{  
38.             try {  
39.                 in.close();  
40.             } catch (IOException e) {  
41.                 e.printStackTrace();  
42.             }  
43.         }  
44.     }  
45. }  

由于BasicConfiguration的实例是static，因此，当类被加载时就会初始化，但这样即使并不需要使用此实例，也会被初始化，导致内存空间的浪费。

方式三：

[java]  view plain  copy

 

1. package org.jediael.util;  
2.   
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStream;  
7. import java.util.Properties;  
8.   
9. public class BasicConfiguration {  
10.   
11.       
12.     private Properties pros = null;  
13.       
14.     private static class ConfigurationHolder{  
15.         private static BasicConfiguration configuration = new BasicConfiguration();  
16.     }  
17.       
18.     public static BasicConfiguration getInstance(){  
19.         return ConfigurationHolder.configuration;  
20.     }  
21.       
22.     public String getValue(String key){  
23.         return pros.getProperty(key);  
24.     }  
25.       
26.     private BasicConfiguration(){  
27.         readConfig();  
28.     }  
29.       
30.   
31.   
32.     private void readConfig() {  
33.         pros = new Properties();          
34.         InputStream in = null;  
35.         try {  
36.             in = new FileInputStream(Thread.currentThread().getContextClassLoader().getResource("")  
37.                     .getPath() + "search.properties");  
38.             pros.load(in);  
39.         } catch (FileNotFoundException e) {  
40.             e.printStackTrace();  
41.         }catch (IOException e) {  
42.             e.printStackTrace();  
43.         }finally{  
44.             try {  
45.                 in.close();  
46.             } catch (IOException e) {  
47.                 e.printStackTrace();  
48.             }  
49.         }  
50.     }  
51. }  

由于初始化放在内部类中，只有当此内部类被使用时，才会进行初始化。从而既节省了空间，也无需同步代码。