【源码】Properties

发表于 | 分类于

介绍

Properties类抽象了一个持久的属性集，可以被存储到一个流中或从一个流中加载。Properties里面的key和value都是String类型。Properites继承自HashTable，但是要避免使用put和putAll方法，防止放入非String类型的数据，应该使用setProperty方法

一个属性集可以包含另一个属性集作为他的默认属性，当一个属性键在原始的Properties中找不着时，才会搜索这个默认属性集。

Properties还支持对xml的读取和存储。

常量&变量

1
2
3
4
5
6
7
8
// 默认属性集
protected Properties defaults;
//十六进制数常量
private static final char[] hexDigit = {
    '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
};

load

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
//将流封装成Properties.LineReader，然后用load0读取properties，LineReader是面向行读取的Reder
public synchronized void load(Reader reader) throws IOException {
    load0(new LineReader(reader));
}
public synchronized void load(InputStream inStream) throws IOException {
    load0(new LineReader(inStream));
}
/*
行分为自然行和逻辑行。自然行被定义为以("\n","\r","\r\n"，eof)任一结尾的字符行。
自然行也可以是空行，注释行(#,!作为第一个非空白字符的行)，或者保存了全部或部分键-元素对的字符行。
逻辑行保存了所有键-元素对的数据，可能分散在多个相邻的自然行中，用反斜杠字符 \ 转义行结束符序列。
key和value中间的分隔符可以是":"、"="，" "，分隔符左右两侧的空格会被删掉，key前的空格也会被去掉
*/
 private void load0(LineReader lr) throws IOException {
    char[] convtBuf = new char[1024];
    int limit;  // 字符总数
    int keyLen; // key的长度
    int valueStart; // value的起始位置
    char c;
    boolean hasSep;
    boolean precedingBackslash; // 是否是转义字符
    while ((limit = lr.readLine()) >= 0) {
        c = 0;
        keyLen = 0;
        // value的起始位置默认为limit
        valueStart = limit;
        hasSep = false;
        precedingBackslash = false;
        // keyLen < limit
        while (keyLen < limit) {
            c = lr.lineBuf[keyLen];
            // 检测到非空格分隔符且前面的字符没有转义
            if ((c == '=' || c == ':') && !precedingBackslash) {
                //下一个就是value开始的位置
                valueStart = keyLen + 1;
                // 并且指定，去除空格
                hasSep = true;
                break;
            } else if ((c == ' ' || c == '\t' || c == '\f') && !precedingBackslash) {
                // 检测到空格分隔符
                valueStart = keyLen + 1;
                break;
            }
            // 检测到'\'，记录
            if (c == '\\') {
                precedingBackslash = !precedingBackslash;
            } else {
                precedingBackslash = false;
            }
            //前进一位
            keyLen++;
        }
        // valueStart < limit
        while (valueStart < limit) 
            c = lr.lineBuf[valueStart];
            // 判断是否是空格类字符
            if (c != ' ' && c != '\t' && c != '\f') {
                // 不是空格类字符，并且第一次出现非空格分隔符
                if (!hasSep && (c == '=' || c == ':')) {
                    hasSep = true;
                } else {
                    break;
                }
            }
            valueStart++;
        }
        // 读取key和value
        String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);
        String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf);
        // 放入
        put(key, value);
    }
}

store

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// 存储，给定Writer或OutStreamWriter和comments
public void store(Writer writer, String comments)
    throws IOException
{
    store0((writer instanceof BufferedWriter)?(BufferedWriter)writer
     : new BufferedWriter(writer),comments,false);
}
private void store0(BufferedWriter bw, String comments, boolean escUnicode) throws IOException {
        if (comments != null) {
            // 写入注释,用 8859-1存储中文
            writeComments(bw, comments);
        }
        // 写入时间
        bw.write("#" + new Date().toString());
        //另起一行
        bw.newLine();
        // 同步
        synchronized (this) {
            for (Enumeration e = keys(); e.hasMoreElements();) {
                String key = (String) e.nextElement();
                String val = (String) get(key);
                // 对key中的空格转义
                key = saveConvert(key, true, escUnicode);
                // 不转义value的的空格
                val = saveConvert(val, false, escUnicode);
                // 写入按照key=value
                bw.write(key + "=" + val);
                bw.newLine();
            }
        }
        bw.flush();
    }

getProperty

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//获取属性
public String getProperty(String key) {
    Object oval = super.get(key
    //存储的不是字符串就返回null
    String sval = (oval instanceof String) ? (String)oval : null;
    //如果默认属性中存在就返回
    return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
}
//给定默认值
public String getProperty(String key, String defaultValue) {
    String val = getProperty(key);
    //默认属性集的优先级要高于给定的默认值
    return (val == null) ? defaultValue : val;
}

setProperty

1
2
3
4
5
// 同步方法
public synchronized Object setProperty(String key, String value) {
    return put(key, value);
}

list

1
2
3
4
5
6
7
//打印属性集
public void list(PrintWriter out);
public void list(PrintStream out);
//exm：直接打印到标准输出流
properties.list(System.out);