来吧，看看shiro是怎么解析ini文件的，这里假设ini文件在classpath下，名字叫做shiro.ini
Factory<org.apache.shiro.mgt.SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
shiro.ini
[users]
zhang=
wang= [main]
#指定securityManager的authenticator实现
authenticator=org.apache.shiro.authc.pam.ModularRealmAuthenticator
securityManager.authenticator=$authenticator #指定securityManager.authenticator的authenticationStrategy
allSuccessfulStrategy=org.apache.shiro.authc.pam.FirstSuccessfulStrategy
securityManager.authenticator.authenticationStrategy=$allSuccessfulStrategy
一、加载ini配置文件
public static InputStream getInputStreamForPath(String resourcePath) throws IOException {
InputStream is;
if (resourcePath.startsWith(CLASSPATH_PREFIX)) {//判断是否为classpath:开头的
is = loadFromClassPath(stripPrefix(resourcePath));
} else if (resourcePath.startsWith(URL_PREFIX)) {//判断是否为url:开头
is = loadFromUrl(stripPrefix(resourcePath));
} else if (resourcePath.startsWith(FILE_PREFIX)) {//判断是否为file:开头
is = loadFromFile(stripPrefix(resourcePath));
} else {
is = loadFromFile(resourcePath);
}
if (is == null) {
throw new IOException("Resource [" + resourcePath + "] could not be found.");
}
return is;
}上面的代码中对我们传进来的配置文件进行前缀判断，再以相应的方法取加载它
stripPrefix（resourcePath）是去掉前缀，那么传进去的classpath:shiro.ini就变成shiro.ini了,下面就是加载配置文件的方法
public static InputStream getResourceAsStream(String name) {
InputStream is = THREAD_CL_ACCESSOR.getResourceStream(name);
if (is == null) {
if (log.isTraceEnabled()) {
log.trace("Resource [" + name + "] was not found via the thread context ClassLoader. Trying the " +
"current ClassLoader...");
}
is = CLASS_CL_ACCESSOR.getResourceStream(name);
}
if (is == null) {
if (log.isTraceEnabled()) {
log.trace("Resource [" + name + "] was not found via the current class loader. Trying the " +
"system/application ClassLoader...");
}
is = SYSTEM_CL_ACCESSOR.getResourceStream(name);
}
if (is == null && log.isTraceEnabled()) {
log.trace("Resource [" + name + "] was not found via the thread context, current, or " +
"system/application ClassLoaders. All heuristics have been exhausted. Returning null.");
}
return is;
}加载配置文件的时候，首先使用了线程的上下文加载器，如果加载不到就用类加载器，下面是这些加载器的获取代码
private static final ClassLoaderAccessor THREAD_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
@Override
protected ClassLoader doGetClassLoader() throws Throwable {
return Thread.currentThread().getContextClassLoader();
}
};
/**
* @since 1.0
*/
private static final ClassLoaderAccessor CLASS_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
@Override
protected ClassLoader doGetClassLoader() throws Throwable {
return ClassUtils.class.getClassLoader();
}
};
/**
* @since 1.0
*/
private static final ClassLoaderAccessor SYSTEM_CL_ACCESSOR = new ExceptionIgnoringAccessor() {
@Override
protected ClassLoader doGetClassLoader() throws Throwable {
return ClassLoader.getSystemClassLoader();
}
};当获取到配置文件的输入流后，使用了isr = new InputStreamReader(is, DEFAULT_CHARSET_NAME);这行代码就输入流变成了字节输入流随后调用过了load（isr）方法
public void load(Reader reader) {
Scanner scanner = new Scanner(reader);
try {
load(scanner);
} finally {
try {
scanner.close();
} catch (Exception e) {
log.debug("Unable to cleanly close the InputStream scanner. Non-critical - ignoring.", e);
}
}
}上面使用了Scanner类对reader进行了包装，随后有调用了load（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);//去除字符串的两边的空白字符，如果这个字符是空字符串，那么返回null
if (line == null || line.startsWith(COMMENT_POUND) || line.startsWith(COMMENT_SEMICOLON)) {//判断这行数据是否为null，或者是以#或者是;开头的注释.
//skip empty lines and comments:
continue;
}
String newSectionName = getSectionName(line);//判断是否为节点名（如[main]这样的）并且去掉[]，如[main]
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; //保存节点名，在读取完配置文件后，还得通过它添加节点（第36行代码需要用到）
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");//说名读取到这行不是节点名，那么就将内容保存到sectionContent中
}
}
//finish any remaining buffered content:
addSection(sectionName, sectionContent);//读到文件结尾时添加最后的这个节点
}第19行是添加节点，下面是添加节点的判断代码，它首先要确认你这个节点内是否有内容，如果没有就不添加，这种情况一般发生在
shiro解析第一个节点的时候，比如我这里的ini配置文件，shiro一开头读取到是[users]这个节点，到达第17行这条语句的时候，明显shiro还没有读取[users]这个节点内的内容
所以还不能进行添加
private void addSection(String name, StringBuilder content) {
if (content.length() > ) {
String contentString = content.toString();
String cleaned = StringUtils.clean(contentString);
if (cleaned != null) {
Section section = new Section(name, contentString);
if (!section.isEmpty()) {
sections.put(name, section);
}
}
}
}二、节点的添加 接着上面的，当节点内容不为空时，也就是一个节点被完整的读取出来了，那么就会创建节点对象
private void addSection(String name, StringBuilder content) {
if (content.length() > ) {
String contentString = content.toString();
String cleaned = StringUtils.clean(contentString);
if (cleaned != null) {
Section section = new Section(name, contentString);
if (!section.isEmpty()) {
sections.put(name, section);
}
}
}
}第6行，创建了一个Section对象，这个Section类实现了Map接口，是个map容器，Ini也实现了Map接口是个Map容器，并且Section是Ini的一个嵌套类。
打开Section这个构造器，它传入了两个参数，一个是节点名，另一个是这个节点下面的内容，如[users],那么节点内容就是
zhang=123
wang=123
private Section(String name, String sectionContent) {
if (name == null) {
throw new NullPointerException("name");
}
this.name = name;
Map<String,String> props;
if (StringUtils.hasText(sectionContent) ) {
props = toMapProps(sectionContent);//将内容解析存到Map中
} else {
props = new LinkedHashMap<String,String>();
}
if ( props != null ) {
this.props = props;
} else {
this.props = new LinkedHashMap<String,String>();
}
}重点看看第8行的内容，这个方法会把
zhang=123
wang=123
解析成键值对的形式存到props这个Map里面
实现代码为
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());//去掉两边的空白符，如果本身是个空字符串，那么返回null
if (isContinued(line)) {//判断是否存在反斜杠\，如果存在就继续读，反斜杠就像java中的+，表示这些字符串是连在一起的，一行写不下，放到下一行
//strip off the last continuation backslash:
line = line.substring(, line.length() - );//去掉反斜杠
lineBuffer.append(line);
continue;
} else {
lineBuffer.append(line);
}
line = lineBuffer.toString();
lineBuffer = new StringBuilder();
String[] kvPair = splitKeyValue(line);
props.put(kvPair[], kvPair[]);
}
return props;
}这里有两个比较重点的方法，一个是第8行的isContinued,还有一个是第18行的splitKeyValue方法
首先看下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 = ;
for (int i = length - ; i > ; i--) {
if (line.charAt(i) == ESCAPE_TOKEN) {//判断时候等于反斜杠
backslashCount++;
} else {
break;
}
}
return backslashCount % != ;
}上面这段代码的意思是，从一句话的最后开始往前查找反斜杠，如果反斜杠的个数是奇数个，那么就返回true，如果是偶数那么就返回
false，为什么呢？反斜杠在shiro的配置中被认为是转义字符，比如\\那么表示的\，只有一个\或者奇数个\\\=》表示用户需要输出一个\,另一个\就不会转义，跟java中的反斜杠是
一样的。
将每条键值对信息读取完整之后，就可以开始进行key，value的解析了
现在来看看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 = ; i < line.length(); i++) {
char c = line.charAt(i);//循环遍历每个字符
if (buildingKey) {//这个值为true时，表示对key值进行解析
if (isKeyValueSeparatorChar(c) && !isCharEscaped(line, i)) {//isKeyValueSeparatorChar是在判断这个字符是否是：或这=，isCharEscaped表示这个字符前是否存在反斜杠
buildingKey = false;//now start building the value
} else {
keyBuffer.append(c);
}
} else {
if (valueBuffer.length() == && 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};
}第15行的isKeyValueSeparatorChar代码如下
private static boolean isKeyValueSeparatorChar(char c) {
return Character.isWhitespace(c) || c == ':' || c == '=';
}isCharEscaped的代码如下
private static boolean isCharEscaped(CharSequence s, int index) {
return index > && s.charAt(index - ) == ESCAPE_TOKEN;//ESCAPE_TOKEN表示反斜杠
}为什么要这么判断，原因很简单就是像\=和\：都会被转义 当找到=或者：时，key的解析结束，将buildingKey设置为false，开始解析value，解析value的时候要注意一下第21行的判断语句
这行判断语句的意思是，当valueBuffer中没有值的时候，如果出现=或这：，那么这些字符将被忽略，比如说zhang===：：：123,它会忽略掉第一个等号后面的=或者：
如果是这样的zhang===qwer=rtet，它只会解析到第一个=后面的=不会被解析，综合以上的判断方式，最后得出的key是zhang，value是qwer=rtet 解析出key和value后将被存到Section类的props这个Map中
并且最后节点名字和Section对象会被存到Ini了的sections这个Map中sections.put(name, section);