本来这篇文章是想写从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. EachSectionis itself a map ofStringname/value pairs. Name/value pairs are guaranteed to be unique within eachSectiononly - not across the entireIniinstance.
意思就是说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类的理解。