文章目录
1. 启动案例
1.1 maven导入jar包
1.2 尝试写一个接口和实现类
1.3 资源路径下创建application.xml文件，配置好bean
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="messageService" class="com.cjw.Spring.MessageServiceImpl"/>
</beans>
1.4 main方法下获得应用上下文，通过getBean方法获得相应的bean
2. 继承关系分析
ApplicationContext上继承BeanFactory接口，下有实现类ClassPathXmlApplicationContext、FileSystemXmlApplicationContext、AnnotationConfigApplicationContext
（1）实现类
图片来源于https://www.javadoop.com/post/spring-ioc#toc5
其中ClassPathXmlApplicationContext：在类路径下查找配置文件
FileSystemXmlApplicationContext：在文件系统路径下查找配置文件
AnnotationConfigApplicationContext:基于注解使用
（2）继承关系
图片来源于https://www.javadoop.com/post/spring-ioc
BeanFactory：Application的顶层接口，利用工厂模式，生产和管理bean的工厂
ListableBeanFactory：这个接口可以获取多个bean，BeanFactory获取一个bean
HierarchicalBeanFactory:该接口可以将各个BeanFactory设置父子关系
AutowireCapableBeanFactory :用于自动装配Bean，ApplicationContext虽然没有继承该接口，但是通过组合方式使用了该接口
ConfigurableListableBeanFactory ：一个特殊的接口，继承了第二层中三个接口
3. 容器初始化过程分析
@Override
public void refresh() throws BeansException, IllegalStateException {
//上锁，保证refresh（）方法的同步操作，使启动或销毁容器操作不会同时进行
synchronized (this.startupShutdownMonitor) {
// 1. 准备工作，记下容器的启动时间、标记'已启动'状态、处理配置文件中的占位符、校验配置文件
prepareRefresh();
/*==============================================================
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
initPropertySources();
// 校验配置文件
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
==============================================================*/
//2. 这个方法将配置文件内容解析成一个个BeanDefinition的实例，注册到BeanFactory中
//注册的过程气质就是将BeanDefinition保存到了注册中心（核心是一个beanName->beanDefinition的map）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
/*==============================================================
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//销毁之前的bean，重新创建beanFactory
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
==============================================================*/
/*==============================================================
protected final void refreshBeanFactory() throws BeansException {
//如果ApplicationContext已经加载过BeanFactory了，销毁所有Bean，关闭BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 创建DefaultListableBeanFactory ，它是ConfigurableListableBeanFactory 的实现类，
//因此同时继承了ListableBeanFactory、HierarchicalBeanFactory、AutowireCapableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
==============================================================*/
/*==============================================================
protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
//配置是否允许被覆盖（在配置文件中定义bean时使用了相同的id或name）
if (this.allowBeanDefinitionOverriding != null) {
beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
//是否允许Bean的循环依赖（A依赖B，B依赖A）
if (this.allowCircularReferences != null) {
beanFactory.setAllowCircularReferences(this.allowCircularReferences);
}
}
==============================================================*/
/*==============================================================
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 创建一个 XmlBeanDefinitionReader 实例来加载各个Bean
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
//配置beanDefinitionReader
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
//重点
loadBeanDefinitions(beanDefinitionReader);
}
==============================================================*/
/*==============================================================
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);
}
}
==============================================================*/
/*==============================================================
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = getConfigResources();
if (configResources != null) {
// 往下看
reader.loadBeanDefinitions(configResources);
}
String[] configLocations = getConfigLocations();
if (configLocations != null) {
// 2
reader.loadBeanDefinitions(configLocations);
}
}
==============================================================*/
/*===============上面的reader.loadBeanDefinitions(configResources);方法会进入到这里
==============================================
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;
this.logger.debug("Loading bean definitions");
//将配置文件转换成一颗DOM树
Element root = doc.getDocumentElement();
//从根节点开始解析文件
this.doRegisterBeanDefinitions(root);
}
==============================================================*/
/*===============上面的this.doRegisterBeanDefinitions(root);方法会进入到这里
解析default namespace 涉及到的四个标签 <import />、<alias />、<bean /> 和 <beans />
解析其他属于custom 下的标签
==============================================
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);
}
}
==============================================================*/
/*=======================以分析<bean>标签为例==============================================
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
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：用于根据<bean>标签下信息定义一个BeanDefinitionHolder ==============================================
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
String id = ele.getAttribute("id");
String nameAttr = ele.getAttribute("name");
List<String> aliases = new ArrayList();
//将name属性以逗号、分号、空格切分，形成一个别名列表数组
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
//如果<bean>标签下没有定义id，则将别名列表中的第一个元素用作id，即beanname
if (!StringUtils.hasText(id) && !aliases.isEmpty()) {
beanName = (String)aliases.remove(0);
if (this.logger.isDebugEnabled()) {
this.logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
this.checkNameUniqueness(beanName, aliases, ele);
}
//重点！！这个方法的作用就是根据<bean...></bean>的配置创建一个beanDefinition，然后将配置找那个信息都设置到实例中
AbstractBeanDefinition beanDefinition = this.parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
} else {
beanName = this.readerContext.generateBeanName(beanDefinition);
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Neither XML 'id' nor 'name' specified - using generated bean name [" + beanName + "]");
}
} catch (Exception var9) {
this.error(var9.getMessage(), ele);
return null;
}
}
String[] aliasesArray = StringUtils.toStringArray(aliases);
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
} else {
return null;
}
}
==============================================================*/
/*=======================根据<bean...></bean>的配置创建一个beanDefinition中具体的方法==============================================
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute("class")) {
className = ele.getAttribute("class").trim();
}
try {
String parent = null;
if (ele.hasAttribute("parent")) {
parent = ele.getAttribute("parent");
}
//创建BeanDefinition，设置类信息
AbstractBeanDefinition bd = this.createBeanDefinition(className, parent);
//向上一步骤创建的BeanDefinition中设置其他的一些属性
this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
//下面的步骤是解析<bean>内部的子元素，解析出来都放在bd中
this.parseMetaElements(ele, bd);
this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
this.parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
this.parseConstructorArgElements(ele, bd);
this.parsePropertyElements(ele, bd);
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;
}
==============================================================*/
/*----------------------回到解析 <bean /> 的入口方法:------------------
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 将 <bean /> 节点转换为 BeanDefinitionHolder，就是上面说的一堆
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 如果有自定义属性的话，进行相应的解析，先忽略
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//这步操作是注册Bean
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// 注册完成后，发送事件
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
==============================================================*/
/*=====================================================================
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
//注册这个bean
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
String[] aliases = definitionHolder.getAliases();
//如果还有别名，要将别名和该beanName保存在一个map中，alias->beanName,维护映射关系
//这样就可以通过别名先找到beanName，再进行进一步的查找
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);
}
}
}
==============================================================*/
/*=====================继续分析如何注册Bean================================================
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition)beanDefinition).validate();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var9);
}
}
BeanDefinition oldBeanDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
//处理重复名称的Bean定义的情况
if (oldBeanDefinition != null) {
//如果不允许覆盖的话，抛异常
if (!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound.");
}
if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
if (this.logger.isWarnEnabled()) {
//用框架定义的Bean覆盖用户自定义的Bean
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
} else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
//用新的Bean覆盖旧的Bean
this.logger.info("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
} else if (this.logger.isDebugEnabled()) {
//用同等的Bean覆盖旧的Bean，这里是指equals方法返回true的Bean
this.logger.debug("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
}
//覆盖
this.beanDefinitionMap.put(beanName, beanDefinition);
} else {
//判断是否已经有其他的Bean开始初始化了
//注意：“注册Bean”这个动作结束，Bean依然还没开始初始化
if (this.hasBeanCreationStarted()) {
synchronized(this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
} else {
//正常情况下会进入这个分支
//将BeanDefinition放入这个map,这个map中保存了所有的BeanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
//这是个ArrayList，所有会按照bean配置的顺序保存每一个注册的Bean的名字
this.beanDefinitionNames.add(beanName);
// 这是个LinkedHashSet，代表手动注册的singleton bean
// 手动指的是通过调用以下方法注册的 bean ：
// registerSingleton(String beanName, Object singletonObject)
// 这不是重点，解释只是为了不让大家疑惑。Spring 会在后面"手动"注册一些 Bean，
// 如 "environment"、"systemProperties" 等 bean，我们自己也可以在运行时注册 Bean 到容器中的
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || this.containsSingleton(beanName)) {
this.resetBeanDefinition(beanName);
}
}
==============================================================*/
/*############################################################################################################
上面的过程中主要是分析obtainFreshBeanFactory方法，这个方法将配置文件内容解析成一个个BeanDefinition的实例，注册到BeanFactory中。注册的过程其实就是将BeanDefinition保存到了注册中心（核心是一个beanName->beanDefinition的map）
############################################################################################################*/
// Prepare the bean factory for use in this context.
//3. 设置Bean的类加载器，添加几个BeanPostProcessor，手动注册几个特殊的bean
prepareBeanFactory(beanFactory);
/*==============================================================
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// BeanFactory需要加载Bean，就需要类加载器。这里设置为加载当前ApplicationContext类的类加载器
beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
//向BeanFactory中添加BeanPostProcessor。实现了Aware接口的beans在初始化的时候，这个processor负责回调
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//下面几行的意思是，如果某个bean依赖于以下接口的实现类，在自动装配的时候忽略它们，Spring会通过其他方式处理这些依赖
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
//下面几行就是为特殊的几个 bean 赋值，如果有 bean 依赖了以下几个，会注入这边相应的值，
//之前我们说过，"当前 ApplicationContext 持有一个 BeanFactory"，这里解释了第一行
// ApplicationContext 还继承了 ResourceLoader、ApplicationEventPublisher、MessageSource
// 所以对于这几个依赖，可以赋值为 this，注意 this 是一个 ApplicationContext
// 那这里怎么没看到为 MessageSource 赋值呢？那是因为 MessageSource 被注册成为了一个普通的 bean
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
//在bean实例化后，如果是ApplicationListener的子类，那么将其添加到listener列表中，可以理解成：注册事件监听器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found. 运行时织入
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 注册默认的环境相关beans
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
==============================================================*/
try {
// Allows post-processing of the bean factory in context subclasses.
//Bean如果实现了BeanFactorypostProcess这个接口，那么在容器初始化后Spring会调用里面的postProcessBeanFactory方法
//4. 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
postProcessBeanFactory(beanFactory);
//5. 调用BeanFactoryPostProcessors各个实现类的postProcessBeanFactory（factory）方法
invokeBeanFactoryPostProcessors(beanFactory);
//6. 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。这里仅仅是注册，之后会看到回调这两方法的时机
registerBeanPostProcessors(beanFactory);
//7. 初始化该ApplicationContext的MessageSource
initMessageSource();
//8. 初始化该ApplicationContext的事件通知器
initApplicationEventMulticaster();
//9. 在该ApplicationContext具体的子类中初始化一些特殊的bean
onRefresh();
//10. 检测监听器的beans并注册他们
registerListeners();
//11 初始化所有的非懒加载 singleton beans,将在下面的标题中单独分析
finishBeanFactoryInitialization(beanFactory);
//12. 最后广播事件，ApplicationContext 初始化完成
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 有异常则销毁已经创建好的singleton beans避免bean占用资源
destroyBeans();
// 重置active标志位
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
初始化所有的非懒加载singleton beans
其中的
//11 初始化所有的非懒加载 singleton beans
finishBeanFactoryInitialization(beanFactory);
主要作用就是初始化所有的非懒加载 singleton beans，也是整个xml解析、加载、注册、初始化Bean过程中十分重要的一步。
到目前为止，应该说BeanFactory已经创建完成，并且所有实现了BeanFactoryPostProcessor接口的Bean都已经初始化并且其中的PostProcessorBeanFactory（factory）方法已经回调执行了，并且Spring已经手动注册了一些特殊的Bean，如 环境beans，系统beans等等
剩下的过程就是初始化所有非懒加载的singleton beans了
预初始化
在初始化操作之前会进行预初始化操作,在preInstantiateSingletons函数中比如如果有Bean继承，则合并父Bean的配置；如果bean实现了SmartInitializingSingleton 接口，会进行相应的函数回调等等。
正式初始化
在doGetBean函数中，会首先判断该bean是否已经被初始化了，若被初始化则直接从容器中返回；否则就先初始化再返回，这个时候就要进入createBean方法。
//第三个参数args数组代表创建实例需要的参数，也就是给构造方法或者工厂Bean用的参数。在初始化阶段，这个参数为null
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//确保BeanDefinition中的Class被加载
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
//准备方法覆写
try {
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var7) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var7);
}
Object beanInstance;
try {
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var8);
}
//在这里就要创建Bean了，下面一个代码块会分析
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//说明不是FactoryBean，这里实例化Bean，非常关键
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
//bean实例
final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
//bean类型
Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
mbd.resolvedTargetType = beanType;
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
//下面的代码用于解决循环依赖问题
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
//前面的过程负责bean的实例化，到了这里，就是负责属性装配，设置具体的值
this.populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
// 还记得 init-method 吗？还有 InitializingBean 接口？还有 BeanPostProcessor 接口？
// 这里就是处理 bean 初始化完成后的各种回调
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
}
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
在doCreateBean函数中主要涉及到了三个部分：创建Bean实例的createBeanInstance 方法->依赖注入的populateBean方法->回调方法initializeBean方法
（1）创建Bean实例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
//确保已经加载了此class
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
//校验类的访问权限
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
} else if (mbd.getFactoryMethodName() != null) {
//采用工厂方法实例化
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
//如果不是第一次创建，比如第二次创建prototype bean
//这种情况下可以从第一次创建知道采用无参构造函数还是构造函数依赖注入完成实例化
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized(mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
//采用无参构造函数还是构造函数依赖注入
return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
//判断是否采用有参构造函数
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
return ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args) ? this.instantiateBean(beanName, mbd) : this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
以无参构造函数构造实例来分析，进入instantiateBean方法
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
//不存在方法覆写，就利用java反射实例化，否则使用CGLIB
if (bd.getMethodOverrides().isEmpty()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
//采用了反射技术
final Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
constructorToUse = (Constructor)AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
public Constructor<?> run() throws Exception {
return clazz.getDeclaredConstructor((Class[])null);
}
});
} else {
constructorToUse = clazz.getDeclaredConstructor((Class[])null);
}
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
//利用构造方法进行实例化
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
//使用CGLIB来实例化
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
（2）Bean属性注入
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
//bean实例的所有属性
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!((PropertyValues)pvs).isEmpty()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
} else {
boolean continueWithPropertyPopulation = true;
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator var6 = this.getBeanPostProcessors().iterator();
while(var6.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var6.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (continueWithPropertyPopulation) {
if (mbd.getResolvedAutowireMode() == 1 || mbd.getResolvedAutowireMode() == 2) {
MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
//通过名字找到所有属性值，如果是bean依赖，先初始化依赖的bean，
if (mbd.getResolvedAutowireMode() == 1) {
this.autowireByName(beanName, mbd, bw, newPvs);
}
//通过类型装配
if (mbd.getResolvedAutowireMode() == 2) {
this.autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = mbd.getDependencyCheck() != 0;
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
Iterator var9 = this.getBeanPostProcessors().iterator();
while(var9.hasNext()) {
BeanPostProcessor bp = (BeanPostProcessor)var9.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
pvs = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
if (needsDepCheck) {
this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
}
}
//设置bean实例的属性值
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
}
（3）方法回调initializeBean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
AbstractAutowireCapableBeanFactory.this.invokeAwareMethods(beanName, bean);
return null;
}
}, this.getAccessControlContext());
} else {
// 如果 bean 实现了 BeanNameAware、BeanClassLoaderAware 或 BeanFactoryAware 接口，回调
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// BeanPostProcessor 的 postProcessBeforeInitialization 回调
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//处理bean中定义的init-method
//或者bean实现了initializinBean接口，调用afterProperties（）方法
//进入该方法可以发现如果一个Bean实现了initializinBean接口，在初始化该Bean的时候会先执行afterProperties方法，后执行init-method配置的方法
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
// BeanPostProcessor 的 postProcessAfterInitialization 回调
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
总结
容器的启动过程从AbstractApplicationContext抽象类的refresh方法开始。
- 准备工作
记录下容器的启动时间，标记容器开启和关闭状态位，校验配置文件 - 解析配置文件，创建BeanDefinition实例，注册进BeanFactory中
（1）将配置文件转换成一颗DOM树，从根节点开始解析文件。
（2）解析default namespace涉及到的四个标签 < import/> < alias/> < bean/>和< beans/> ;
解析其他属于custom下的标签
（3）以< bean/>标签为例，根据标签下的内容形成一个个的BeanDefiniton，然后放入注册中心中，说到底核心是一个beanName->BeanDefinition的map - 设置BeanFactory的类加载器，添加BeanPostProcessor，手动注册几个bean
- 具体的子类添加一个特殊的BeanFactoryPostProcessor 的实现类或做点什么事
- 调用上一步实现类的PostProcessorBeanFactory（factory）回调方法
- 注册BeanPostProcessor实现类，其中的两个方法会在Bean初始化之前和初始化之后得到执行
- 初始化当前ApplicationContext的MessageSource
- 初始化当前ApplicationContext的事件广播器
- 注册事件监听器
- 初始化所有的非懒加载 singleton beans
（1）预初始化：如果有Bean继承关系，合并父Bean的配置；如果bean实现了SmartInitializingSingleton 接口，进行相应的函数回调等等。
（2）正式初始化：判断bean是否已被初始化，若被初始化则直接返回，否则就进行初始化。分为三步：
第一步–创建Bean实例
如果不存在方法覆写，就利用java反射实例化，否则使用CGLB
第二步–Bean属性注入
通过名字装配、通过类型装配等
第三步–方法回调
- 如果bean实现了BeanNameAware、BeanClassLoaderAware或者BeanFactoryAware接口，调用回调方法
- 如果bean注册了BeanPostProcessor实现类，则调用postProcessBeforeInitialization 方法
- 如果bean实现了initializingBean接口，调用afterProperties（）方法
调用init-method配置的方法- 如果bean注册了BeanPostProcessor实现类，则调用postProcessAfterInitialization 方法
- 广播事件
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
