深入浅出的分析 Properties

开发 后端
最近在看 java 集合源码的时候,发现原来我们经常使用的 Properties 类既然继承自 Hashtable!又涨见识了!

 最近在看 java 集合源码的时候,发现原来我们经常使用的 Properties 类既然继承自 Hashtable!又涨见识了!

[[281908]]

01. 摘要

在集合系列的第一章,咱们了解到,Map 的实现类有 HashMap、LinkedHashMap、TreeMap、IdentityHashMap、WeakHashMap、Hashtable、Properties 等等。

在上一章节中,咱们介绍到 Hashtable 的数据结构和算法实现,在 Java 中其实还有一个非常重要的类 Properties,它继承自 Hashtable,主要用于读取配置文件。

本文通过看 JDK 和一些网友的博客总结,主要从 Properties 的用法实例来做介绍,如果有理解不当之处,欢迎指正。

02. 简介

Properties 类是 java 工具包中非常重要的一个类,比如在实际开发中,有些变量,我们可以直接硬写入到自定义的 java 枚举类中。

但是有些变量,在测试环境、预生产环境、生产环境,变量所需要取的值都不一样,这个时候,我们可以通过使用 properties 文件来加载程序需要的配置信息,以达到一行代码,多处环境都可以运行的效果!

最常见的比如 JDBC 数据源配置文件,properties文件以.properties作为后缀,文件内容以键=值格式书写,左边是变量名称,右边是变量值,用#做注释,比如新建一个jdbc.properties文件,内容如下:

Properties 类是 properties 文件和程序的中间桥梁,不论是从 properties 文件读取信息,还是写入信息到 properties 文件,都要经由 Properties 类。

好了,唠叨了这么多,咱们回到本文要介绍的主角Properties!

