上一篇中分析springmvc对于annotation-driven注解的解析找到了MvcNameSpaceHandler类，这篇以此为由头，来分析spring初始化源码，来看如何找到的NameSpaceHandler，和如何进行容器初始化、bean实例加载
说实话不算什么深入分析，只能是把源码走了一遍，深入分析还容后续(些许瑕疵，前期部分代码是class文件反编译看的，有些var1一些变量可能不好阅读，后来下了源码，没改前边的文字)
目录
AbstractApplicationContext#refresh
AbstractApplicationContext#obtainFreshBeanFactory
AbstractApplicationContext#prepareBeanFactory
AbstractApplicationContext#invokeBeanFactoryPostProcessors
AbstractApplicationContext#registerBeanPostProcessors
AbstractApplicationContext#initApplicationEventMulticaster
AbstractApplicationContext#registerListeners
AbstractApplicationContext#finishBeanFactoryInitialization
AbstractApplicationContext#finishRefresh
beanFactory体系结构
BeanFactory ：一级接口，提供简单的bean获取、判断bean存在等功能
AutowireCapableBeanFactory ： 二级接口，提供工厂的装配功能
HierarchicalBeanFactory ：二级接口，提供父子容器的访问功能
ListableBeanFactory ：二级接口，提供容器内bean实例的枚举功能
ConfigurableBeanFactory ：三级接口，提供容器各种配置
ConfigurableListableBeanFactory ：四级接口，集大成者
DefaultListableBeanFactory ： 集大成者接口的实现类，下边分析的时候，生成的beanFactory就是这个类
入口
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
// applicationContext高级容器继承关系比较复杂我理解可能还不是很到位
// 跟到父类中，新建一个应用上下文对象
super(parent);
// 设置配置路径
this.setConfigLocations(configLocations);
if (refresh) {
// 初始化开始
this.refresh();
}
}
super():
public AbstractApplicationContext() {
this.logger = LogFactory.getLog(this.getClass());
this.id = ObjectUtils.identityToString(this);
this.displayName = ObjectUtils.identityToString(this);
this.beanFactoryPostProcessors = new ArrayList();
this.active = new AtomicBoolean();
this.closed = new AtomicBoolean();
this.startupShutdownMonitor = new Object();
this.applicationListeners = new LinkedHashSet();
this.resourcePatternResolver = this.getResourcePatternResolver();
}
AbstractApplicationContext#refresh
public void refresh() throws BeansException, IllegalStateException {
Object var1 = this.startupShutdownMonitor;
synchronized(this.startupShutdownMonitor) {
// 设置其启动日期和活动标志，以及一些属性初始化，略过
this.prepareRefresh();
// 这里是模板方法，实现是在子类中，new DefaultListableBeanFactory实例并解析配置获取beanDefintion等
// beanFactory系列接口是典型接口分离原则
// DefaultListableBeanFactory是beanFactory接口系列集大成者
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
// 配置beanFactory
this.prepareBeanFactory(beanFactory);
try {
// 子类可以去实现自己的逻辑，此文中这里是空实现
// web的上下文中AbstractRefreshableWebApplicationContext进行了环境和web特有bean实例的初始化
this.postProcessBeanFactory(beanFactory);
// 加载beanFactoryPostProcessor并执行，自定义的beanFactoryPostProcessor都在这加载和执行
this.invokeBeanFactoryPostProcessors(beanFactory);
// 加载所有BeanPostProcessors到容器
this.registerBeanPostProcessors(beanFactory);
// 国际化，信息源相关，此文不详解
this.initMessageSource();
// 初始化事件传播器
this.initApplicationEventMulticaster();
// 模板方法，调用子类某些特殊bean初始化操作，此文不详解
// servlet容器就在此加载，类：ServletWebServerApplicationContext
this.onRefresh();
// 为事件传播器注册事件监听器
this.registerListeners();
// 初始化剩余的单例bean（非懒加载方式）,Bean的IoC、DI和AOP都是发生在此步骤
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#obtainFreshBeanFactory
加载配置文件中的bean定义
本文是这个applicationContext走这，加载xml文件中的bean配置，boot web项目中就不走这加载bean了，走GenericApplicationContext#refreshBeanFactory，加载bean在invokeBeanFactoryPostProcessors()方法中
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 下边进入子类实现
this.refreshBeanFactory();
// 返回上边方法产生的beanFactory
return this.getBeanFactory();
}
public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
protected final void refreshBeanFactory() throws BeansException {
// 如果有了删了重新搞一个beanFactory
if (this.hasBeanFactory()) {
this.destroyBeans();
this.closeBeanFactory();
}
try {
// new BeanFactory()
DefaultListableBeanFactory beanFactory = this.createBeanFactory();
beanFactory.setSerializationId(this.getId());
this.customizeBeanFactory(beanFactory);
// 加载beanDefinition
this.loadBeanDefinitions(beanFactory);
// 把beanFactory设置到ApplicationContext对象中
this.beanFactory = beanFactory;
} catch (IOException var2) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2);
}
}
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(this.getInternalParentBeanFactory());
}
}AbstractXmlApplicationContext#loadBeanDefinitions(DefaultListableBeanFactory)
public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 创建beandefinitionReader类，reader中可以获取到beanFactory
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.setEnvironment(this.getEnvironment());
// 把ResourceLoader设置为当前ClassPathXmlApplicationContext对象
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
this.initBeanDefinitionReader(beanDefinitionReader);
// 从配置文件中读beanDefinition到beanFactory中
this.loadBeanDefinitions(beanDefinitionReader);
}
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
Resource[] configResources = this.getConfigResources();
if (configResources != null) {
reader.loadBeanDefinitions(configResources);
}
// 在本次入口代码中设置的xml文件路径
String[] configLocations = this.getConfigLocations();
if (configLocations != null) {
reader.loadBeanDefinitions(configLocations);
}
}
}一路往下点,忽略中间封装xml成resource类的代码
最后终于到了上边创建的XmlBeanDefinitionReader的loadBeanDefinitions(EncodedResource)
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Set<EncodedResource> currentResources = (Set)this.resourcesCurrentlyBeingLoaded.get();
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");
} else {
int var6;
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
Throwable var4 = null;
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// spring中常见的doXXX终于来了
var6 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
} catch (Throwable var24) {
var4 = var24;
throw var24;
} finally {
if (inputStream != null) {
if (var4 != null) {
try {
inputStream.close();
} catch (Throwable var23) {
var4.addSuppressed(var23);
}
} else {
inputStream.close();
}
}
}
} catch (IOException var26) {
throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), var26);
} finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
return var6;
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
// 把xml对应的资源resource对象转成Document对象
Document doc = this.doLoadDocument(inputSource, resource);
// 找对应的handler来解析Document对象
int count = this.registerBeanDefinitions(doc, resource);
return count;
}
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 解析成dom以后再交给专业的去解析
BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
int countBefore = this.getRegistry().getBeanDefinitionCount();
// createReaderContext()是创建了一个XmlReaderContext来解析document
// 这个XmlReaderContext下边有用到，它持有XmlBeanDefinitionReader引用，也就能访问beanFaactory
documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
return this.getRegistry().getBeanDefinitionCount() - countBefore;
}DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
// 专业的是委托给了BeanDefinitionParserDelegate对象来具体操作，成员有上边的XmlReaderContext
this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
String profileSpec = root.getAttribute("profile");
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, ",; ");
if (!this.getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + this.getReaderContext().getResource());
}
return;
}
}
}
// 空实现
this.preProcessXml(root);
// 正经解析
this.parseBeanDefinitions(root, this.delegate);
// 空实现
this.postProcessXml(root);
this.delegate = parent;
}
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// 判断这个是spring-bean配置还是aop,mvc等
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)) {
//<bean id="" />等从这解析
this.parseDefaultElement(ele, delegate);
} else {
// <mvc:annotation-driven/>从这走，本文走这
delegate.parseCustomElement(ele);
}
}
}
} else {
delegate.parseCustomElement(root);
}
}
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")) {
this.processBeanDefinition(ele, delegate);
} else if (delegate.nodeNameEquals(ele, "beans")) {
this.doRegisterBeanDefinitions(ele);
}
}
public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader {
public boolean isDefaultNamespace(@Nullable String namespaceUri) {
return !StringUtils.hasLength(namespaceUri) || "http://www.springframework.org/schema/beans".equals(namespaceUri);
}
public boolean isDefaultNamespace(Node node) {
return this.isDefaultNamespace(this.getNamespaceURI(node));
}
}BeanDefinitionParserDelegate#parseCustomElement(Element, BeanDefinition)
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
// 获取命名空间，mvc是http\://www.springframework.org/schema/mvc
String namespaceUri = this.getNamespaceURI(ele);
if (namespaceUri == null) {
return null;
} else {
// 这个this.readerContext就是上边提到的XmlReaderContext
// getNamespaceHandlerResolver()获取到DefaultNamespaceHandlerResolver对象来加载各个包下的spring.handlers 获取当前命名空间的handler
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
this.error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
} else {
// 执行解析， 这里的readerContext里是能获取到beanFactory的，在具体解析逻辑中业务调用这个传入对象的readerContext.getRegistry()获取beanFactory来往里边塞beanDefinition
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
}
}DefaultNamespaceHandlerResolver#resolve，从这算是到了上一篇MvcNameSpaceHandler的地方了
public DefaultNamespaceHandlerResolver() {
this((ClassLoader)null, "META-INF/spring.handlers");
}
// 默认找这里
public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
this(classLoader, "META-INF/spring.handlers");
}
public NamespaceHandler resolve(String namespaceUri) {
// 获取默认路径spring.handlers下配置的命名空间对应handler关系
Map<String, Object> handlerMappings = this.getHandlerMappings();
Object handlerOrClassName = handlerMappings.get(namespaceUri);
if (handlerOrClassName == null) {
return null;
} else if (handlerOrClassName instanceof NamespaceHandler) {
return (NamespaceHandler)handlerOrClassName;
} else {
String className = (String)handlerOrClassName;
try {
Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri + "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
} else {
NamespaceHandler namespaceHandler = (NamespaceHandler)BeanUtils.instantiateClass(handlerClass);
// 注册各个xml标签对应的解析类
// 下方见代码
namespaceHandler.init();
handlerMappings.put(namespaceUri, namespaceHandler);
return namespaceHandler;
}
} catch (ClassNotFoundException var7) {
throw new FatalBeanException("Could not find NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]", var7);
} catch (LinkageError var8) {
throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" + className + "] for namespace [" + namespaceUri + "]", var8);
}
}
}
private Map<String, Object> getHandlerMappings() {
Map<String, Object> handlerMappings = this.handlerMappings;
// 双重检查锁
if (handlerMappings == null) {
synchronized(this) {
handlerMappings = this.handlerMappings;
if (handlerMappings == null) {
try {
//handlerMappingLocation为META_INF/spring.handlers
// // 例如：http\://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.MvcNamespaceHandler
Properties mappings = PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Loaded NamespaceHandler mappings: " + mappings);
}
// 加载成map返回
handlerMappings = new ConcurrentHashMap(mappings.size());
CollectionUtils.mergePropertiesIntoMap(mappings, (Map)handlerMappings);
this.handlerMappings = (Map)handlerMappings;
} catch (IOException var5) {
throw new IllegalStateException("Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", var5);
}
}
}
return (Map)handlerMappings;
}
--------------------
public class MvcNamespaceHandler extends NamespaceHandlerSupport {
public MvcNamespaceHandler() {
}
public void init() {
this.registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
this.registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
this.registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
this.registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
this.registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
this.registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
this.registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
this.registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
this.registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
this.registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
this.registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
this.registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
this.registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
}
}再回到parseCustomElement方法，开始handler.parse(), 就是根据当前传入的Element来找对应的一个Parser类，进行对应的解析逻辑，把解析完毕的BeanDefinition放入beanFactory这块先不详细了就。
削微总结一下经历
AbstractRefreshableApplicationContext
主要用来对
BeanFactory
提供
refresh
功能。包括
BeanFactory
的创建和
BeanDefinition
的定
义、解析、注册操作。
AbstractXmlApplicationContext
主要提供对于
XML
资源
的加载功能。包括从
Resource
资源对象和资源路径中加载
XML
文件。
AbstractBeanDefinitionReader
主要提供对于
BeanDefinition
对象的读取功能。具体读取工作交给子类实现。
XmlBeanDefinitionReader (持有beanFactory对象引用，从Resource读取成Document)
主要通过
DOM4J
对于
XML
资源
的读取、解析功能，并提供对于
BeanDefinition
的注册功能。
DefaultBeanDefinitionDocumentReader定义如何解析
Document为BeanDefinition，内部又委托给
BeanDefinitionParserDelegate来加载NameSpaceHandler来具体解析xml文件内容，然后注册到beanFactory
至此obtainFreshBeanFactory方法就到此为止，回到最上边AbstractApplicationContext#refresh
AbstractApplicationContext#prepareBeanFactory
设置beanFactory属性
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.setBeanClassLoader(this.getClassLoader());
// SPEL表达式解析器SpelExpressionParser
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 不知道。。
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
// 给下边六个ignoreDependencyInterface忽略的Aware接口实现类注入当前的applicationContext
// beanPostProcessor和beanFactoryPostProcessor接口会新写一篇
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// ignoreDependencyInterface方法忽略指定依赖接口的自动装配指的是忽略接口中的set方法这样的自动装配方式
// ignoreDependency忽略指定依赖类型的自动装配指的是忽略参数class类型的自动装配
// 我另一篇文章对这个ignore进行了测试,链接：https://blog.csdn.net/xyjy11/article/details/113776587
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// registerResolvableDependency意思是指定该类型接口，如果外部要注入该类型接口的对象，则会注入我们指定的对象
// 例如，程序中需要@AutoWire了一个beanFactory，会注入这个DefaultListableBeanFactory对象，因为beanFactory实现很多，不指定会报错
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
if (beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 没有则注册几个bean
if (!beanFactory.containsLocalBean("environment")) {
beanFactory.registerSingleton("environment", this.getEnvironment());
}
if (!beanFactory.containsLocalBean("systemProperties")) {
beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean("systemEnvironment")) {
beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
}
}AbstractApplicationContext#invokeBeanFactoryPostProcessors
加载BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor并执行，对beanDefinition和beanFactory进行自定义处理
BeanFactoryPostProcessor(ConfigurableListableBeanFactory var1)：在加载完xml中的bean定义后做一些改变，方法：postProcessBeanFactory(ConfigurableListableBeanFactory var1)
BeanDefinitionRegistryPostProcessor：继承了BeanFactoryPostProcessor接口，可以用来注册更多的bean到spring容器中，BeanDefinitionRegistry提供了丰富的方法来操作BeanDefinition，实现这个接口的实现类有两个方法需要执行，1、postProcessBeanDefinitionRegistry(BeanDefinitionRegistry var1) 2、postProcessBeanFactory(ConfigurableListableBeanFactory var1)
boot项目加载bean就在这一步加载，入口是ConfigurationClassPostProcessor类
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
// 传入已经注册的BeanFactoryPostProcessor
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}1、先调用BeanDefinitionRegistryPostProcessors实现类的postProcessBeanDefinitionRegistry方法，按Ordered接口排序执行
2、再调用BeanDefinitionRegistryPostProcessors实现类的postProcessBeanFactory方法
3、调用接口BeanFactoryPostProcessor实现类的postProcessBeanFactory方法
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet();
// 普通的BeanFactoryPostProcessor集合
ArrayList regularPostProcessors;
// BeanDefinitionRegistryPostProcessor集合
ArrayList registryProcessors;
int var9;
// 临时用的BeanDefinitionRegistryPostProcessor集合
ArrayList currentRegistryProcessors;
String[] postProcessorNames;
// 进if,因为DefaultListableBeanFactory实现了BeanDefinitionRegistry接口
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
regularPostProcessors = new ArrayList();
registryProcessors = new ArrayList();
Iterator var6 = beanFactoryPostProcessors.iterator();
// 如果beanFactoryPostProcessors入参有，先处理这些，本文进入方法这里是不走的，暂时也没发现什么情况会走到
while(var6.hasNext()) {
BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
} else {
regularPostProcessors.add(postProcessor);
}
}
currentRegistryProcessors = new ArrayList();
// 获取所有实现BeanDefinitionRegistryPostProcessor的beanName
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
String[] var16 = postProcessorNames;
var9 = postProcessorNames.length;
int var10;
String ppName;
for(var10 = 0; var10 < var9; ++var10) {
ppName = var16[var10];
// 先处理优先级最高的PriorityOrdered实现类
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 加入临时集合，下边立马处理
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 加入set，表示处理过了这个bean
processedBeans.add(ppName);
}
}
// getOrder()排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 这个集合是为了之后调用实现类的postProcessBeanFactory方法
registryProcessors.addAll(currentRegistryProcessors);
// 这个调用的是临时集合那些实现类的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 临时集合清空
currentRegistryProcessors.clear();
// 再次获取并处理优先级较低的Order实现类的那一批
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
var16 = postProcessorNames;
var9 = postProcessorNames.length;
for(var10 = 0; var10 < var9; ++var10) {
ppName = var16[var10];
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
boolean reiterate = true;
while(reiterate) {
reiterate = false;
// 再处理那些没有order接口的bean
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
String[] var19 = postProcessorNames;
var10 = postProcessorNames.length;
for(int var26 = 0; var26 < var10; ++var26) {
String ppName = var19[var26];
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// 再统一调用两个集合beanProcessor的另一个postProcessBeanFactory方法
invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
} else {
invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
}
// 上边处理了BeanDefinitionRegistryPostProcessor实现类，现在开始处理BeanFactoryPostProcessor的实现类
// 处理方式一样，按优先级处理
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
regularPostProcessors = new ArrayList();
registryProcessors = new ArrayList();
currentRegistryProcessors = new ArrayList();
postProcessorNames = postProcessorNames;
int var20 = postProcessorNames.length;
String ppName;
for(var9 = 0; var9 < var20; ++var9) {
ppName = postProcessorNames[var9];
// 上边已经处理过的就不走了
if (!processedBeans.contains(ppName)) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
registryProcessors.add(ppName);
} else {
currentRegistryProcessors.add(ppName);
}
}
}
// 排序PriorityOrdered接口的，并执行
sortPostProcessors(regularPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
// Ordered接口的开始处理
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
Iterator var21 = registryProcessors.iterator();
while(var21.hasNext()) {
String postProcessorName = (String)var21.next();
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 排序Ordered接口的，并执行
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
// 一般的PostProcessors开始处理
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
Iterator var24 = currentRegistryProcessors.iterator();
while(var24.hasNext()) {
ppName = (String)var24.next();
nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 执行一般的PostProcessors
invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
// 清缓存，初始化缓存集合
beanFactory.clearMetadataCache();
}AbstractApplicationContext#registerBeanPostProcessors
beanPostProcessors在bean初始化前后进行处理
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
} public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 查当前容器所有BeanPostProcessor实现类
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
List<BeanPostProcessor> internalPostProcessors = new ArrayList();
List<String> orderedPostProcessorNames = new ArrayList();
List<String> nonOrderedPostProcessorNames = new ArrayList();
String[] var8 = postProcessorNames;
int var9 = postProcessorNames.length;
// 跟上边BeanFactoryPostProcessor一样处理，先PriorityOrdered，再Ordered，再一般的
String ppName;
BeanPostProcessor pp;
for(int var10 = 0; var10 < var9; ++var10) {
ppName = var8[var10];
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 按getOrder排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 放到一个List<beanPostProcessors>集合中
registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
// Ordered
List<BeanPostProcessor> orderedPostProcessors = new ArrayList(orderedPostProcessorNames.size());
Iterator var14 = orderedPostProcessorNames.iterator();
while(var14.hasNext()) {
String ppName = (String)var14.next();
BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 排序、加到list集合
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors);
// 处理一般的，没Ordered接口的
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList(nonOrderedPostProcessorNames.size());
Iterator var17 = nonOrderedPostProcessorNames.iterator();
while(var17.hasNext()) {
ppName = (String)var17.next();
pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
// 上边对MergedBeanDefinitionPostProcessor实现类另存了一个集合，在最后重新进行排序和注册，注册代码在下边，先把原先的删掉再注册新的
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
// 往List<BeanPostProcessor>添加的操作
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
// 先删后增
this.beanPostProcessors.remove(beanPostProcessor);
// 这两个是干啥用的暂时还不知道
if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
this.hasInstantiationAwareBeanPostProcessors = true;
}
if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
this.hasDestructionAwareBeanPostProcessors = true;
}
this.beanPostProcessors.add(beanPostProcessor);
}AbstractApplicationContext#initApplicationEventMulticaster
ApplicationContext都实现了 ApplicationEventPublisher事件发布接口，实现方法publishEvent中调用applicationEventMulticaster事件派发器去调用所有listener执行
//看容器中是否已经有applicationEventMulticaster事件派发器，没有则新增一个，用来保存ApplicationListener和调用ApplicationListener方法
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
} else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
if (this.logger.isTraceEnabled()) {
this.logger.trace("No 'applicationEventMulticaster' bean, using [" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}AbstractApplicationContext#registerListeners
加载监听器ApplicationListener接口的实现类，遗留问题：earlyApplicationEvents什么时候会存在
protected void registerListeners() {
// Register statically specified listeners first.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}AbstractApplicationContext#finishBeanFactoryInitialization
获取单例bean存在三级缓存，singletonObjects、earlySingletonObjects、singletonFactories
遗留问题：
1、ChildBeanDefinition、RootBeanDefinition、GenericBeanDefinition区别，合并详细
2、AbstractAutowireCapableBeanFactory#createBeanInstance 创建bean包装对象（反射new对象的操作）没有详细跟踪分析
3、AbstractAutowireCapableBeanFactory#populateBean 对new出来的对象进行属性注入的操作，没有详细跟踪分析
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
// 注入一个默认的StringValueResolver解析器，解析@Value类型注解的属性
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 冻结beanDefi配置，要实例化bean了不允许修改了
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化所有非懒加载的单例bean
beanFactory.preInstantiateSingletons();
}DefaultListableBeanFactory#preInstantiateSingletons
String FACTORY_BEAN_PREFIX = "&";
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
// BeanDefinition分种类，有子类ChildBeanDefinition，需要合并父子定义，返回一个可用的RootDF类型，至于子类DF是个啥，待续
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 非抽象、单例、非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// FactoryBean是一种工厂对象，实现了这个接口的bean，在getBean获取实例时，不是反射newInstance一个实例，而是调用这个工厂对象的getObject方法返回实例
if (isFactoryBean(beanName)) {
// 上边说了getBean(FactoryBeanName)时是调用这个e对象的getObject方法获取实例
// 如果就想获取这个FactoryBean对象，如下行，getBean("&" + FactoryBeanName)
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 实例化bean
getBean(beanName);
}
}
}
else {
// 实例化bean
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}AbstractBeanFactory#doGetBean
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 获取单例对象
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 已经实例化了，获取到了
// 省略了日志代码
。。。。。
// 这里不详细看了，这里主要是FactoryBean来调用getObject()来获取实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 缓存集合没有这个bean
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 缓存已经有这个原型bean,正在创建
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
// 当前有父beanFactory,且当前子beanFactory没有这个Bean定义
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
//将指定的bean标记为已创建（或即将创建）
markBeanAsCreated(beanName);
}
try {
// 获取合并后的RBD对象
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 如果bean定义是abstract，报错
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 获取bean定义的显示依赖，即初始化mbd之前必须初始化dependsOn数组中的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 如果有显示依赖，判断是否循环依赖，类似死锁
// 内部使用dependentBeanMap<String, Set<String>> 表示初始化key之后，才能初始化value中的bean。
// 递归判断了一下beanName初始化之后才能初始化的bean集合有没有dep这个bean
if (isDependent(beanName, dep)) {
// 循环了就报错
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 注意参数位置是变了的，这里是把依赖的两个A\B bean放入集合，为了下次判断是否循环依赖, 就是上边说的dependentBeanMap<String, Set<String>> 集合
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// 原型bean
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
// 放入正在创建的集合中，上边代码有判断
beforePrototypeCreation(beanName);
// 创建个新实例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
// 从正在创建的集合中删除
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 既不是单例又不是原型，根据配置的生命周期范围获取实例
// restart\refresh\request\session\application
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
// 这比较简单，单例集合中找，没找到再去未初始化完成的单例集合中找
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// earlySingletonObjects保存未初始化完成的单例bean集合，为了避免循环依赖
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
AbstractAutowireCapableBeanFactory#doCreateBean
正经创建bean的地方
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 创建包装对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
// 提前暴露对象ObjectFactory
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 注入bean对象的属性，getter/setter设置属性
populateBean(beanName, mbd, instanceWrapper);
// 初始化bean对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!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 " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}populateBean方法是获取属性，解析属性值\简单类型或引用，查找容器内bean,最后赋值操作，（autowiring和@Autowire的属性都在这里被注入）
其中注解的注入的操作是由AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues来完成，AutowiredAnnotationBeanPostProcessor继承InstantiationAwareBeanPostProcessor，populateBean中对InstantiationAwareBeanPostProcessor有处理
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}AbstractAutowireCapableBeanFactory#initializeBean
bean调用init方法前后调用beanPostProcessor方法前后处理
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}aop入口AbstractAutoProxyCreator#postProcessAfterInitialization，实现类AnnotationAwareAspectJAutoProxyCreator
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}InstantiationAwareBeanPostProcessor需要重点记录一下，有四个方法
postProcessBeforeInstantiation、postProcessAfterInstantiation这两分别是实例化前后调用，（createBean、populateBean）方法中被调用，after来做注入操作，before本文没有体现，看代码意思是在new之前如果方法中有处理，返回代理对象的话，spring会将这个代理对象作为实例化的对象来做下一步操作
另外两个就是BeanPostProcessor带的两个方法，postProcessBeforeInitialization、postProcessAfterInitialization在initializeBean 方法中来调用，例如返回aop代理对象
AbstractApplicationContext#finishRefresh
遗留问题：DefaultLifecycleProcessor是干啥的
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 容器刷新事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}遗留问题汇总
AbstractApplicationContext#obtainFreshBeanFactory
beanDefinition的DependsOn属性是怎么来的
AbstractApplicationContext#registerListeners
加载监听器ApplicationListener接口的实现类，遗留问题：earlyApplicationEvents什么时候会存在
AbstractApplicationContext#finishBeanFactoryInitialization
1、ChildBeanDefinition、RootBeanDefinition、GenericBeanDefinition区别，合并详细
2、AbstractAutowireCapableBeanFactory#createBeanInstance 创建bean包装对象（反射new对象的操作）没有详细跟踪分析
3、AbstractAutowireCapableBeanFactory#populateBean 对new出来的对象进行属性注入的操作，没有详细跟踪分析
AbstractApplicationContext#finishRefresh
DefaultLifecycleProcessor是干啥的
AnnotationConfigApplicationContext启动有什么不一样，以及如何加载的注解bean类
aop流程AbstractAutoProxyCreator#postProcessAfterInitialization、事务TransactionInterceptor#invoke
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
