一、入口
protected ConfigurableListablebeanfactory obtainFreshbeanfactory() {
// 初始化beanfactory,并进行XML文件读取，并将得到的beanfactory记录在当前实体的属性中
refreshbeanfactory();
// 返回当前实体的beanfactory属性
return getbeanfactory();
}
二、refreshbeanfactory
@Override
protected final void refreshbeanfactory() throws BeansException {
// 如果存在beanfactory，则销毁beanfactory
if (hasbeanfactory()) {
destroyBeans();
closebeanfactory();
}
try {
// 创建DefaultListablebeanfactory对象
DefaultListablebeanfactory beanfactory = createbeanfactory();
// 为了序列化指定id，可以从id反序列化到beanfactory对象
beanfactory.setSerializationId(getId());
// 定制beanfactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖
customizebeanfactory(beanfactory);
// 初始化documentReader,并进行XML文件读取及解析,默认命名空间的解析，自定义标签的解析
loadBeanDeFinitions(beanfactory);
this.beanfactory = beanfactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean deFinition source for " + getdisplayName(), ex);
}
}
三、createbeanfactory
**
* 构造方法，忽略BeanNameAware，beanfactoryAware，BeanClassLoaderAware的依赖
*
*/
public AbstractAutowireCapablebeanfactory() {
super();
// 忽略要依赖的接口
ignoreDependencyInterface(BeanNameAware.class);
ignoreDependencyInterface(beanfactoryAware.class);
ignoreDependencyInterface(BeanClassLoaderAware.class);
}
四、customizebeanfactory
protected void customizebeanfactory(DefaultListablebeanfactory beanfactory) {
// 如果属性allowBeanDeFinitionOverriding不为空，设置给beanfactory对象相应属性，是否允许覆盖同名称的不同定义的对象
if (this.allowBeanDeFinitionOverriding != null) {
beanfactory.setAllowBeanDeFinitionOverriding(this.allowBeanDeFinitionOverriding);
}
// 如果属性allowCircularReferences不为空，设置给beanfactory对象相应属性，是否允许bean之间存在循环依赖
if (this.allowCircularReferences != null) {
beanfactory.setAllowCircularReferences(this.allowCircularReferences);
}
}
五、loadBeanDeFinitions
@Override
protected void loadBeanDeFinitions(DefaultListablebeanfactory beanfactory) throws BeansException, IOException {
// 创建一个xml的beanDeFinitionReader，并通过回调设置到beanfactory中
XmlBeanDeFinitionReader beanDeFinitionReader = new XmlBeanDeFinitionReader(beanfactory);
// 给reader对象设置环境对象
beanDeFinitionReader.setEnvironment(this.getEnvironment());
beanDeFinitionReader.setResourceLoader(this);
beanDeFinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 初始化beanDeFinitionReader对象，此处设置配置文件是否要进行验证
initBeanDeFinitionReader(beanDeFinitionReader);
// 开始完成beanDeFinition的加载
loadBeanDeFinitions(beanDeFinitionReader);
}
六、loadBeanDeFinitions
protected void loadBeanDeFinitions(XmlBeanDeFinitionReader reader) throws BeansException, IOException {
// 以Resource的方式获得配置文件的资源位置
Resource[] configResources = getConfigResources();
if (configResources != null) {
reader.loadBeanDeFinitions(configResources);
}
// 以String的形式获得配置文件的位置
String[] configLocations = getConfigLocations();
if (configLocations != null) {
reader.loadBeanDeFinitions(configLocations);
}
}
七、loadBeanDeFinitions
@Override
public int loadBeanDeFinitions(String... locations) throws BeanDeFinitionStoreException {
Assert.notNull(locations, "Location array must not be null");
int count = 0;
for (String location : locations) {
count += loadBeanDeFinitions(location);
}
return count;
}
@Override
public int loadBeanDeFinitions(String location) throws BeanDeFinitionStoreException {
return loadBeanDeFinitions(location, null);
}
八、loadBeanDeFinitions
public int loadBeanDeFinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDeFinitionStoreException {
//此处获取resourceLoader对象
ResourceLoader resourceLoader = getResourceLoader();
if (resourceLoader == null) {
throw new BeanDeFinitionStoreException(
"Cannot load bean deFinitions from location [" + location + "]: no ResourceLoader available");
}
if (resourceLoader instanceof ResourcePatternResolver) {
// Resource pattern matching available.
try {
// 调用DefaultResourceLoader的getResource完成具体的Resource定位
Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
int count = loadBeanDeFinitions(resources);
if (actualResources != null) {
Collections.addAll(actualResources, resources);
}
if (logger.isTraceEnabled()) {
logger.trace("Loaded " + count + " bean deFinitions from location pattern [" + location + "]");
}
return count;
}
catch (IOException ex) {
throw new BeanDeFinitionStoreException(
"Could not resolve bean deFinition resource pattern [" + location + "]", ex);
}
}
else {
// Can only load single resources by absolute URL.
Resource resource = resourceLoader.getResource(location);
int count = loadBeanDeFinitions(resource);
if (actualResources != null) {
actualResources.add(resource);
}
if (logger.isTraceEnabled()) {
logger.trace("Loaded " + count + " bean deFinitions from location [" + location + "]");
}
return count;
}
}
@Override
public int loadBeanDeFinitions(Resource resource) throws BeanDeFinitionStoreException {
return loadBeanDeFinitions(new EncodedResource(resource));
}
九、loadBeanDeFinitions
获取Resource对象中的文件流对象，然后转为InputSource，并设置编码。InputSource是jdk中的sax中xml文件解析对象。提供的一种输入规范。之后执行doLoadBeanDeFinitions进行XML的解析。
public int loadBeanDeFinitions(EncodedResource encodedResource) throws BeanDeFinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Loading XML bean deFinitions from " + encodedResource);
}
// 通过属性来记录已经加载的资源
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (!currentResources.add(encodedResource)) {
throw new BeanDeFinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import deFinitions!");
}
// 从encodedResource中获取已经封装的Resource对象并再次从Resource中获取其中的inputStream
try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 逻辑处理的核心步骤
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();
}
}
}
十、doLoadBeanDeFinitions
protected int doLoadBeanDeFinitions(InputSource inputSource, Resource resource)
throws BeanDeFinitionStoreException {
try {
// 此处获取xml文件的document对象，这个解析过程是由documentLoader完成的,从String[] -string-Resource[]- resource,最终开始将resource读取成一个document文档，根据文档的节点信息封装成一个个的BeanDeFinition对象
Document doc = doLoadDocument(inputSource, resource);
int count = registerBeanDeFinitions(doc, resource);
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + count + " bean deFinitions from " + resource);
}
return count;
}
catch (BeanDeFinitionStoreException ex) {
throw ex;
}
catch (SAXParseException ex) {
throw new XmlBeanDeFinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
catch (SAXException ex) {
throw new XmlBeanDeFinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
catch (ParserConfigurationException ex) {
throw new BeanDeFinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
catch (IOException ex) {
throw new BeanDeFinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
catch (Throwable ex) {
throw new BeanDeFinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}
public int registerBeanDeFinitions(Document doc, Resource resource) throws BeanDeFinitionStoreException {
// 实例化创建documentReader对象，documentReader对xml的beanDeFinition进行解析
BeanDeFinitionDocumentReader documentReader = createBeanDeFinitionDocumentReader();
int countBefore = getRegistry().getBeanDeFinitionCount();
// 完成具体的解析过程
documentReader.registerBeanDeFinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDeFinitionCount() - countBefore;
}
@Override
public void registerBeanDeFinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
doRegisterBeanDeFinitions(doc.getDocumentElement());
}
protected void doRegisterBeanDeFinitions(Element root) {
BeanDeFinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) { // 判断namespaceuri是否是http://www.springframework.org/schema/beans
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) { // profile属性存在
String[] specifiedProfiles = StringUtils.tokenizetoStringArray(
profileSpec, BeanDeFinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
// We cannot use Profiles.of(...) since profile expressions are not supported
// in XML config. See SPR-12458 for details.
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (logger.isDebugEnabled()) {
logger.debug("Skipped XML bean deFinition file due to specified profiles [" + profileSpec +
"] not matching: " + getReaderContext().getResource());
}
return;
}
}
}
preProcessXml(root); // 钩子函数
parseBeanDeFinitions(root, this.delegate); // 解析xml文件里的标签
postProcessXml(root); // 钩子函数
this.delegate = parent;
}
十一、parseBeanDeFinitions
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); // 解析默认标签import，alias，bean，beans
}
else {
delegate.parseCustomElement(ele); // 解析自定义标签
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
以上是将xml的位置解析成Resource对象，在将Resource转成sax中解析xml的InputSource，读取成Document文档，解析Document文档。