从集合 Map 架构图可以看出,Properties 继承自 Hashtable,表示一个持久的 map 集合,属性列表以 key-value 的形式存在,Properties 类定义如下:

  1. public class Properties extends Hashtable<Object,Object> { 
  2.     ...... 

Properties 除了继承 Hashtable 中所定义的方法,Properties 也定义了以下几个常用方法,如图所示:

 

常用方法介绍

set 方法(添加修改元素)

set 方法是将指定的 key, value 对添加到 map 里,在添加元素的时候,调用了 Hashtable 的 put 方法,与 Hashtable 不同的是, key 和 value 都是字符串。

打开 Properties 的 setProperty 方法,源码如下:

  1. public synchronized Object setProperty(String key, String value) { 
  2.     //调用父类 Hashtable 的 put 方法 
  3.     return put(key, value); 

方法测试如下:

  1. public static void main(String[] args) { 
  2.     Properties properties = new Properties(); 
  3.     properties.setProperty("name1","张三"); 
  4.     properties.setProperty("name2","张四"); 
  5.     properties.setProperty("name3","张五"); 
  6.     System.out.println(properties.toString()); 

输出结果:

{name3=张五, name2=张四, name1=张三}

get 方法(搜索指定元素)

get 方法根据指定的 key 值返回对应的 value,第一步是从调用 Hashtable 的 get 方法,如果有返回值,直接返回;如果没有返回值,但是初始化时传入了defaults变量,从 defaults变量中,也就是 Properties 中,去搜索是否有对于的变量,如果有就返回元素值。

打开 Properties 的 getProperty 方法,源码如下:

  1. public String getProperty(String key) { 
  2.     //调用父类 Hashtable 的 get 方法 
  3.     Object oval = super.get(key); 
  4.     String sval = (oval instanceof String) ? (String)oval : null
  5.      //进行变量非空判断 
  6.     return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval; 

查看 defaults 这个变量,源码如下:

  1. public class Properties extends Hashtable<Object,Object> { 
  2.     protected Properties defaults; 

这个变量在什么时候赋值呢,打开源码如下:

  1. public Properties(Properties defaults) { 
  2.     this.defaults = defaults; 

可以发现,在 Properties 构造方法初始化阶段,如果你给了一个自定义的 defaults ,当调用 Hashtable 的 get 方法没有搜索到元素值的时候,并且 defaults 也不等于空,那么就会进一步在 defaults 里面进行搜索元素值。

方法测试如下:

  1. public static void main(String[] args) { 
  2.     Properties properties = new Properties(); 
  3.     properties.setProperty("name1","张三"); 
  4.     properties.setProperty("name2","张四"); 
  5.     properties.setProperty("name3","张五"); 
  6.     //将 properties 作为参数初始化到 newProperties 中 
  7.     Properties newProperties = new Properties(properties); 
  8.     newProperties.setProperty("name4","李三"); 
  9.     //查询key中 name1 的值 
  10.     System.out.println("查询结果:" + properties.getProperty("name1")); 

输出结果:

通过key查询结果:张三

load方法(加载配置文件)

load 方法,表示将 properties 文件以输入流的形式加载文件,并且提取里面的键、值对,将键值对元素添加到 map 中去。

打开 Properties 的 load 方法,源码如下:

  1. public synchronized void load(InputStream inStream) throws IOException { 
  2.     //读取文件流 
  3.     load0(new LineReader(inStream)); 

load0 方法,源码如下:

  1. private void load0 (LineReader lr) throws IOException { 
  2.     char[] convtBuf = new char[1024]; 
  3.     int limit; 
  4.     int keyLen; 
  5.     int valueStart; 
  6.     char c; 
  7.     boolean hasSep; 
  8.     boolean precedingBackslash; 
  9.  
  10.     //一行一行的读取 
  11.     while ((limit = lr.readLine()) >= 0) { 
  12.         c = 0; 
  13.         keyLen = 0; 
  14.         valueStart = limit; 
  15.         hasSep = false
  16.  
  17.         precedingBackslash = false
  18.         //判断key的长度 
  19.         while (keyLen < limit) { 
  20.             c = lr.lineBuf[keyLen]; 
  21.             if ((c == '=' ||  c == ':') && !precedingBackslash) { 
  22.                 valueStart = keyLen + 1; 
  23.                 hasSep = true
  24.                 break; 
  25.             } else if ((c == ' ' || c == '\t' ||  c == '\f') && !precedingBackslash) { 
  26.                 valueStart = keyLen + 1; 
  27.                 break; 
  28.             } 
  29.             if (c == '\\') { 
  30.                 precedingBackslash = !precedingBackslash; 
  31.             } else { 
  32.                 precedingBackslash = false
  33.             } 
  34.             keyLen++; 
  35.         } 
  36.         //获取值的起始位置 
  37.         while (valueStart < limit) { 
  38.             c = lr.lineBuf[valueStart]; 
  39.             if (c != ' ' && c != '\t' &&  c != '\f') { 
  40.                 if (!hasSep && (c == '=' ||  c == ':')) { 
  41.                     hasSep = true
  42.                 } else { 
  43.                     break; 
  44.                 } 
  45.             } 
  46.             valueStart++; 
  47.         } 
  48.         //获取文件中的键和值参数 
  49.         String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf); 
  50.         String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf); 
  51.         //调用 Hashtable 的 put 方法,将键值加入 map 中 
  52.         put(key, value); 
  53.     } 

好了,我们来在src/recources目录下,新建一个custom.properties配置文件,内容如下:

  1. #定义一个变量名称和值 
  2. userName=李三 
  3. userPwd=123456 
  4. userAge=18 
  5. userGender=男 
  6. userEmail=123@123.com 

方法测试如下:

  1. public class TestProperties  { 
  2.  
  3.     public static void main(String[] args) throws Exception { 
  4.         //初始化 Properties 
  5.         Properties prop = new Properties(); 
  6.         //加载配置文件 
  7.         InputStream in = TestProperties .class.getClassLoader().getResourceAsStream("custom.properties"); 
  8.         //读取配置文件,指定编码格式,避免读取中文乱码 
  9.         prop.load(new InputStreamReader(in"UTF-8")); 
  10.         //将内容输出到控制台 
  11.         prop.list(System.out); 
  12.     } 

输出结果:

userPwd=123456

userEmail=123@123.com

userAge=18

userName=李三

userGender=男

propertyNames方法(读取全部信息)

propertyNames 方法,表示读取 Properties 的全部信息,本质是创建一个新的 Hashtable 对象,然后将原 Hashtable 中的数据复制到新的 Hashtable 中,并将 map 中的 key 全部返回。

打开 Properties 的 propertyNames 方法,源码如下:

  1. public Enumeration<?> propertyNames() { 
  2.     Hashtable<String,Object> h = new Hashtable<>(); 
  3.     //将原 map 添加到新的 Hashtable 中 
  4.     enumerate(h); 
  5.     //返回 Hashtable 中全部的 key 元素 
  6.     return h.keys(); 

enumerate 方法,源码如下:

  1. private synchronized void enumerate(Hashtable<String,Object> h) { 
  2.     //判断 Properties 中是否有初始化的配置文件 
  3.     if (defaults != null) { 
  4.         defaults.enumerate(h); 
  5.     } 
  6.     //将原 Hashtable 中的数据添加到新的 Hashtable 中 
  7.     for (Enumeration<?> e = keys() ; e.hasMoreElements() ;) { 
  8.         String key = (String)e.nextElement(); 
  9.         h.put(key, get(key)); 
  10.     } 

方法测试如下:

  1. public static void main(String[] args) throws Exception { 
  2.     //初始化 Properties 
  3.     Properties prop = new Properties(); 
  4.     //加载配置文件 
  5.     InputStream in = TestProperties.class.getClassLoader().getResourceAsStream("custom.properties"); 
  6.     //读取配置文件,指定读取编码 UTF-8,防止内容乱码 
  7.     prop.load(new InputStreamReader(in"UTF-8")); 
  8.     //获取 Properties 中全部的 key 元素 
  9.     Enumeration enProp = prop.propertyNames(); 
  10.     while (enProp.hasMoreElements()){ 
  11.         String key = (String) enProp.nextElement(); 
  12.         String value = prop.getProperty(key); 
  13.         System.out.println(key + "=" + value); 
  14.     } 

输出内容如下:

userPwd=123456

userEmail=123@123.com

userAge=18

userName=李三

userGender=男

总结

Properties 继承自 Hashtable,大部分方法都复用于 Hashtable,比如,get、put、remove、clear 方法,**与 Hashtable 不同的是, Properties中的 key 和 value 都是字符串,**如果需要获取 properties 中全部内容,可以先通过迭代器或者 propertyNames 方法获取 map 中所有的 key 元素,然后遍历获取 key 和 value。

需要注意的是,Properties 中的 setProperty 、load 方法,都加了synchronized同步锁,用来控制线程同步。

03. properties 文件的加载方式

在实际开发中,经常会遇到读取配置文件路径找不到,或者读取文件内容乱码的问题,下面简单介绍一下,properties 文件的几种常用的加载方式。

properties 加载文件的方式,大致可以分两类,第一类是使用 java.util.Properties 的 load 方法来加载文件流;第二类是使用 java.util.ResourceBundle 类来获取文件内容。

在src/recources目录下,新建一个custom.properties配置文件,文件编码格式为UTF-8,内容还是以刚刚那个测试为例,各个加载方式如下!

通过文件路径来加载文件

这类方法加载文件,主要是调用 Properties 的 load 方法,获取文件路径,读取文件以流的形式加载文件。

方法如下:

  1. Properties prop = new Properties(); 
  2. //获取文件绝对路径 
  3. String filePath = "/coding/java/src/resources/custom.properties"
  4. //加载配置文件 
  5. InputStream in = new FileInputStream(new File(filePath)); 
  6. //读取配置文件 
  7. prop.load(new InputStreamReader(in"UTF-8")); 
  8. System.out.println("userName:"+prop.getProperty("userName")); 

输出结果:

userName:李三 

通过当前类加载器的getResourceAsStream方法获取

这类方法加载文件,也是调用 Properties 的 load 方法,不同的是,通过类加载器来获取文件路径,如果当前文件是在src/resources目录下,那么直接传入文件名就可以了。

方法如下:

  1. Properties prop = new Properties(); 
  2. //加载配置文件 
  3. InputStream in = TestProperties.class.getClassLoader().getResourceAsStream("custom.properties"); 
  4. //读取配置文件 
  5. prop.load(new InputStreamReader(in"UTF-8")); 
  6. System.out.println("userName:"+prop.getProperty("userName")); 

输出结果:

userName:李三 

使用ClassLoader类的getSystemResourceAsStream方法获取

和上面类似,也是通过类加载器来获取文件流,方法如下:

Properties prop = new Properties();//加载配置文件InputStream in = ClassLoader.getSystemResourceAsStream("custom.properties");//读取配置文件prop.load(new InputStreamReader(in, "UTF-8"));System.out.println("userName:"+prop.getProperty("userName"));

输出结果:

userName:李三

使用 ResourceBundle 类加载文件

ResourceBundle 类加载文件,与 Properties 有所不同,ResourceBundle 获取 properties 文件不需要加.properties后缀名,只需要文件名即可。

ResourceBundle 是按照iso8859编码格式来读取原属性文件,如果是读取中文内容,需要进行转码处理。

方法如下:

  1. //加载custom配置文件,不需要加`.properties`后缀名 
  2. ResourceBundle resource = ResourceBundle.getBundle("custom"); 
  3. //转码处理,解决读取中文内容乱码问题 
  4. String value = new String(resource.getString("userName").getBytes("ISO-8859-1"),"UTF-8"); 
  5. System.out.println("userName:"+value); 

输出结果:

userName:李三

04. 总结

从源码上可以看出,Properties 继承自 Hashtable,大部分方法都复用于 Hashtable,与 Hashtable 不同的是, Properties 中的 key 和 value 都是字符串。

实际开发中,Properties 主要用于读取配置文件,尤其是在不同的环境下,变量值需要不一样的情况,可以通过读取配置文件来避免将变量值写死在 java 的枚举类中,以达到一行代码,多处运行的目的!

在读取 Properties 配置文件的时候,容易因文件路径找不到报错,可以参考 properties 文件加载的几种方式,

责任编辑:华轩 来源: Java极客技术
相关推荐

2019-11-14 09:53:30

Set集合存储

2021-03-16 08:54:35

AQSAbstractQueJava

2011-07-04 10:39:57

Web

2013-11-14 15:53:53

AndroidAudioAudioFlinge

2022-12-02 09:13:28

SeataAT模式

2009-11-30 16:46:29

学习Linux

2019-01-07 15:29:07

HadoopYarn架构调度器

2012-05-21 10:06:26

FrameworkCocoa

2017-07-02 18:04:53

块加密算法AES算法

2021-07-20 15:20:02

FlatBuffers阿里云Java

2022-09-26 09:01:15

语言数据JavaScript

2015-08-06 14:02:31

数据分析

2018-03-15 09:13:43

MySQL存储引擎

2023-03-20 09:48:23

ReactJSX

2018-11-09 16:24:25

物联网云计算云系统

2012-02-21 13:55:45

JavaScript

2021-04-27 08:54:43

ConcurrentH数据结构JDK8

2009-11-18 13:30:37

Oracle Sequ

2022-01-11 07:52:22

CSS 技巧代码重构

2019-12-04 10:13:58

Kubernetes存储Docker
点赞
收藏

51CTO技术栈公众号