devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JavaSE基础:Properties属性类

作者：weixin_40725706 | 2024-03-18 05:29:00

赞

踩

paserint属性

Properties

在Java中属性操作类是一个很重要的类,而要想明白属性操作类的作用,就必须先要清楚什么是属性文件,在属性文件中含有多个属性,每个属性就是直接用字符串表示出来的"key=value 键/值对", 而如果要想轻松操作这些属性需要使用Properties类完成.

1.简单认识Properties

  1. public class Properties extends Hashtable<Object,Object>
  2. 复制代码
编号方法名称类型描述
1public Properties()构造创建一个无默认值的空属性类
2public Properties(Properties props)构造创建一个带有指定默认值的空属性类
3public String getProperty(String key)普通方法根据属性的key取得属性的value,如果没有,将放回null
4public String getProperty(String key, String defaultValue)普通方法根据属性的key取得属性的value,如果没有,将返回defaultValue
5public Object setProperty(String key, String value)普通方法设置属性
6public void list(PrintStream out)普通方法属性打印
7public void load(InputStream inStream)普通方法将输入流中取出全部的属性内容
8public void loadFromXML(InputStream in)普通方法从XML文件格式中读取内容
9public void store(OutputStream out, String comments)普通方法将属性内容通过输出流输出,同时声明属性的注释内容
10public void storeToXML(OutputStream os, String comment)普通方法以XML文件格式输出属性,默认编码
11public void storeToXML(OutputStream os, String comment, String encoding)普通方法以XML文件格式输出属性,用户指定默认编码

实际开发中我们使用Properties的功能类似于存储的数据为Map<String,String>都是字符串的形式

2.Properties的操作实例

示例1:设置和取得属性

主要使用setProperty()和getProperty()方法设置和获取属性,存储的数据类型都是String

  1. package com.shxt.demo06;
  2.  
  3. import java.util.Properties;
  4.  
  5. public class Demo01 {
  6.     public static void main(String[] args) {
  7.         Properties props = new Properties(); //创建Properties对象
  8.         //设置属性
  9.         props.setProperty("title","胖先森博客");
  10.         props.setProperty("version","v1.0");
  11.         props.setProperty("db","MySQL 5.7");
  12.  
  13.         //获取属性
  14.         System.out.println("1.title属性存在:"+props.getProperty("title"));
  15.         System.out.println("2.name属性不存在:"+props.getProperty("name"));
  16.         System.out.println("3.name属性不存在,显示默认值:"+props.getProperty("name","胖先森"));
  17.  
  18.     }
  19. }
  20. /*
  21. 	运行结果:
  22. 		1.title属性存在:胖先森博客
  23.         2.name属性不存在:null
  24.         3.name属性不存在,显示默认值:胖先森
  25. */
  26. 复制代码

