Apache Shiro 学习记录5

本来这篇文章是想写从Factory加载ini配置到生成securityManager的过程的。。。。但是貌似涉及的东西有点多。。。我学的又比较慢。。。很多类都来不及研究，我又怕等我后面的研究了前面的都忘记了。。。所以就先与大家分享一下我对Shiro里Ini这个类的研究。

 

简介

我感觉其实利用ini来配置shiro在实际应用中应该不是很多，我想大部分java应用还是web类型的，数据也应该储存在数据库里。。不会简简单单的存在.ini这样的配置文件中的。。。但是对于学习Shiro来说，我觉得研究一下这个类也无妨。。Ini配置文件是怎么写的，我就不介绍了，网上一大把。。我就说说Ini这个类的主要作用与一些值得注意的地方。

Shiro加载.ini配置文件以后会生成一个Ini类的对象，这个Ini类的对象就储存了配置文件的信息。

 

Ini

Ini实现了Map<String, Ini.Section>，它又有一个sections对象，也是Map<String, Section>类型的，所有Ini类上的Map接口的操作实际上都是操作sections对象。

Ini的主要作用就是解析.ini文件，从.ini中解析出多个section，放到sections成员域中。

public class Ini implements Map<String, Ini.Section> {

    private static transient final Logger log = LoggerFactory.getLogger(Ini.class);

    public static final String DEFAULT_SECTION_NAME = ""; //empty string means the first unnamed section
    public static final String DEFAULT_CHARSET_NAME = "UTF-8";

    public static final String COMMENT_POUND = "#";
    public static final String COMMENT_SEMICOLON = ";";
    public static final String SECTION_PREFIX = "[";
    public static final String SECTION_SUFFIX = "]";

    protected static final char ESCAPE_TOKEN = '\\';

    private final Map<String, Section> sections;

    ...............
}

Map中key是String类型的（废话，大家都知道。。。），value是Section类型的，Section是Ini类里的一个静态内部类。

那么这么一个Map有什么用处呢？用Shiro的话来回答：

An Ini instance is a map of Sections, keyed by section name. Each Section is itself a map of String name/value pairs. Name/value pairs are guaranteed to be unique within each Section only - not across the entire Ini instance.

意思就是说Ini这个Map，key是Section的名字，就是ini配置文件中[]中的部分，value则是Section。

.ini文件中的key并不是整个.ini唯一的，而是每个section唯一的，要问为什么的话，就是因为每个section都是Ini类中的Map中的一个键值对，而.ini文件中的key又是section中的Map中的键值对，所以并不会相互影响（绕口令....看了Section那一节应该就明白了...），这点请注意。

 

介绍一下Ini中的一些方法：

    public static Ini fromResourcePath(String resourcePath) throws ConfigurationException {
        if (!StringUtils.hasLength(resourcePath)) {
            throw new IllegalArgumentException("Resource Path argument cannot be null or empty.");
        }
        Ini ini = new Ini();
        ini.loadFromPath(resourcePath);
        return ini;
    }

这个方法很短也很简单，介绍他主要是因为它会被Factory调用，来加载ini文件，Factory中会new一个Ini，然后调用这个方法。

另外这个方法会调用loadFromPath来加载ini配置。

而loadFromPath会调用load方法来加载ini配置，所以说其实这些方法都没有做什么事实，最多就是读取文件，最后其实都是调用了load方法来真正解析ini文件。

 

load

load方法被重载了10000次。。。。。最终都会调用load(Scanner scanner)这个方法。。。

  public void load(Scanner scanner) {

        String sectionName = DEFAULT_SECTION_NAME;
        StringBuilder sectionContent = new StringBuilder();

        while (scanner.hasNextLine()) {

            String rawLine = scanner.nextLine();
            String line = StringUtils.clean(rawLine);

            if (line == null || line.startsWith(COMMENT_POUND) || line.startsWith(COMMENT_SEMICOLON)) {
                //skip empty lines and comments:
                continue;
            }

            String newSectionName = getSectionName(line);
            if (newSectionName != null) {
                //found a new section - convert the currently buffered one into a Section object
                addSection(sectionName, sectionContent);

                //reset the buffer for the new section:
                sectionContent = new StringBuilder();

                sectionName = newSectionName;

                if (log.isDebugEnabled()) {
                    log.debug("Parsing " + SECTION_PREFIX + sectionName + SECTION_SUFFIX);
                }
            } else {
                //normal line - add it to the existing content buffer:
                sectionContent.append(rawLine).append("\n");
            }
        }

        //finish any remaining buffered content:
        addSection(sectionName, sectionContent);
    }

这个方法就是一行一行读取ini，如果是;或者#开头，则认为这是注释行，忽略。

否则就去调用getSectionName（第16行）这个方法。这个方法会判断一行是否是[开头，]结尾，是说明这个是一个section的name，否则就是section的content。

如果是下一个section的name，就先保存上个section的name和content（第19行），并重新赋值sectionName局部变量。

不是下一个section的name，就说明这一行是content，那么就调用31行的append方法，把content append到sectionContent上面。

