目录
前言
用通俗易懂的方式介绍，Spring容器初始化的过程，介绍bean标签转换为BeanDefinition的全过程。记录学习过程，学习源码的优秀思想，提供抽象思维能力。
一、基本概念
1.1 基本介绍
Spring容器初始化时，会将传入路径的所有xml文件中的bean标签的所有内容，最后转换为BeanDefinition对象，存在容器的beanDefinitionMap中，最后根据BeanDefinition对象来创建bean对象。以beanName为key，BeanDefinition对象为value。
1.2 代码展示
| 项目结构，xml文件路径为/abc，/c/，/abc/ssdf
|
| 示例类代码
|
| xml文件bean标签的内容
|
| 初始化之后，BeanDefinition的结构
|
1.3 常见的容器和实现类
容器
BeanFactory
和ApplicationContext区别
BeanFactory是Spring里面最底层的接口，是IoC的核心，定义了IoC的基本功能，包含了各种Bean的定义、加载、实例化，依赖注入和生命周期管理。
容器初始后不实例化单例bean，getBean时才创建。
ApplicationContext接口作为BeanFactory的子类，除了提供BeanFactory所具有的功能外，还提供其他功能：
支持国际化；资源文件访问；提供在监听器中注册bean的事件；
容器初始后实例化单例bean。
基本的实现类
ClassPathXmlApplicationContext：
new ClassPathXmlApplicationContext("classpath:a.xml");
普通的xml文件bean容器 AnnotationConfigApplicationContext：
new AnnotationConfigApplicationContext(Config.class);
基于注解的bean容器 FileSystemXmlApplicationContext：
new FileSystemXmlApplicationContext("C:\\java\\d.xml");
基于文件系统xml文件的bean容器 XmlBeanFactory：
newXmlBeanFactory(new FileSystemResource("C:\\java\\b.xml"));
最底层的BeanFactory的实现类，不建议使用了，xml文件可以来自classpath和文件系统
二、源码解析
ClassPathXmlApplicationContext的类图
new一个ClassPathXmlApplicationContext容器对象，传入有通配符的classpath路径
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"classpath:*c/test*.xml","classpath:*c/s*/test*.xml");
Object bean = applicationContext.getBean("test3");
}进入构造方法
// 当前类：ClassPathXmlApplicationContext
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
// 设置父容器，此时为空
super(parent);
// 将传入的classpath路径数组保存起来
this.setConfigLocations(configLocations);
if (refresh) {
// 刷新容器，创建容器的入口
this.refresh();
}
}
// 当前类：AbstractRefreshableConfigApplicationContext
public void setConfigLocations(@Nullable String... locations) {
if (locations != null) {
Assert.noNullElements(locations, "Config locations must not be null");
// new一个String数组，将locations的元素保存进去
this.configLocations = new String[locations.length];
// 遍历保存
for(int i = 0; i < locations.length; ++i) {
this.configLocations[i] = this.resolvePath(locations[i]).trim();
}
} else {
this.configLocations = null;
}
}进入refresh方法
// 当前类：AbstractApplicationContext
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
// 准备工作
this.prepareRefresh();
// 得到一个容器对象
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
this.invokeBeanFactoryPostProcessors(beanFactory);
this.registerBeanPostProcessors(beanFactory);
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
this.finishBeanFactoryInitialization(beanFactory);
this.finishRefresh();
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
}
this.destroyBeans();
this.cancelRefresh(var9);
throw var9;
} finally {
this.resetCommonCaches();
}
}
}
// 当前类：AbstractApplicationContext
protected void prepareRefresh() {
// 记录一个初始时间，容器初始化完成后，用来计算容器初始化所用的时间
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (this.logger.isDebugEnabled()) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Refreshing " + this);
} else {
this.logger.debug("Refreshing " + this.getDisplayName());
}
}
// 留给子类实现的模板方法，初始化一些资源
this.initPropertySources();
// 初始化环境变量对象，并校验
this.getEnvironment().validateRequiredProperties();
// 初始化事件监听的集合
this.earlyApplicationEvents = new LinkedHashSet();
}进入obtainFreshBeanFactory方法
// 当前类：AbstractApplicationContext
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 刷新容器
this.refreshBeanFactory();
// 返回初始化的容器
return this.getBeanFactory();
}进入refreshBeanFactory方法
// 当前类：AbstractRefreshableApplicationContext
protected final void refreshBeanFactory() throws BeansException {
// 容器不为空的话
if (this.hasBeanFactory()) {
// destroy容器中的所有单例bean
this.destroyBeans();
// close容器
this.closeBeanFactory();
}
try {
// 得到一个DefaultListableBeanFactory容器
DefaultListableBeanFactory beanFactory = this.createBeanFactory();
// 设置唯一的容器id
beanFactory.setSerializationId(this.getId());
this.customizeBeanFactory(beanFactory);
// 加载xml文件的bean对象为BeanDefinition
this.loadBeanDefinitions(beanFactory);
synchronized(this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
} catch (IOException var5) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var5);
}
}
// 当前类：AbstractRefreshableApplicationContext
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(this.getInternalParentBeanFactory());
}进入loadBeanDefinitions方法
// 当前类：AbstractXmlApplicationContext
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// new一个xml阅读器对象，将容器保存在它的父类AbstractBeanDefinitionReader中
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
this.initBeanDefinitionReader(beanDefinitionReader);
// 加载BeanDefinitions
this.loadBeanDefinitions(beanDefinitionReader);
}进入loadBeanDefinitions方法
// 当前类：AbstractXmlApplicationContext
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = this.getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
// 得到开始设置的classpath路径数组
String[] configLocations = this.getConfigLocations();
if (configLocations != null) {
// 加载路径下的xml文件的bean标签为BeanDefinition
reader.loadBeanDefinitions(configLocations);
}
}进入loadBeanDefinitions方法
// 当前类：AbstractBeanDefinitionReader
// locations为["classpath:*c/test*.xml","classpath:*c/s*/test*.xml"]
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
Assert.notNull(locations, "Location array must not be null");
int count = 0;
String[] var3 = locations;
int var4 = locations.length;
// 加载classpath路径数组下的所有xml文件的bean标签为BeanDefinition
for(int var5 = 0; var5 < var4; ++var5) {
// 得到一个路径，假设为"classpath:*c/test*.xml"
String location = var3[var5];
// "classpath:*c/test*.xml"
count += this.loadBeanDefinitions(location);
}
return count;
}进入loadBeanDefinitions方法
// 当前类：AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
return this.loadBeanDefinitions(location, (Set)null);
}
// 当前类：AbstractBeanDefinitionReader
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
ResourceLoader resourceLoader = this.getResourceLoader();
// 为什么是这个if哪，看loadBeanDefinitions方法，
// new XmlBeanDefinitionReader(beanFactory);这个对象的构造方法
if (resourceLoader == null) {
throw new BeanDefinitionStoreException("Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
} else {
int count;
if (resourceLoader instanceof ResourcePatternResolver) {
try {
// location="classpath:*c/test*.xml",这个下面有test1.xml和test2.xml
// 所以生成两个Resource对象
Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location);
// 加载BeanDefinition
count = this.loadBeanDefinitions(resources);
if (actualResources != null) {
Collections.addAll(actualResources, resources);
}
if (this.logger.isTraceEnabled()) {
this.logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
}
return count;
} catch (IOException var6) {
throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", var6);
}
} else {
...
}
}
}进入loadBeanDefinitions方法
// 当前类：AbstractBeanDefinitionReader
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int count = 0;
// resources是test1.xml和test2.xml文件的Resource对象数组
Resource[] var3 = resources;
int var4 = resources.length;
// 循环加载test1.xml和test2.xml文件中的bean标签为BeanDefinition对象
for(int var5 = 0; var5 < var4; ++var5) {
// 假设resource为test1.xml文件的Resource 对象
Resource resource = var3[var5];
// 加载test1.xml文件的bean标签为BeanDefinition对象
count += this.loadBeanDefinitions((Resource)resource);
}
return count;
}进入loadBeanDefinitions方法
// 当前类：XmlBeanDefinitionReader
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
return this.loadBeanDefinitions(new EncodedResource(resource));
}
// 当前类：XmlBeanDefinitionReader
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (this.logger.isTraceEnabled()) {
this.logger.trace("Loading XML bean definitions from " + encodedResource);
}
Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!((Set)currentResources).add(encodedResource)) {
throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
} else {
int var5;
try {
// 得到test1.xml文件的文件流
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
// 封装为InputSource 对象
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 加载BeanDefinition
var5 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
} finally {
inputStream.close();
}
} catch (IOException var15) {
throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var15);
} finally {
((Set)currentResources).remove(encodedResource);
if (((Set)currentResources).isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
return var5;
}
}进入doLoadBeanDefinitions方法
// 当前类：XmlBeanDefinitionReader
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
try {
// 将test1.xml的文件封装为Document 对象
Document doc = this.doLoadDocument(inputSource, resource);
// 注册BeanDefinition对象
int count = this.registerBeanDefinitions(doc, resource);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Loaded " + count + " bean definitions from " + resource);
}
return count;
} catch (BeanDefinitionStoreException var5) {
throw var5;
} catch (SAXParseException var6) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + var6.getLineNumber() + " in XML document from " + resource + " is invalid", var6);
} catch (SAXException var7) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", var7);
} catch (ParserConfigurationException var8) {
throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, var8);
} catch (IOException var9) {
throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, var9);
} catch (Throwable var10) {
throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, var10);
}
}进入registerBeanDefinitions方法
// 当前类：XmlBeanDefinitionReader
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// BeanDefinition对象阅读器，负责把bean标签注册为BeanDefinition
// documentReader=DefaultBeanDefinitionDocumentReader
BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
int countBefore = this.getRegistry().getBeanDefinitionCount();
// 把test1.xml的Document对象和XmlReaderContext对象，赋值给BeanDefinitionDocumentReader
// 注意createReaderContext(resource)方法，会把this对象XmlBeanDefinitionReader传给
// XmlReaderContext对象，XmlBeanDefinitionReader对象里面有容器对象
// DefaultListableBeanFactory，最后面取这个容器对象
documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
return this.getRegistry().getBeanDefinitionCount() - countBefore;
}进入registerBeanDefinitions方法
// 当前类：DefaultBeanDefinitionDocumentReader
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
this.doRegisterBeanDefinitions(doc.getDocumentElement());
}
// 当前类：DefaultBeanDefinitionDocumentReader
protected void doRegisterBeanDefinitions(Element root) {
// delegate=BeanDefinitionParserDelegate
BeanDefinitionParserDelegate parent = this.delegate;
// 这个方法可以看出delegate的具体类是那个
this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
...
}
// 留给子类实现的，在加载xml文件之前，做一些自定义的操作
this.preProcessXml(root);
// 解析xml文件为BeanDefinition对象
this.parseBeanDefinitions(root, this.delegate);
// 留给子类实现的，在加载xml文件之后，做一些自定义的操作
this.postProcessXml(root);
this.delegate = parent;
}进入parseBeanDefinitions方法
// 当前类：DefaultBeanDefinitionDocumentReader
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)) {
// 进入这个方法
this.parseDefaultElement(ele, delegate);
} else {
delegate.parseCustomElement(ele);
}
}
}
} else {
delegate.parseCustomElement(root);
}
}进入parseDefaultElement方法
// 当前类：DefaultBeanDefinitionDocumentReader
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
if (delegate.nodeNameEquals(ele, "import")) {
this.importBeanDefinitionResource(ele);
} else if (delegate.nodeNameEquals(ele, "alias")) {
this.processAliasRegistration(ele);
} else if (delegate.nodeNameEquals(ele, "bean")) {
// 讲解解析bean标签为BeanDefinition对象
this.processBeanDefinition(ele, delegate);
} else if (delegate.nodeNameEquals(ele, "beans")) {
this.doRegisterBeanDefinitions(ele);
}
}进入processBeanDefinition方法
// 当前类：DefaultBeanDefinitionDocumentReader
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 创建BeanDefinition对象，包装进BeanDefinitionHolder对象
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// 注册BeanDefinitionHolder对象，到容器的beanDefinitionMap集合
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
} catch (BeanDefinitionStoreException var5) {
this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
}
this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}进入parseBeanDefinitionElement方法
// 当前类：BeanDefinitionParserDelegate
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
return this.parseBeanDefinitionElement(ele, (BeanDefinition)null);
}
// 当前类：BeanDefinitionParserDelegate
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
String id = ele.getAttribute("id");
String nameAttr = ele.getAttribute("name");
List<String> aliases = new ArrayList();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
if (!StringUtils.hasText(id) && !aliases.isEmpty()) {
beanName = (String)aliases.remove(0);
if (this.logger.isTraceEnabled()) {
this.logger.trace("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
this.checkNameUniqueness(beanName, aliases, ele);
}
// 把xml文件的bean标签解析为一个BeanDefinition对象
AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
...
String[] aliasesArray = StringUtils.toStringArray(aliases);
// 把BeanDefinition对象装饰为BeanDefinitionHolder对象返回
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
} else {
return null;
}
}进入parseBeanDefinitionElement方法
// 当前类：BeanDefinitionParserDelegate
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute("class")) {
className = ele.getAttribute("class").trim();
}
String parent = null;
if (ele.hasAttribute("parent")) {
parent = ele.getAttribute("parent");
}
try {
// 真正的创建BeanDefinition对象，GenericBeanDefinition
AbstractBeanDefinition bd = this.createBeanDefinition(className, parent);
// 下面是对bd赋值，就是把bean标签的所有信息都转换为bd的属性
// 设置BeanDefinition对象的属性，singleton，scope，abstract，lazy-init，
// init-method，destroy-method，primary等等
this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
// 解析元数据
this.parseMetaElements(ele, bd);
this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
// 解析构造方法
this.parseConstructorArgElements(ele, bd);
// property属性
this.parsePropertyElements(ele, bd);
// Qualifier
this.parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(this.extractSource(ele));
AbstractBeanDefinition var7 = bd;
return var7;
} catch (ClassNotFoundException var13) {
this.error("Bean class [" + className + "] not found", ele, var13);
} catch (NoClassDefFoundError var14) {
this.error("Class that bean class [" + className + "] depends on not found", ele, var14);
} catch (Throwable var15) {
this.error("Unexpected failure during bean definition parsing", ele, var15);
} finally {
this.parseState.pop();
}
return null;
}
// 当前类：BeanDefinitionParserDelegate
protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName) throws ClassNotFoundException {
return BeanDefinitionReaderUtils.createBeanDefinition(parentName, className, this.readerContext.getBeanClassLoader());
}
// 当前类：BeanDefinitionReaderUtils
public static AbstractBeanDefinition createBeanDefinition(@Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
// 创建是一个GenericBeanDefinition对象
GenericBeanDefinition bd = new GenericBeanDefinition();
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
bd.setBeanClass(ClassUtils.forName(className, classLoader));
} else {
bd.setBeanClassName(className);
}
}
return bd;
}进入processBeanDefinition方法的registerBeanDefinition方法
// 当前类：BeanDefinitionReaderUtils
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
// registry对象为DefaultListableBeanFactory，可以看上面的registerBeanDefinitions方法
// 注册bean标签转换的BeanDefinition对象到DefaultListableBeanFactory容器里面
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
String[] var4 = aliases;
int var5 = aliases.length;
for(int var6 = 0; var6 < var5; ++var6) {
String alias = var4[var6];
registry.registerAlias(beanName, alias);
}
}
}进入registerBeanDefinition方法
// 当前类：DefaultListableBeanFactory
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
...
// 查询beanDefinitionMap集合是否包含该BeanDefinition对象
BeanDefinition existingDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
// 如果存在，不允许被覆盖，就抛异常
if (!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
...
// 允许覆盖就覆盖
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
// 不包含就put进入beanDefinitionMap集合
if (this.hasBeanCreationStarted()) { // 是否已经开始创建bean
synchronized(this.beanDefinitionMap) { // 锁住
this.beanDefinitionMap.put(beanName, beanDefinition);
...
}
} else { // 没有开始创建bean就直接put
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || this.containsSingleton(beanName)) {
this.resetBeanDefinition(beanName);
}
}总结
整体的流程还是很简单的，复杂的是初始化容器，然后对非懒加载的bean进行实例化和aop代理。
413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