示例2:保存属性到普通的属性文件

  1. package com.shxt.demo06;
  2.  
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.util.Properties;
  7.  
  8. public class Demo02 {
  9.     public static void main(String[] args) {
  10.         Properties props = new Properties(); //创建Properties对象
  11.         //设置属性
  12.         props.setProperty("title","胖先森博客");
  13.         props.setProperty("version","v1.0");
  14.         props.setProperty("db","MySQL 5.7");
  15.  
  16.         //设置属性文件的保存路径,使用绝对路径
  17.         //关于文件的操作,我们在后面J2EE文件上传的时候会再次说明
  18.         File file = new File("D:/sys.properties");
  19.         try {
  20.             props.store(new FileOutputStream(file),"system config");
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  25. }
  26. 复制代码

运行结果:

说明:如果是中文会使用Unicode进行转换

示例3:从属性文件中读取内容

  1. package com.shxt.demo06;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.util.Properties;
  7.  
  8. public class Demo03 {
  9.     public static void main(String[] args) {
  10.         Properties props = new Properties(); //创建Properties对象
  11.  
  12.         //跟磁盘中的文件建立联系
  13.         File file = new File("D:/sys.properties");
  14.         try {
  15.             //读取属性文件
  16.             props.load(new FileInputStream(file));
  17.             //获取属性
  18.             System.out.println("getProperty():"+props.getProperty("title"));
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  24. /*
  25. 	运行结果:
  26. 		getProperty():胖先森博客
  27. */
  28. 复制代码

下面的简单了解就好

示例4:将属性文件保存到XML文件中

  1. package com.shxt.demo06;
  2.  
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.util.Properties;
  7.  
  8. public class Demo04 {
  9.     public static void main(String[] args) {
  10.         Properties props = new Properties(); //创建Properties对象
  11.         //设置属性
  12.         props.setProperty("title","胖先森博客");
  13.         props.setProperty("version","v1.0");
  14.         props.setProperty("db","MySQL 5.7");
  15.  
  16.         //跟磁盘中的文件建立联系,文件的后缀名必须为.xml
  17.         File file = new File("D:/sys.xml");
  18.         try {
  19.             props.storeToXML(new FileOutputStream(file),"system config");
  20.  
  21.         } catch (IOException e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  25. }
  26. 复制代码

运行结果:

示例5:从XML文件中读取属性

  1. package com.shxt.demo06;
  2.  
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.util.Properties;
  7.  
  8. public class Demo05 {
  9.     public static void main(String[] args) {
  10.         Properties props = new Properties(); //创建Properties对象
  11.  
  12.         //跟磁盘中的文件建立联系
  13.         File file = new File("D:/sys.xml");
  14.         try {
  15.             //读取XML文件
  16.             props.loadFromXML(new FileInputStream(file));
  17.             //获取属性
  18.             System.out.println("getProperty():"+props.getProperty("title"));
  19.         } catch (IOException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  24. /*
  25. 	运行结果:
  26. 		getProperty():胖先森博客
  27. */
  28. 复制代码

3.认识Properties文件

  • properties文件是一个文本文件
  • properties文件的语法有两种，一种是注释，一种属性配置。
    • 注释：前面加上#号
    • 属性配置：以"键=值"的方式书写一个属性的配置信息,都是字符串。
  • properties文件的一个属性配置信息值可以换行，但键不可以换行。值换行用“\”表示。
  • properties的属性配置键值前后的空格在解析时候会被忽略。
  • properties文件可以只有键而没有值。也可以仅有键和等号而没有值，但无论如何一个属性配置不能没有键。

不推荐的写法

  1. #正确的properties配置文件 
  2. aaa=wu\ 
  3.     kong 
  4. b
  5. bb    =     bajie
  6. 复制代码

推荐的写法

  1. #格式良好的properties文件 
  2. aaa=wukong
  3. bbb=bajie
  4. 复制代码

4.读取Properties文件的方法

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

你需要提供一共绝对路径读取数据,"D:/sys.properties"类似的路径,我个人不怎么推荐使用

  1. package com.shxt.demo06;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.util.Properties;
  6.  
  7. public class Demo06 {
  8.     public static void main(String[] args) {
  9.        Properties props = new Properties();
  10.         try {
  11.             props.load(new FileInputStream("D:/sys.properties"));
  12.             //获取属性
  13.             System.out.println("title属性的值:"+props.getProperty("title"));
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         }
  17.     }
  18. }
  19.  
  20. 复制代码

(2) 使用java.util.ResourceBunld类的getBundle()方法[掌握]

通过ResourceBundle.getBundle()静态方法来获取（ResourceBundle是一个抽象类），这种方式来获取properties属性文件不需要加.properties后缀名，只需要文件名即可.

  • 属性文件在src的根目录下
  1.  
  2. package com.shxt.demo06;
  3.  
  4. import java.util.ResourceBundle;
  5.  
  6. public class Demo07 {
  7.     public static void main(String[] args) {
  8.        ResourceBundle resouce = ResourceBundle.getBundle("sys");
  9.         //获取属性
  10.         System.out.println("title属性的值:"+resouce.getString("title"));
  11.     }
  12. }
  13. 复制代码
  • 属性文件在包com.shxt.demo06
  1. package com.shxt.demo06;
  2.  
  3. import java.util.ResourceBundle;
  4.  
  5. public class Demo08 {
  6.     public static void main(String[] args) {
  7.         //sys为属性文件名，放在包com.shxt.demo06下，如果是放在src下，直接用sys即可
  8.        ResourceBundle resouce = ResourceBundle.getBundle("com/shxt/demo06/sys");
  9.         //获取属性
  10.         System.out.println("title属性的值:"+resouce.getString("title"));
  11.     }
  12. }
  13. 复制代码

(3) 使用PropertyResourceBundle

  1. package com.shxt.demo06;
  2.  
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.util.PropertyResourceBundle;
  6. import java.util.ResourceBundle;
  7.  
  8. public class Demo09 {
  9.     public static void main(String[] args) {
  10.         try {
  11.             ResourceBundle resource =  new PropertyResourceBundle(new FileInputStream("D:/sys.properties"));
  12.             //获取属性
  13.             System.out.println("title属性的值:"+resource.getString("title"));
  14.         } catch (IOException e) {
  15.             e.printStackTrace();
  16.         }
  17.     }
  18. }
  19. 复制代码

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

  1. package com.shxt.demo06;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.Properties;
  6.  
  7. public class Demo11 {
  8.     public static void main(String[] args) {
  9. 		//  /config/sys.properties 从src的根目录开始查找,记住这个"/"
  10.       	// 如果没有这个斜线,那么会报空指针异常
  11.         InputStream in =  Demo11.class.getResourceAsStream("/config/sys.properties");
  12.         Properties props = new Properties();
  13.         try {
  14.             props.load(in);
  15.             //获取属性
  16.             System.out.println("title属性的值:"+props.getProperty("db"));
  17.         } catch (IOException e) {
  18.             e.printStackTrace();
  19.         }
  20.  
  21.     }
  22. }
  23.  
  24. 复制代码

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

  1. package com.shxt.demo06;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.Properties;
  6.  
  7. public class Demo12 {
  8.     public static void main(String[] args) {
  9.  
  10.         InputStream in =  Demo12.class.getClassLoader().getResourceAsStream("config/sys.properties");
  11.         Properties props = new Properties();
  12.         try {
  13.             props.load(in);
  14.             //获取属性
  15.             System.out.println("title属性的值:"+props.getProperty("db"));
  16.         } catch (IOException e) {
  17.             e.printStackTrace();
  18.         }
  19.  
  20.     }
  21. }
  22.  
  23. 复制代码

感觉上就是少了一个斜线而已

(6) 使用java.lang.ClassLoader类的getSystemResourceAsStream()静态方法[推荐]

  1. package com.shxt.demo06;
  2.  
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.util.Properties;
  6.  
  7. public class Demo13 {
  8.     public static void main(String[] args) {
  9.  
  10.         InputStream in =  ClassLoader.getSystemResourceAsStream("config/sys.properties");
  11.         Properties props = new Properties();
  12.         try {
  13.             props.load(in);
  14.             //获取属性
  15.             System.out.println("title属性的值:"+props.getProperty("db"));
  16.         } catch (IOException e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  20. }
  21.  
  22. 复制代码

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

  1. InputStream in = context.getResourceAsStream(path);
  2. Properties p = new Properties();
  3. p.load(in);
  4. 复制代码

5.技术穿越

这里分享一个简单的封装的工具类

  1. package com.pangsir.helper.properties;
  2.  
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import java.io.*;
  6. import java.util.Properties;
  7.  
  8.  
  9. /**
  10.  * 加载属性文件
  11.  *
  12.  * @author 刘文铭
  13.  * @see com.pangsir.helper.properties.PropertiesConfigHelper
  14.  * @since 1.0
  15.  */
  16. public class PropertiesConfigHelper {
  17.     private PropertiesConfigHelper(){}
  18.  
  19.     //使用日志输出
  20.     private final static Logger logger = LoggerFactory.getLogger(PropertiesConfigHelper.class);
  21.     //设置后缀名
  22.     private final static String EXT = ".properties";
  23.     //实例化Properties对象
  24.     private static Properties configProperties = null;
  25.  
  26.     /**
  27.      * 加载properties文件
  28.      *
  29.      * @param filepaths properties文件路径
  30.      */
  31.     public static void load(String... filepaths) {
  32.         logger.debug("开始读取properties文件 开始时间" + System.currentTimeMillis());
  33.         if(configProperties==null){
  34.             configProperties = new Properties();
  35.         }
  36.         //配置文件路径
  37.         String configFilePath;
  38.         InputStream inputStream = null;
  39.         //遍历filepathke数组
  40.         for (int i = 0; i < filepaths.length; i++) {
  41.             configFilePath = filepaths[i];
  42.             //读取属性文件后缀名为.properties
  43.             try {
  44.                 if (configFilePath.toLowerCase().endsWith(EXT)) {
  45.                     inputStream = PropertiesConfigHelper.class.getClassLoader().getResourceAsStream(configFilePath);
  46.                     configProperties.load(inputStream);
  47.                 } else {
  48.                     throw new RuntimeException("无法读取该文件: " + configFilePath);
  49.                 }
  50.                 logger.debug("文件 \"" + configFilePath + "\" 读取 成功! 时间为:" + System.currentTimeMillis());
  51.             } catch (Exception e) {
  52.                 logger.debug("文件 \"" + configFilePath + "\" 读取 失败, 失败异常信息:\\n" + e.getMessage());
  53.                 throw new RuntimeException("文件 \"" + configFilePath + "\" 加载失败", e);
  54.             } finally {
  55.                 if (inputStream != null) {
  56.                     try {
  57.                         inputStream.close();
  58.                     } catch (IOException e) {
  59.                         logger.debug("所有配置文件读取完毕,当关闭文件FileInputStream时，异常信息 :\\n" + e.getMessage());
  60.                     }
  61.                 }
  62.             }
  63.  
  64.         }
  65.  
  66.     }
  67.  
  68.     /**
  69.      * 获取 int 类型的配置属性的value
  70.      *
  71.      * @param key          配置属性的key
  72.      * @param defaultValue 默认值
  73.      * @return 对应的配置属性value，如果配置属性的value不为short类型或不存在对应的配置属性，则返回 defaultValue
  74.      */
  75.     public static Short getShortValue(String key, Short defaultValue) {
  76.         try {
  77.             return getShortValue(key);
  78.         } catch (NumberFormatException e) {
  79.             return defaultValue;
  80.         }
  81.     }
  82.  
  83.     /**
  84.      * 获取 short 类型的配置属性的value
  85.      *
  86.      * @param key 配置属性的key
  87.      * @return 对应的配置属性value
  88.      */
  89.     public static Short getShortValue(String key) {
  90.         return Short.parseShort(configProperties.getProperty(key));
  91.     }
  92.  
  93.     /**
  94.      * 获取 int 类型的配置属性的value
  95.      *
  96.      * @param key          配置属性的key
  97.      * @param defaultValue 默认值
  98.      * @return 对应的配置属性value，如果配置属性的value不为int类型或不存在对应的配置属性，则返回 defaultValue
  99.      */
  100.     public static int getIntegerValue(String key, Integer defaultValue) {
  101.         try {
  102.             return getIntegerValue(key);
  103.         } catch (NumberFormatException e) {
  104.             return defaultValue;
  105.         }
  106.     }
  107.  
  108.     /**
  109.      * 获取 int 类型的配置属性的value
  110.      *
  111.      * @param key 配置属性的key
  112.      * @return 对应的配置属性value
  113.      */
  114.     public static Integer getIntegerValue(String key) {
  115.         return Integer.parseInt(configProperties.getProperty(key));
  116.     }
  117.  
  118.  
  119.     /**
  120.      * 获取 float 类型的配置属性的value
  121.      *
  122.      * @param key          配置属性的key
  123.      * @param defaultValue 默认值
  124.      * @return 对应的配置属性value，如果配置属性的value不为float类型或不存在对应的配置属性，则返回 defaultValue
  125.      */
  126.     public static Float getFloatValue(String key, float defaultValue) {
  127.         try {
  128.             return getFloatValue(key);
  129.         } catch (NumberFormatException e) {
  130.             return defaultValue;
  131.         }
  132.     }
  133.  
  134.     /**
  135.      * 获取 float 类型的配置属性的value
  136.      *
  137.      * @param key 配置属性的key
  138.      * @return 对应的配置属性value
  139.      */
  140.     public static Float getFloatValue(String key) {
  141.         return Float.parseFloat(configProperties.getProperty(key));
  142.     }
  143.  
  144.     /**
  145.      * 获取 double 类型的配置属性的value
  146.      *
  147.      * @param key 配置属性的key
  148.      * @param defaultValue 默认值
  149.      * @return 对应的配置属性value，如果配置属性的value不为double类型或不存在对应的配置属性，则返回 defaultValue
  150.      */
  151.     public static Double getDoubleValue(String key, double defaultValue) {
  152.         try {
  153.             return getDoubleValue(key);
  154.         } catch (NumberFormatException e) {
  155.             return defaultValue;
  156.         }
  157.     }
  158.     /**
  159.      * 获取 Double 类型的配置属性的value
  160.      *
  161.      * @param key 配置属性的key
  162.      * @return 对应的配置属性value
  163.      */
  164.     public static Double getDoubleValue(String key) {
  165.         return Double.parseDouble(configProperties.getProperty(key));
  166.     }
  167.  
  168.  
  169.  
  170.     /**
  171.      * 获取 long 类型的配置属性的value
  172.      *
  173.      * @param key 配置属性的key
  174.      * @param defaultValue 默认值
  175.      * @return 对应的配置属性value，如果配置属性的value不为long类型或不存在对应的配置属性，则返回 defaultValue
  176.      */
  177.     public static Long getLongValue(String key, long defaultValue) {
  178.         try {
  179.             return getLongValue(key);
  180.         } catch (NumberFormatException e) {
  181.             return defaultValue;
  182.         }
  183.     }
  184.     /**
  185.      * 获取 Long 类型的配置属性的value
  186.      *
  187.      * @param key 配置属性的key
  188.      * @return 对应的配置属性value
  189.      */
  190.     public static Long getLongValue(String key) {
  191.         return Long.parseLong(configProperties.getProperty(key));
  192.     }
  193.  
  194.  
  195.  
  196.     /**
  197.      * 获取 String 类型的配置属性的value
  198.      *
  199.      * @param key 配置属性的key
  200.      * @param defaultValue 默认值
  201.      * @return 对应的配置属性value，如果配置属性的value为""或不存在对应的配置属性，则返回 defaultValue
  202.      */
  203.     public static String getStringValue(String key, String defaultValue) {
  204.         String value = configProperties.getProperty(key);
  205.         return (value == null) ? defaultValue : getStringValue(key);
  206.     }
  207.     /**
  208.      * 获取 String 类型的配置属性的value
  209.      *
  210.      * @param key 配置属性的key
  211.      * @return 对应的配置属性value
  212.      */
  213.     public static String getStringValue(String key) {
  214.         return configProperties.getProperty(key);
  215.     }
  216.  
  217.     /**
  218.      * 获取 boolean 类型的配置属性的value
  219.      *
  220.      * @param key 配置属性的key
  221.      * @param defaultValue 默认值
  222.      * @return 如果在配置文件中没有定义此属性，则返回 defaultValue;
  223.      *         如果 value 为y、on、yes 、true 或非 0 数值(均不区分大小写) 则返回 true, 否则返回 false
  224.      */
  225.     public static boolean getBooleanValue(String key, Boolean defaultValue) {
  226.         String value = configProperties.getProperty(key);
  227.         return (value == null) ? defaultValue : getBooleanValue(key);
  228.     }
  229.     /**
  230.      * 获取 boolean 类型的配置属性的value
  231.      *
  232.      * @param key 配置属性的key
  233.      * @return 对应的配置属性value
  234.      */
  235.     public static Boolean getBooleanValue(String key) {
  236.         String value = configProperties.getProperty(key);
  237.         return ("y".equalsIgnoreCase(value)) || ("on".equalsIgnoreCase(value)) || ("yes".equalsIgnoreCase(value))
  238.                 || ("true".equalsIgnoreCase(value)) || (getIntegerValue(key, 0) != 0);
  239.     }
  240.     /**
  241.      * 加载properties文件
  242.      *
  243.      * @param filepath properties文件路径
  244.      */
  245.     public static void write(String key, String value,String filepath){
  246.         if(configProperties==null){
  247.             configProperties = new Properties();
  248.         }
  249.  
  250.         OutputStream outputStream = null;
  251.         try{
  252.             String base = PropertiesConfigHelper.class.getResource("/"+filepath).getPath();
  253.             java.net.URL url = PropertiesConfigHelper.class.getResource("/"+filepath);
  254.             File file = new File(url.toURI());
  255.             //判断文件是否存在
  256.             if(!file.exists()){
  257.                 file.createNewFile();
  258.             }
  259.  
  260.             load(filepath);//加载文件
  261.  
  262.             outputStream = new FileOutputStream(file);
  263.  
  264.             configProperties.setProperty(key,value);
  265.  
  266.             configProperties.store(outputStream,"");
  267.  
  268.  
  269.         }catch (Exception e){
  270.             throw new RuntimeException("文件 \"" + filepath + "\" 加载失败", e);
  271.         }finally {
  272.             if (outputStream != null) {
  273.                 try {
  274.                     outputStream.close();
  275.                 } catch (IOException e) {
  276.                     logger.debug("所有配置文件修改完毕,FileOutputStream异常信息 :\\n" + e.getMessage());
  277.                 }
  278.             }
  279.         }
  280.  
  281.     }
  282. }
  283.  
  284. 复制代码

重点:将properties文件的配置设置为整个Web应用的全局变量实现方法,学到J2EE阶段再使用下面的方式

WEB域的简单说明:

Web应用中的变量存放在不同的jsp对象中，会有不一样的作用域，四种不同的作用域排序是 pageContext < request < session < application;

  • pageContext：页面域，仅当前页面有效，离开页面后，不论重定向还是转向（即无论是redirect还是forward），pageContext的属性值都失效；
  • request：请求域，在一次请求中有效，如果用forward转向，则下一次请求还可以保留上一次request中的属性值，而redirect重定向跳转到另一个页面则会使上一次request中的属性值失效；
  • session：会话域，在一次会话过程中（从浏览器打开到浏览器关闭这个过程），session对象的属性值都保持有效，在这次会话过程，session中的值可以在任何页面获取；
  • application：应用域，只要应用不关闭，该对象中的属性值一直有效，并且为所有会话所共享

思路说明:

利用ServletContextListener监听器，一旦应用加载，就将properties的值存储到application当中.

现在需要在所有的jsp中都能通过EL表达式读取到properties中的属性，并且是针对所有的会话，故这里利用application作用域，那么什么时候将properties中的属性存储到application呢？因为是将properties的属性值作为全局的变量以方便任何一次EL的获取，所以在web应用加载的时候就将值存储到application当中.

这里就要利用ServletContextListener：

  • ServletContextListener是Servlet API 中的一个接口，它能够监听 ServletContext 对象的生命周期，实际上就是监听 Web 应用的生命周期。
  • 当Servlet 容器启动或终止Web 应用时，会触发ServletContextEvent 事件，该事件由ServletContextListener 来处理。

具体步骤:

  • (1) 新建一个类PropertyListenter实现 ServletContextListener接口的contextInitialized方法；
  • (2) 读取properties配置文件，转存到Map当中；
  • (3) 使用ServletContext对象将Map存储到application作用域中；
  1. /**
  2.  * 设值全局变量
  3.  */
  4. public class PropertyListenter implements ServletContextListener {
  5.  private static final Logger logger = (Logger) LoggerFactory.getLogger(PropertyListenter.class);
  6.  @Override
  7.  public void contextDestroyed(ServletContextEvent context) {}
  8.  @Override
  9.  public void contextInitialized(ServletContextEvent sce) {
  10.   /**
  11.    * 读取properties文件
  12.    */
  13.   Properties properties = new Properties(); 
  14.   
  15.   InputStream in = null;
  16.   try {
  17.    //通过类加载器进行获取properties文件流
  18.    in = PropertiesUtil.class.getClassLoader().getResourceAsStream("sys.properties");   
  19.    properties.load(in);
  20.    
  21.   } catch (FileNotFoundException e) {
  22.    logger.error("未找到properties文件");
  23.   } catch (IOException e) {
  24.    logger.error("发生IOException异常");
  25.   } finally {
  26.    try {
  27.     if(null != in) {
  28.      in.close();
  29.     }
  30.    } catch (IOException e) {
  31.     logger.error("properties文件流关闭出现异常");
  32.    }
  33.   }
  34.       
  35.   /**
  36.    * 将properties文件转存到map.关键步骤
  37.    */
  38.   Map<String, String> pros = new HashMap<String,String>((Map)properties);
  39.   
  40.   /**
  41.    * 将Map通过ServletContext存储到全局作用域中
  42.    */
  43.   ServletContext sct=sce.getServletContext(); 
  44.   
  45.   sct.setAttribute("pros", pros);
  46.  
  47.  }
  48.  
  49.  
  50. }
  51. 复制代码
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/260666
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号