前两节分析到容器的创建和刷新，并且在刷新的时候创建了XmlBeanDefinitionReader，开始了配置文件的加载。
//构建XmlBeanDefinitionReader并开始加载配置文件
protected void org.springframework.web.context.support.XmlWebApplicationContext.loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
//创建XmlBeanDefinitionReader，并关联BeanFactory，用于将解析好的BeanDefinition注册到BeanDefinition中
XmlBeanDefinitionReader
beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
//设置环境变量实例
beanDefinitionReader.setEnvironment(getEnvironment());
//设置资源加载器，XmlWebApplicationContext实现了ResourceLoader
beanDefinitionReader.setResourceLoader(this);
//设置xml校验资源
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
//初始化XmlBeanDefinitionReader，目前为空方法，可以由子类实现
initBeanDefinitionReader(beanDefinitionReader);
//加载配置文件
loadBeanDefinitions(beanDefinitionReader);
}
上面一段代码主要就是创建了XmlBeanDefinitionReader用于读取配置文件，XmlBeanDefinitionContext的类图如下：
[外链
EnvironmentCapable（定义获取Environment的能力）
BeanDefinitionReader（定义获取BeanDefinitionRegister，ResoureLoader以及加载BeanDefinition的能力）
AbstractBeanDefinitionReader（模板类，定义loadBeanDefinitions模板方法）
XmlBeanDefinitionReader （完整的实现类）
//获取配置文件，由ServletContextResourcePatternResolver的实例调用，这个实例与XmlWebApplicationContext关联，在创建context的时候由其父类的AbstractApplicationContext构造器调用AbstractRefreshableWebApplicationContext的getResourcePatternResolver方法得到
public Resource[] org.springframework.core.io.support.PathMatchingResourcePatternResolver.getResources(String locationPattern) throws IOException {
Assert.notNull(locationPattern, "Location pattern must not be null");
//判断当前配置路径是否由classpath*:开头
if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
// a class path resource (multiple resources for same name possible)
//使用AntPathMatcher判断当前配置路径是否符合ant通配符模式
if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
// a class path resource pattern
//通过路径匹配的方式获取配置资源
return findPathMatchingResources(locationPattern);
}
else {
// all class path resources with the given name
//寻找所有加载器路径下叫这个路径名的资源配置
return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
}
}
else {
// Only look for a pattern after a prefix here
// (to not get fooled by a pattern symbol in a strange prefix).
int prefixEnd = locationPattern.indexOf(":") + 1;
//判断是否符合ant路径模式
if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
// a file pattern
//通过通配符匹配的方式寻找配置资源
return findPathMatchingResources(locationPattern);
}
else {
// a single resource with the given name
//获取当前加载器路径下的第一个匹配到的资源配置
return new Resource[] {getResourceLoader().getResource(locationPattern)};
}
}
}
我们来研究一下spring是如何获取资源的，第一种通过通配符的方式获取
//通过通配符的方式获取资源
protected Resource[] findPathMatchingResources(String locationPattern) throws IOException {
//获取不是通配符的跟路径，比如classpath:spring/springContext-*.xml,那么它的根dir就是classpath:spring，如果是classpath:spring/config/springContext-*.xml,那么根路径就是classpath:spring/config
String rootDirPath = determineRootDir(locationPattern);
//获取具有通配符的路径，也就是去掉rootDirPath的，如果是classpath:spring/springContext-*.xml那么subPattern就是springContext-*.xml
String subPattern = locationPattern.substring(rootDirPath.length());
//获取根路径对应的资源，如果是classpath*:开头的，那么将会获取所有加载器下的资源
Resource[] rootDirResources = getResources(rootDirPath);
Set<Resource> result = new LinkedHashSet<Resource>(16);
for (Resource rootDirResource : rootDirResources) {
//用于解析OSGi的url路径，这里不管它
rootDirResource = resolveRootDirResource(rootDirResource);
//判断是否为vfs（虚拟文件系统）类型的url,内部使用VfsUtils反射获取资源，这个获取资源的类是jboss提供的一个vfs资源读取工具
if (rootDirResource.getURL().getProtocol().startsWith(ResourceUtils.URL_PROTOCOL_VFS)) {
result.addAll(VfsResourceMatchingDelegate.findMatchingResources(rootDirResource, subPattern, getPathMatcher()));
}
//判断是否为压缩类型的url协议，比如jar，vfszip开头的
else if (isJarResource(rootDirResource)) {
result.addAll(doFindPathMatchingJarResources(rootDirResource, subPattern));
}
else {
//寻找普通的文件，匹配模式使用AntPathMatcher进行匹配
result.addAll(doFindPathMatchingFileResources(rootDirResource, subPattern));
}
}
if (logger.isDebugEnabled()) {
logger.debug("Resolved location pattern [" + locationPattern + "] to resources " + result);
}
return result.toArray(new Resource[result.size()]);
}
主要看下获取普通文件的方式，对于vfs，spring封装了一个VfsUtils获取资源，而VfsUitls内部发射的是jboss提供的vfs访问工具（org.jboss.vfs.VFS）。对于jar，是通AntPathMatcher去匹配jar的entryName来获取资源的，下面我们主要分析一下获取普通系统文件的方式
/**
* fullPattern 表示绝对路径的通配符模式，比如D:/java_project/learn_sprin* g_source/classes/spring/springContext-*.xml
*
* dir 表示根目录，前面说到这个根目录为没有通配符的那个目录，比如D:/java* _project/learn_sprin* g_source/classes/spring/
*
* result 一个用于存储发现并且能够匹配通配符的file文件集合
*/
protected void doRetrieveMatchingFiles(String fullPattern, File dir, Set<File> result) throws IOException {
if (logger.isDebugEnabled()) {
logger.debug("Searching directory [" + dir.getAbsolutePath() +
"] for files matching pattern [" + fullPattern + "]");
}
//列出当前根目录下所有的文件
File[] dirContents = dir.listFiles();
if (dirContents == null) {
if (logger.isWarnEnabled()) {
logger.warn("Could not retrieve contents of directory [" + dir.getAbsolutePath() + "]");
}
return;
}
//递归的方式选择文件，并用AntPathMatcher去匹配，如果匹配就存到result集合中
for (File content : dirContents) {
String currPath = StringUtils.replace(content.getAbsolutePath(), File.separator, "/");
if (content.isDirectory() && getPathMatcher().matchStart(fullPattern, currPath + "/")) {
if (!content.canRead()) {
if (logger.isDebugEnabled()) {
logger.debug("Skipping subdirectory [" + dir.getAbsolutePath() +
"] because the application is not allowed to read the directory");
}
}
else {
doRetrieveMatchingFiles(fullPattern, content, result);
}
}
//AntPatchMatcher
if (getPathMatcher().match(fullPattern, currPath)) {
result.add(content);
}
}
}
现在来分析下AntPathMatcher是如何进行匹配的
protected boolean doMatch(String pattern, String path, boolean fullMatch, Map<String, String> uriTemplateVariables) {
//如果两者开头匹配/不一致，那么就是不匹配，返回false
if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
return false;
}
//根据/进行分割成数组
String[] pattDirs = tokenizePattern(pattern);
String[] pathDirs = tokenizePath(path);
int pattIdxStart = 0;
int pattIdxEnd = pattDirs.length - 1;
int pathIdxStart = 0;
int pathIdxEnd = pathDirs.length - 1;
//如果没有**，那么就会进行全匹配
// Match all elements up to the first **
while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
String pattDir = pattDirs[pattIdxStart];
if ("**".equals(pattDir)) {
break;
}
//此处会发生*？{}字符的替换，替换成正则表达式进行匹配
if (!matchStrings(pattDir, pathDirs[pathIdxStart], uriTemplateVariables)) {
return false;
}
pattIdxStart++;
pathIdxStart++;
}
//如果path数组的元素被耗尽
if (pathIdxStart > pathIdxEnd) {
// Path is exhausted, only match if rest of pattern is * or **'s
//并且pattern数组的元素也被耗尽，那么说明两者长度一样，那么只要匹配查看他们的结束符是否相同，相同就返回true，不相同就返回false,匹配 srping/springContext-*.xml vs spring/springContext-dao.xml的情况
if (pattIdxStart > pattIdxEnd) {
return (pattern.endsWith(this.pathSeparator) ? path.endsWith(this.pathSeparator) :
!path.endsWith(this.pathSeparator));
}
//如果path数组被耗尽，而pattern未被好景，并且不要求全匹配，那么直接返回true，匹配 spring/config/springContext-*.xml vs spring/config的情况
if (!fullMatch) {
return true;
}
//如果path数组耗尽，而pattern还未耗尽，还是全匹配的模式下，那么判断pattern最后一个元素是否为*，path最后一个字符是否为/，用于匹配 spring/config/* vs spring/config/这种情况
if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") && path.endsWith(this.pathSeparator)) {
return true;
}
//如果path数组被耗尽，而pattern还未被耗尽，还是全匹配的模式下，那么就需要判断从当前pattIdxStart开始是否全是**,否则返回false，用于匹配 spring/config/**[/**/**] vs spring/config这种情况
for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
if (!pattDirs[i].equals("**")) {
return false;
}
}
return true;
}
//如果path数组未被耗尽，而pattern数组被耗尽，那么肯定是不匹配的
else if (pattIdxStart > pattIdxEnd) {
// String not exhausted, but pattern is. Failure.
return false;
}
//如果path数组未被耗尽，并且是不要求全匹配的，当前pattern元素为**，那么直接返回true，用于匹配spring/config/**/a/b/c vs spring/config/haha/xixi
else if (!fullMatch && "**".equals(pattDirs[pattIdxStart])) {
// Path start definitely matches due to "**" part in pattern.
return true;
}
//如果两者都未被耗尽，能够走到这里，那么就一定出现了**，那么从后往前匹配
// up to last '**'
while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
String pattDir = pattDirs[pattIdxEnd];
if (pattDir.equals("**")) {
break;
}
if (!matchStrings(pattDir, pathDirs[pathIdxEnd], uriTemplateVariables)) {
return false;
}
pattIdxEnd--;
pathIdxEnd--;
}
//如果path数组被耗尽，那么判断当前pattern下标对应的元素是否为**，用于匹配 spring/**/[**/**/]springContext-*.xml vs spring/springContext-*.xml
if (pathIdxStart > pathIdxEnd) {
// String is exhausted
for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
if (!pattDirs[i].equals("**")) {
return false;
}
}
return true;
}
//用于匹配spirng/**/**[a/b/c][/**]/springContext-*.xml vs spring/a/b/springContext-*.xml
while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) {
int patIdxTmp = -1;
for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) {
if (pattDirs[i].equals("**")) {
patIdxTmp = i;
break;
}
}
if (patIdxTmp == pattIdxStart + 1) {
// '**/**' situation, so skip one
//跳过连续**的情况
pattIdxStart++;
continue;
}
// Find the pattern between padIdxStart & padIdxTmp in str between
// strIdxStart & strIdxEnd
int patLength = (patIdxTmp - pattIdxStart - 1);
int strLength = (pathIdxEnd - pathIdxStart + 1);
int foundIdx = -1;
//匹配spirng/**/**/a/b/c/**/fg/**/springContext-*.xml vs spring/lala/a/b/c/yiyi/ffg/xixi/springContext-*.xml的情况
strLoop:
for (int i = 0; i <= strLength - patLength; i++) {
for (int j = 0; j < patLength; j++) {
String subPat = pattDirs[pattIdxStart + j + 1];
String subStr = pathDirs[pathIdxStart + i + j];
if (!matchStrings(subPat, subStr, uriTemplateVariables)) {
continue strLoop;
}
}
foundIdx = pathIdxStart + i;
break;
}
//如果没有匹配到相同的片段，那么就返回false
if (foundIdx == -1) {
return false;
}
pattIdxStart = patIdxTmp;
pathIdxStart = foundIdx + patLength;
}
//用于匹配spirng/**/**[a/b/c][/**]/springContext-*.xml vs spring/a/b/springContext-*.xml
for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
if (!pattDirs[i].equals("**")) {
return false;
}
}
return true;
}
AntPathMatcher的路径匹配方式考虑的情况比较多，其中可能比较复杂的地方是标注为strLoop循环标签的地方，这段循环主要是通过锁定a，b，c与lala，a，b，c，yiyi，ffg，xixi片段进行匹配是否有连续的a,b,c fg片段与yiyi，ffg，xixi片段进行匹配。如果都能匹配，那么就到最后会判断fg片段后到上次匹配结束的地方是否全是**，或者说pattIdxStart大于patIdxend（也就是没有**），那么就表示匹配。
1.2 解析配置文件的序列图
21万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
