定义BeanFactory，并加载以下两种bean的定义，装配到BeanFactory：
1.配置文件中定义的bean
2.通过<context:component-scan base-package="..." />配置的路径下的，且经过相应注解标注的所有类，注解包括：@Controller、@Service、@Component、@Repository
主要流程总结：
1.创建BeanFactory：DefaultListableBeanFactory
2.解析web.xml配置，读取spring配置文件，封装为Resource对象
3.把Resource对象封装为Document对象
4.开始层层遍历Document的节点。
以下是细节：
先来看该方法的实现，注：这里会把无关代码删掉，以方便阅读。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//刷新bean工厂
this.refreshBeanFactory();
//创建bean工厂
return this.getBeanFactory();
}
重点看刷新bean工厂部分：
protected final void refreshBeanFactory() throws BeansException {
//创建bean工厂
DefaultListableBeanFactory beanFactory = createBeanFactory();
//这里加载beanDefinition，并赋给bean工厂
loadBeanDefinitions(beanFactory);
}
createBeanFactory()好理解，就是new了个工厂对象。
有了工厂对象后，就需要往里面装载东西，装什么呢？这里是
接下来看loadBeanDefinitions(beanFactory)方法的具体实现：创建xml文件读取器
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 以下这一堆内容就是为了准备一个xml文件读取器，仅作了解
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
initBeanDefinitionReader(beanDefinitionReader);
//这里才是核心，加载beanDefinition的工作还没开始
loadBeanDefinitions(beanDefinitionReader);
}
继续跟进去，这里依然“没干正事”：加载spring配置文件
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
//核心代码
reader.loadBeanDefinitions(configLocations);
}
}
接着看核心代码
public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException {
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader instanceof ResourcePatternResolver) {
// 通配符模式匹配资源，转换为Resource对象。spring提供了多种ResourceLoader，根据通配符匹配，生成对应类型的Resource
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
//【继续把加载工作往后放】
int loadCount = loadBeanDefinitions(resources);return loadCount;
}
}
else {
// 以绝对路径加载单个资源文件，转换为Resource对象
Resource resource = resourceLoader.getResource(location);
//【继续把加载工作往后放】
int loadCount = loadBeanDefinitions(resource);return loadCount;
}
}
通过上面一步，把配置资源转化为Resource对象，然后作为参数传入loadxxx方法里进行解析。
进入下面的实现发现，依然在做准备工作：将Resource读取为流
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
//
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet<EncodedResource>(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
//终于到do...是不是这里就开始真正的执行加载了？
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}
来看下,删除非核心代码，就做了两件事，先读取资源对象Resource，封装成Document对象；再“注册”beanDefinition。
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
//生成Document对象
Document doc = doLoadDocument(inputSource, resource);
//注册BeanDefinition
return registerBeanDefinitions(doc, resource);
}
中间又经历了n个准备环境，最终进入方法parseBeanDefinitions，拿到了Document对象的根节点，开始调用解析方法解析节点：
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
具体的解析逻辑，可以参考以下文章：https://blog.csdn.net/v123411739/article/details/86669952
BeanDefinition包含的主要内容：
@todo
解析完成后，依然是注入到BeanFactory中缓存起来，供后续使用，主要的内容是两部分：
1.beanDefinitionNames
2.beanDefinitionMap
总结：
obtainFreshBeanFactory()方法的主要作用：
1.创建beanFactory
2.根据web.xml中contextConfigLocation配置的路径，读取Spring配置文件，封装为Resource
3.根据Resource加载XML配置文件（bean文件）并解析为Document对象
4.遍历Document，解析为beanDefinition。