这个方法做完，ini配置文件就被解析成了很多小的Section，也就是说完成了sections属性的解析，后面每个section的解析就留到Section这个静态内部类中来完成。

 

 

 

Section

Section又是一个Map（Map<String, String>，默认实现是LinkedHashMap）。

public static class Section implements Map<String, String> {
        private final String name;
        private final Map<String, String> props;
        ...............      
}

section的key是section的名字，value是这个section中的所有文字信息（每一行文字信息做String.trim()以后再拼接起来）。

看上面的代码，Scetion中有一个props属性，也是Map类型，props代表了.ini配置文件中section中每一行的信息。

比如在ini文件中有这么一行：

authenticator=org.apache.shiro.authc.pam.ModularRealmAuthenticator

那key就是authenticator，value就是org.apache.shiro.authc.pam.ModularRealmAuthenticator。

 

section中有几个方法比较重要，我想介绍一下。

toMapProps

这个方法的用处就是把section中整整一大节的文字信息转化成很多小行，每一行都包含了键值对，存进props中。

        private static Map<String, String> toMapProps(String content) {
            Map<String, String> props = new LinkedHashMap<String, String>();
            String line;
            StringBuilder lineBuffer = new StringBuilder();
            Scanner scanner = new Scanner(content);
            while (scanner.hasNextLine()) {
                line = StringUtils.clean(scanner.nextLine());
                if (isContinued(line)) {
                    //strip off the last continuation backslash:
                    line = line.substring(0, line.length() - 1);
                    lineBuffer.append(line);
                    continue;
                } else {
                    lineBuffer.append(line);
                }
                line = lineBuffer.toString();
                lineBuffer = new StringBuilder();
                String[] kvPair = splitKeyValue(line);
                props.put(kvPair[0], kvPair[1]);
            }

            return props;
        }

整个方法其实还是比较简单的，就是一行一行读取section中的文字，然后调用splitKeyValue方法，把每一行的键值对分别取出来，然后再放到props这个map里。

这也就是section要做的主要内容，把一整节文字拆分成很多小的键值对，完成解析ini。

这个方法中会调用其他2个方法，isContinued（第8行）和splitKeyValue（第18行），这2个方法都值得一说。

 

isContinued

 protected static boolean isContinued(String line) {
            if (!StringUtils.hasText(line)) {
                return false;
            }
            int length = line.length();
            //find the number of backslashes at the end of the line.  If an even number, the
            //backslashes are considered escaped.  If an odd number, the line is considered continued on the next line
            int backslashCount = 0;
            for (int i = length - 1; i > 0; i--) {
                if (line.charAt(i) == ESCAPE_TOKEN) {
                    backslashCount++;
                } else {
                    break;
                }
            }
            return backslashCount % 2 != 0;
        }

上面说道toMapProps会一行一行解析section中的文字，其实不是，可能是2行，甚至多行，这要看每行最后有没有\（backslashes，反斜杠）这个符号。如果每行最后是一个\，那代表这一行其实文字太长了，写不下才换行，下一行和上面一行是连在一起的。所以说：

security\
Manager.realms=$myRealm1,$myRealm3

和

securityManager.realms=$myRealm1,$myRealm3

是一样的东西，这点大家值得注意，文字太长的时候可以用\换行。

但是\也有转义的意思，如果2个\\一起在最后，并不代表2行文字是同一行。所以要用isContinued方法来判断最后有几个\，奇数就说明2行文字是连续的，偶数说明\只是转义用的。

 

splitKeyValue

 protected static String[] splitKeyValue(String keyValueLine) {
            String line = StringUtils.clean(keyValueLine);
            if (line == null) {
                return null;
            }
            StringBuilder keyBuffer = new StringBuilder();
            StringBuilder valueBuffer = new StringBuilder();

            boolean buildingKey = true; //we'll build the value next:

            for (int i = 0; i < line.length(); i++) {
                char c = line.charAt(i);

                if (buildingKey) {
                    if (isKeyValueSeparatorChar(c) && !isCharEscaped(line, i)) {
                        buildingKey = false;//now start building the value
                    } else {
                        keyBuffer.append(c);
                    }
                } else {
                    if (valueBuffer.length() == 0 && isKeyValueSeparatorChar(c) && !isCharEscaped(line, i)) {
                        //swallow the separator chars before we start building the value
                    } else {
                        valueBuffer.append(c);
                    }
                }
            }

            String key = StringUtils.clean(keyBuffer.toString());
            String value = StringUtils.clean(valueBuffer.toString());

            if (key == null || value == null) {
                String msg = "Line argument must contain a key and a value.  Only one string token was found.";
                throw new IllegalArgumentException(msg);
            }

            log.trace("Discovered key/value pair: {}={}", key, value);

            return new String[]{key, value};
        }

这个方法其实并没有什么特别的，就是一个char一个读取过去，读到：或者=的时候说明前面都是key的部分，后面都是value的部分。但是因为有\的存在，所以读取可能会稍微麻烦一点，但是并不是很难理解，大家可以自己看看源码。其实只要知道这个方法干嘛用的就行了，并不用深究。

 

 

 

以上就是我对Ini类的理解。