1、refresh()
refresh大致流程图
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
this.prepareRefresh();
//将配置文件解析成BeanDefinition对象，并没有在这步初始化
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
this.prepareBeanFactory(beanFactory);
try {
this.postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
this.invokeBeanFactoryPostProcessors(beanFactory);
this.registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
this.initMessageSource();
this.initApplicationEventMulticaster();
this.onRefresh();
this.registerListeners();
this.finishBeanFactoryInitialization(beanFactory);
this.finishRefresh();
} catch (BeansException var10) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
}
this.destroyBeans();
this.cancelRefresh(var10);
throw var10;
} finally {
this.resetCommonCaches();
contextRefresh.end();
}
}
}
2、obtainFreshBeanFactory()——注册BeanDefinitions
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//GenericApplicationContext不能刷新
//GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once
//比如基于代码注解创建的Bean容器
this.refreshBeanFactory();
return this.getBeanFactory();
}
@Override
protected final void refreshBeanFactory() throws BeansException {
//如果已经有BeanFactory了
//销毁所有Bean,关闭BeanFactory
//基于xml创建Bean是可以refresh的，实现Bean的动态创建
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
//创建BeanFactory，类型为DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
customizeBeanFactory(beanFactory);
// 加载BeanDefinitions，这个方法很重要，下面看
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
接下来就是地狱般的loadBeanDefinitions()——加载BeanDefinitions，这里设计上比较复杂，扛过这里后面的就简单一些了
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
// 给这个 BeanFactory 实例化一个 XmlBeanDefinitionReader
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
// Configure the bean definition reader with this context's
// resource loading environment.
// 国际化
beanDefinitionReader.setEnvironment(this.getEnvironment());
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
// 初始化 BeanDefinitionReader，其实这个是提供给子类覆写的，
initBeanDefinitionReader(beanDefinitionReader);
// 重点来了，继续往下
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);
}
}
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;
//定义Bean的xml可能有多个，这里做的是分次处理，每次只处理一个xml文件
//同时count计数，count表示的就是处理的个数
for(int var5 = 0; var5 < var4; ++var5) {
String location = var3[var5];
count += this.loadBeanDefinitions(location);
}
return count;
}
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
//获取ResourceLoader，这个东西是负责解析资源文件成Resource的
//当解析成功并且它确实存在，就可以通过Resource获取他的InputStream，去真正的逐行读取文件内容
ResourceLoader resourceLoader = this.getResourceLoader();
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为单个路径了，这里没搞懂为什么设计成数组对象
Resource[] resources = ((ResourcePatternResolver)resourceLoader).getResources(location);
// 继续深入loadBeanDefinitions
count = this.loadBeanDefinitions(resources);
if (actualResources != null) {
Collections.addAll(actualResources, resources);
}
//省略了一些不重要的代码
return count;
}
}
}
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
Assert.notNull(resources, "Resource array must not be null");
int count = 0;
Resource[] var3 = resources;
int var4 = resources.length;
//把Resource[]拆分成单个，逐个处理
for(int var5 = 0; var5 < var4; ++var5) {
Resource resource = var3[var5];
count += this.loadBeanDefinitions((Resource)resource);
}
return count;
}
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
//这里要new EncodedResource，将Resource再包装进EncodedResource
//里面指定了编码格式和字符集格式，我们这里都是null
return this.loadBeanDefinitions(new EncodedResource(resource));
}
//EncodedResource()的构造方法
private EncodedResource(Resource resource, @Nullable String encoding, @Nullable Charset charset) {
Assert.notNull(resource, "Resource must not be null");
//指定负责的resource
this.resource = resource;
//指定编码格式，我们没有，用默认的
this.encoding = encoding;
//指定字符集格式，我们没用，用默认的
this.charset = charset;
}
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);
}
//这是一个ThreadLocal，里面记录了正在进行的Resource解析，当前Resource还没有放入
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 {
//到这里真正从Resource中获取InputStream，准备干活了。
InputStream inputStream = encodedResource.getResource().getInputStream();
Throwable var4 = null;
try {
//InputSource是SAX解析器用于读取 XML 数据的输入源，专门读InputSource，不要和InputStream混淆了
//这个构造方法内设置了InputSource的字节输入流为inputstream
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
//设置编码类型，我们本次是null
inputSource.setEncoding(encodedResource.getEncoding());
}
//重头戏来了，这个var6还是count
var6 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
//省略了一些不重要代码，不然看着很难受
return var6;
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
try {
//EntityResolver的作用是项目本身就可以提供一个如何寻找DTD 声明的方法，即由程序来实现寻找 DTD 声明的过程
//先简单介绍一下Document
//Document是 XML 文档的一个表示,通常用于 XML 数据的解析、创建和操作,并提供了访问文档中各个部分的方法
//内部会校验xml约束模式是DTD模式还是XSD模式还是默认模式，我们先进入这里看看
//DTD和XCD就是XML的文档定义类型
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;
//省略一堆异常捕获
}
- 我们需要介绍一下loadDocument()这些参数
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
return this.documentLoader.loadDocument(
//这个说过了
inputSource,
//用于解析 XML 文档中的实体引用
this.getEntityResolver(),
//用于处理解析过程中的错误
this.errorHandler,
//表示 XML 验证模式,DTD或XCD模式
this.getValidationModeForResource(resource),
//是否开启命名空间感知，开启了会保留命名空间信息
this.isNamespaceAware());
}
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
//创建DocumentBuilderFactory，内部指定了命名空间和文档类型
DocumentBuilderFactory factory = this.createDocumentBuilderFactory(validationMode, namespaceAware);
if (logger.isTraceEnabled()) {
logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
}
//然后再创建DocumentBuilder，实例自然是从上面创建出的工厂中创建的
//然后，设置了解析器和异常处理器
DocumentBuilder builder = this.createDocumentBuilder(factory, entityResolver, errorHandler);
//将文档解析成Document
//里面又是地狱般的parse，比loadBeanDefinitions还多，不深入了
return builder.parse(inputSource);
}
我们回到外层方法
int count = this.registerBeanDefinitions(doc, resource);
解析及注册BeanDefinition——registerBeanDefinitions()
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
//实例化BeanDefinitonDocumentReader，用于解析XML中的Bean定义
BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();
//获取当前注册表中BeanDefinition的个数
int countBefore = this.getRegistry().getBeanDefinitionCount();
//解析并注册Bean定义
documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));
return this.getRegistry().getBeanDefinitionCount() - countBefore;
}
继续深入
protected void doRegisterBeanDefinitions(Element root) {
//解析 Bean 定义的委托类。它主要负责解析 XML 配置文件中 `<bean>` 元素和自定义的命名空间元素
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = this.createDelegate(this.getReaderContext(), root, parent);
if (this.delegate.isDefaultNamespace(root)) {
String profileSpec = root.getAttribute("profile");
//使用profile可以同时在配置文件中部署两套配置来适用于生产环境和开发环境这样可以方便的进行切换开发、部署环境，最常用的就是更换不同的数据库。
//了解了 profile 的使用再来分析代码会清得多，首先程序会获取 beans 节点是否定义了profile属性如果定义了则会需要到环境变量中去寻找，所以这里首先断言environment 不可能为空，因为 profle 是可以同时指定多个的，需要程序对其拆分，并解析每个 profile 是都合环境变量中所定义的，不定义则不会浪费性能去解析。
// 这块说的是根节点 <beans ... profile="dev" /> 中的 profile 是否是当前环境需要的，
// 如果当前环境配置的 profile 不包含此 profile，那就直接 return 了，不对此 <beans /> 解析
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;
}
}
}
//上面一段都是处理profile
//解析前处理 默认空方法
this.preProcessXml(root);
//解析
this.parseBeanDefinitions(root, this.delegate);
//解析后处理 默认空方法
this.postProcessXml(root);
this.delegate = parent;
}
parseBeanDefinitions()
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//节点一个一个处理，通过拿到根节点遍历处理每个子节点
//根节点就是把子节点包裹起来的最高级节点，比如<beans>，我们的<bean>是定义在<beans>中的
//子节点是什么?比如<bean/> 就是一个子节点。
//如果根节点是默认命名空间
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;
//对于根节点或者子节点如果是默认命名空间的话则采用 parseDefaultElement 方法进
行解析，否则使用delegate.parseCustomElement方法对自定义命名空间进行解析
//带http://www.springframework.org/schema/beans的即为默认命名空间
if (delegate.isDefaultNamespace(ele)) {
// 处理节点 我们这里以处理<bean>节点为例
this.parseDefaultElement(ele, delegate);
} else {
delegate.parseCustomElement(ele);
}
}
}
} else {
//根节点非命名空间，使用delegate.parseCustomElement方法对自定义命名空间进行解析
delegate.parseCustomElement(root);
}
}
- 先看看
<bean>节点长什么样子
可以看到，Bean信息基本都记录在节点中了
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//这个nodeName，就是上图的name，标识了节点标签名称
//处理import标签
if (delegate.nodeNameEquals(ele, "import")) {
this.importBeanDefinitionResource(ele);
//处理alias标签
} else if (delegate.nodeNameEquals(ele, "alias")) {
this.processAliasRegistration(ele);
//处理bean标签
//以上图为例，我们进入这里
} else if (delegate.nodeNameEquals(ele, "bean")) {
this.processBeanDefinition(ele, delegate);
//处理beans标签
} else if (delegate.nodeNameEquals(ele, "beans")) {
this.doRegisterBeanDefinitions(ele);
}
}
Bean标签的处理
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 将 <bean/> 节点中的信息提取出来，然后封装到一个 BeanDefinitionHolder 中，这个方法我们要看看
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 在必要时对 BeanDefinition 进行装饰，不懂 不重要
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//对解析后的bdHolder进行注册
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));
}
}
解析Bean属性
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
String id = ele.getAttribute("id");
String nameAttr = ele.getAttribute("name");
List<String> aliases = new ArrayList();
// 将 name 属性的定义按照 “逗号、分号、空格” 切分，形成一个 别名列表数组，
// 当然，如果你不定义 name 属性的话，就是空的了
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, ",; ");
aliases.addAll(Arrays.asList(nameArr));
}
String beanName = id;
// 如果没有指定id, 那么用别名列表的第一个名字作为beanName
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);
}
// 根据节点信息和BeanName创建 BeanDefinition。进里面看看
// 到这里，一个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.isTraceEnabled()) {
this.logger.trace("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;
}
}
(1)取元素中的id 以及name属性。
(2)进一步解析其他所有属性并统一封装至GenericBeanDefinition类型的实例中。
(3)如果检测到bean没有指定beanName，那么使用默认规则为此Bean生成beanName。
(4)将获取到的信息封装到BeanDefinitionHolder 的实例中。
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
//解析class属性
if (ele.hasAttribute("class")) {
className = ele.getAttribute("class").trim();
}
//解析parent属性
String parent = null;
if (ele.hasAttribute("parent")) {
parent = ele.getAttribute("parent");
}
try {
//创建beanDefinition容器
AbstractBeanDefinition bd = this.createBeanDefinition(className, parent);
//硬编码解析bean各种默认属性 这里解析的东西很多 例如lazy-init scope singleton
this.parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, "description"));
//解析元数据
this.parseMetaElements(ele, bd);
//解析lookup-method
this.parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析replace-method
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;
//解析了一堆东西 返回这个beanDefinition
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;
}
注册beanDefinition
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
//获取beanName
String beanName = definitionHolder.getBeanName();
//注册beanDefinition
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//获取bean的别名
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);
}
}
}
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 var8) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var8);
}
}
//所有的 Bean 注册后会放入这个 beanDefinitionMap 中
BeanDefinition existingDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
//如果bean定义存在，重名了
if (existingDefinition != null) {
//是否允许覆盖，不允许就抛异常
if (!this.isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
}
//各种方式的覆盖bean
if (existingDefinition.getRole() < beanDefinition.getRole()) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (!beanDefinition.equals(existingDefinition)) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
}
//覆盖
this.beanDefinitionMap.put(beanName, beanDefinition);
// 判断是否已经有其他的 Bean 开始初始化了.
// 注意，"注册Bean" 这个动作结束，Bean 依然还没有初始化，我们后面会有大篇幅说初始化过程，
// 在 Spring 容器启动的最后，会 预初始化 所有的 singleton beans
// 这里也会更新Bean定义并覆盖
} else {
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;
this.removeManualSingletonName(beanName);
}
} else {
//无意外出现的分支
// 将 BeanDefinition 放到这个 map 中，这个 map 保存了所有的 BeanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
// 这是个 ArrayList，所以会按照 bean 配置的顺序保存每一个注册的 Bean 的名字
this.beanDefinitionNames.add(beanName);
// 这是个 LinkedHashSet，代表的是手动注册的 singleton bean，
// 注意这里是 remove 方法，到这里的 Bean 当然不是手动注册的
// 手动指的是通过调用以下方法注册的 bean ：
// registerSingleton(String beanName, Object singletonObject)
// Spring 会在后面"手动"注册一些 Bean
// 如 "environment"、"systemProperties" 等 bean，我们自己也可以在运行时注册 Bean 到容器中的
this.removeManualSingletonName(beanName);
}
//在预初始化的时候会用到
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition == null && !this.containsSingleton(beanName)) {
if (this.isConfigurationFrozen()) {
this.clearByTypeCache();
}
} else {
this.resetBeanDefinition(beanName);
}
}
obtainFreshBeanFactory()结束，BeanDefinition注册完毕
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
// 启动步骤：spring.context.refresh
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// 准备刷新前的工作，设置容器状态标志，记录启动时间等
this.prepareRefresh();
// 获取一个新的 BeanFactory 实例，用于承载新的 Bean 定义和实例
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
// 对 BeanFactory 进行一些预备工作，设置类加载器、属性编辑器注册器等
this.prepareBeanFactory(beanFactory);
try {
// 启动步骤：spring.context.beans.post-process
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 对 BeanFactory 进行后处理，例如解析占位符等
this.postProcessBeanFactory(beanFactory);
// 调用 BeanFactoryPostProcessors 进行后处理，例如 @Configuration 类的处理
this.invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessors，用于处理 Bean 的生命周期回调
this.registerBeanPostProcessors(beanFactory);
// 结束 spring.context.beans.post-process 步骤
beanPostProcess.end();
// 初始化消息源，用于国际化
this.initMessageSource();
// 初始化应用程序事件广播器，用于发布事件
this.initApplicationEventMulticaster();
// 调用具体容器实现的 onRefresh 方法
this.onRefresh();
// 注册事件监听器
this.registerListeners();
// 完成 BeanFactory 的初始化，实例化和初始化所有非懒加载的单例Bean
this.finishBeanFactoryInitialization(beanFactory);
// 完成刷新，清理资源等
this.finishRefresh();
} catch (BeansException var10) {
// 捕获异常，如果出现异常，则取消刷新并销毁容器中的所有 Bean
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
}
this.destroyBeans();
this.cancelRefresh(var10);
throw var10;
} finally {
// 重置一些共用的缓存等
this.resetCommonCaches();
// 结束 spring.context.refresh 步骤
contextRefresh.end();
}
}
}
3、prepareBeanFactory() —— 手动注册特殊Bean
- 上文提及的特殊Bean在这里注册
// 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
prepareBeanFactory(beanFactory);
// 设置 BeanFactory 的类加载器
beanFactory.setBeanClassLoader(this.getClassLoader());
// 如果不忽略 SpEL（Spring Expression Language）处理，则设置 BeanFactory 的表达式解析器
if (!shouldIgnoreSpel) {
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
}
// 注册属性编辑器注册器，用于处理资源值
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
// 添加用于处理 ApplicationContextAware Bean 的 BeanPostProcessor
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 在自动装配时忽略特定的依赖接口
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
// 注册某些类型作为可解析的依赖关系
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 添加用于检测 ApplicationListener Bean 的 BeanPostProcessor
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 如果不处于本地镜像模式且容器中包含名为 "loadTimeWeaver" 的 Bean，则添加 LoadTimeWeaverAwareProcessor
if (!NativeDetector.inNativeImage() && beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 如果容器中尚未包含名为 "environment" 的 Bean，则注册它
if (!beanFactory.containsLocalBean("environment")) {
beanFactory.registerSingleton("environment", this.getEnvironment());
}
// 如果容器中尚未包含名为 "systemProperties" 的 Bean，则注册它
if (!beanFactory.containsLocalBean("systemProperties")) {
beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
}
// 如果容器中尚未包含名为 "systemEnvironment" 的 Bean，则注册它
if (!beanFactory.containsLocalBean("systemEnvironment")) {
beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
}
// 如果容器中尚未包含名为 "applicationStartup" 的 Bean，则注册它
if (!beanFactory.containsLocalBean("applicationStartup")) {
beanFactory.registerSingleton("applicationStartup", this.getApplicationStartup());
}
4、finishBeanFactoryInitialization()——完成BeanFactory初始化，实例化所有非懒加载单例Bean
/**
* 完成 BeanFactory 的初始化，包括以下步骤：
* 1. 如果 BeanFactory 包含名为 "conversionService" 的 Bean 且类型匹配 ConversionService，则设置为 ConversionService。
* 2. 如果 BeanFactory 中没有嵌入式值解析器，添加一个用于解析属性占位符的默认嵌入式值解析器。
* 3. 处理所有实现了 LoadTimeWeaverAware 接口的 Bean，确保这些 Bean 被实例化。
* 4. 设置临时类加载器为 null。
* 5. 冻结 BeanFactory 的配置，防止进一步的配置更改。
* 6. 预实例化所有的非懒加载单例 Bean。
*
* @param beanFactory 要完成初始化的 ConfigurableListableBeanFactory
*/
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 1. 如果 BeanFactory 包含名为 "conversionService" 的 Bean 且类型匹配 ConversionService，则设置为 ConversionService。
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService) beanFactory.getBean("conversionService", ConversionService.class));
}
// 2. 如果 BeanFactory 中没有嵌入式值解析器，添加一个用于解析属性占位符的默认嵌入式值解析器。
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
// 3. 处理所有实现了 LoadTimeWeaverAware 接口的 Bean，确保这些 Bean 被实例化。
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
this.getBean(weaverAwareName);
}
// 4. 设置临时类加载器为 null。
beanFactory.setTempClassLoader((ClassLoader) null);
// 5. 冻结 BeanFactory 的配置，防止进一步的配置更改。
beanFactory.freezeConfiguration();
// 6. 预实例化所有的非懒加载单例 Bean。 进入这里
beanFactory.preInstantiateSingletons();
}
preInstantiateSingletons();
public void preInstantiateSingletons() throws BeansException {
// 如果启用跟踪日志，记录正在预实例化单例对象的日志信息
if (this.logger.isTraceEnabled()) {
this.logger.trace("Pre-instantiating singletons in " + this);
}
// 获取所有的 BeanDefinition 名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
Iterator<String> iterator = beanNames.iterator();
while (true) {
String beanName;
Object bean;
// 迭代所有 BeanDefinition 名称
do {
// 如果没有下一个 BeanDefinition 名称，执行 SmartInitializingSingleton 回调并返回
if (!iterator.hasNext()) {
iterator = beanNames.iterator();
while (iterator.hasNext()) {
// 获取单例 Bean 实例
beanName = iterator.next();
Object singletonInstance = this.getSingleton(beanName);
// 如果单例实例实现了 SmartInitializingSingleton 接口，执行回调方法
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize").tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
// 使用特权访问方式执行 SmartInitializingSingleton 的回调方法
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, this.getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
return;
}
//正常先来到这里！！！！！！
beanName = iterator.next();
//从BeanDefinitionMap中根据BeanName获取合并后的本地 `BeanDefinition` ，
RootBeanDefinition bd = this.getMergedLocalBeanDefinition(beanName);
// 如果 BeanDefinition 是抽象的，或者不是单例的，或者是懒加载的，跳过，不实例化
} while (bd.isAbstract() || !bd.isSingleton() || bd.isLazyInit());
// 如果 Bean 是 FactoryBean，获取 FactoryBean 并继续迭代
if (this.isFactoryBean(beanName)) {
bean = this.getBean("&" + beanName);
} else {
// 正常的入口 getBean中真正初始化由我们注册的Bean
// 任何方式实例化Bean最终都会来到getBean() （似乎）
bean = this.getBean(beanName);
}
// 如果 Bean 是 SmartFactoryBean，并且是懒加载的
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
// 判断是否需要立即初始化，如果是 SmartFactoryBean，使用 SmartFactoryBean 提供的 isEagerInit 方法
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
SmartFactoryBean<?> smartFactoryBean = (SmartFactoryBean<?>) factory;
((SmartFactoryBean<?>) factory).getClass();
isEagerInit = AccessController.doPrivileged(smartFactoryBean::isEagerInit, this.getAccessControlContext());
} else {
// 如果不是 SmartFactoryBean，使用默认方式判断是否需要立即初始化
isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit();
}
// 如果需要立即初始化，调用 getBean 方法实际实例化 Bean
if (isEagerInit) {
this.getBean(beanName);
}
}
}
}
getBean()
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
// 获取一个 “正统的” beanName，处理两种情况，一个是前面说的 FactoryBean(前面带 ‘&’)，
// 一个是别名问题，因为这个方法是 getBean，获取 Bean 用的，你要是传一个别名进来，是完全可以的
String beanName = this.transformedBeanName(name);
// 检查下是不是已经创建过了
Object sharedInstance = this.getSingleton(beanName);
Object beanInstance;
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 下面这个方法：如果是普通 Bean 的话，直接返回 sharedInstance，
// 如果是 FactoryBean 的话，返回它创建的那个实例对象
beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
// 处理原型模式中的循环依赖检测
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 获取父BeanFactory
BeanFactory parentBeanFactory = this.getParentBeanFactory();
// 如果有父工厂，检查一下这个 BeanDefinition 在当前Factory的beanDefinitionMap
中是否存在
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
//如果当前不存在，看看父工厂有没有
if (parentBeanFactory instanceof AbstractBeanFactory) {
//返回父工厂的Bean
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
if (!typeCheckOnly) {
//标记 Bean 为已创建状态，将beanName放进一个标识已经创建的set集合中
this.markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
//获取合并后的beanDefinition，可以获取到父类定义的一些信息，合并成最终的定义
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
//处理 depends-on 属性
//被depends-on的bean优先初始化
String[] dependsOn = mbd.getDependsOn();
String[] prototypeInstance;
if (dependsOn != null) {
prototypeInstance = dependsOn;
int var13 = dependsOn.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dep = prototypeInstance[var14];
// 检查是不是循环依赖
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注册依赖关系
this.registerDependentBean(dep, beanName);
//初始化依赖bean
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var31) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31);
}
}
}
//根据bean不同作用域获取
if (mbd.isSingleton()) {
//单例bean，单例缓存中获取
sharedInstance = this.getSingleton(beanName, () -> {
try {
//创建bean实例，核心方法，一会追这里
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
//创建失败销毁bean
this.destroySingleton(beanName);
throw var5;
}
});
beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
//原型模式：创建原型实例
} else if (mbd.isPrototype()) {
prototypeInstance = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
//其他自定义作用域
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
}
Scope 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, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var30) {
throw new ScopeNotActiveException(beanName, scopeName, var30);
}
}
} catch (BeansException var32) {
//捕获异常信息
beanCreation.tag("exception", var32.getClass().toString());
beanCreation.tag("message", String.valueOf(var32.getMessage()));
this.cleanupAfterBeanCreationFailure(beanName);
throw var32;
} finally {
//结束性能追踪
beanCreation.end();
}
}
return this.adaptBeanInstance(name, beanInstance, requiredType);
}
createBean
/**
* 创建指定名称的 Bean 实例的核心方法。该方法包括了 Bean 创建的整个生命周期，从实例化到初始化。
*
* @param beanName Bean 的名称
* @param mbd Bean 的元数据定义
* @param args 传递给 Bean 构造函数的参数
* @return 创建完成的 Bean 实例
* @throws BeanCreationException 如果在 Bean 创建过程中发生异常
*/
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
// 确保 BeanDefinition 中的 Class 被加载
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 准备方法覆写 它来自于 bean 定义中的 <lookup-method />
try {
//准备方法重写
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
// 调用 BeanPostProcessor 的 beforeInstantiation 方法
try {
// 让 InstantiationAwareBeanPostProcessor 在这一步有机会返回代理，
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
// BeanPostProcessor 已经在 beforeInstantiation 中返回了实例，直接返回
return beanInstance;
}
} catch (Throwable var10) {
// 异常处理，抛出 BeanCreationException
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
//执行实际的 Bean 创建
try {
// 调用 doCreateBean 方法完成实际的 Bean 创建过程
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
//日志记录
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
// 返回创建的 Bean 实例
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
// 如果是特定的异常类型，直接抛出，否则抛出 BeanCreationException
throw var7;
} catch (Throwable var8) {
// 异常处理，抛出 BeanCreationException
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
doCreateBean
/**
* 执行实际的 Bean 创建过程，包括实例化、初始化等步骤。
*
* @param beanName Bean 的名称
* @param mbd Bean 的元数据定义
* @param args 传递给 Bean 构造函数的参数
* @return 创建完成的 Bean 实例
* @throws BeanCreationException 如果在 Bean 创建过程中发生异常
*/
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 返回值就是被删除的旧值，如果无旧值则为null
// 返回值为NULL说明不是factoryBean
instanceWrapper = (BeanWrapper) this.factoryBeanInstanceCache.remove(beanName);
}
// 如果返回到的是Null，说明不是FactoryBean
// 调用createBeanInstance()创建Bean实例
// 先下去看这个方法
if (instanceWrapper == null) {
// 根据执行bean使用对应的策略创建新的实例，如，工厂方法，构造函数主动注入、简单初始化
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
// 获取创建的 Bean 实例和类型信息
//instanceWrapper.getWrappedInstance()`：获取包装的 Bean 实例。这是通过
//`BeanWrapper` 封装的，它提供了对 Bean 实例的访问。
Object bean = instanceWrapper.getWrappedInstance();
//`instanceWrapper.getWrappedClass()`：获取 Bean 实例的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
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;
}
}
// 处理早期曝露的单例 Bean，用于解决循环依赖下的Bean引用，暂时不看
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, () -> this.getEarlyBeanReference(beanName, mbd, bean));
}
// 初始化 Bean 实例
Object exposedObject = bean;
try {
// 这一步也是非常关键的，这一步负责属性装配，
// 因为前面的实例只是实例化了，并没有属性填充
this.populateBean(beanName, mbd, instanceWrapper);
// 这里就是处理 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);
}
// 步骤6: 处理早期曝露的单例 Bean
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 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 步骤7: 注册可销毁的 Bean
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 解析bean的类类型
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
// 检查类是否为public且允许访问
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean类不是public，并且不允许非public访问: " + beanClass.getName());
}
// 采用工厂方法实例化
// 如果没有指定，通常情况下instanceSupplier为NULL。所以关心else逻辑即可
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName);
} else if (mbd.getFactoryMethodName() != null) {
//factory-method 用于指定创建 bean 实例的静态工厂方法。
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
boolean resolved = false;
boolean autowireNecessary = false;
// 这块部分是有参构造的逻辑
// 检查构造函数和参数是否已解析
// 如果不是第一次创建，比如第二次创建 prototype bean，这种情况下，我们可以从第一次创建知道，采用无参构造函数，还是构造函数依赖注入 来完成实例化
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 {
// 如果未解析，则从BeanPostProcessors中确定构造函数并相应地进行自动装配
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
//AUTOWIRE_CONSTRUCTOR —— 按照构造函数自动装配
if (ctors == null && mbd.getResolvedAutowireMode() != AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR &&
!mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
ctors = mbd.getPreferredConstructors();
//不满足这些条件，调用instantiateBean(beanName, mbd)进入无参构造
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[]) null) :
this.instantiateBean(beanName, mbd);
} else {
return this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
Bean无参构造
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(() -> {
return this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}, this.getAccessControlContext());
} else {
// 获取实例化策略并且进行实例化操作
beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
}
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
this.initBeanWrapper(bw);
return bw;
} catch (Throwable var5) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var5);
}
}
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
if (!bd.hasMethodOverrides()) {
Constructor constructorToUse;
synchronized(bd.constructorArgumentLock) {
constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
if (constructorToUse == null) {
// 得到当前bean的Class
Class<?> clazz = bd.getBeanClass();
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
if (System.getSecurityManager() != null) {
clazz.getClass();
constructorToUse = (Constructor)AccessController.doPrivileged(() -> {
return clazz.getDeclaredConstructor();
});
} else {
// 通过class得到其默认的构造方法
constructorToUse = clazz.getDeclaredConstructor();
}
//赋值
bd.resolvedConstructorOrFactoryMethod = constructorToUse;
} catch (Throwable var9) {
throw new BeanInstantiationException(clazz, "No default constructor found", var9);
}
}
}
// 准备通过构造方法对象newInstance
return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
} else {
return this.instantiateWithMethodInjection(bd, beanName, owner);
}
}
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
//省略
//最后也是终于创建出实例了,但还有一些事没做
return ctor.newInstance(argsWithDefaultValues);
}
属性填充
示例
<bean id="a01" class="org.example.springg.BeanLIfe.a01">
<property name="name" value="John Doe" />
<!-- 注入 age 属性 -->
<property name="age" value="30" />
</bean>
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//只看关键步骤吧
// 得到当前 BeanDefinition 的属性值
PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
if (pvs != null) {
// 注入属性
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
// 只看核心逻辑
if (!pvs.isEmpty()) {
while(true) {
while(var11.hasNext()) {
PropertyValue pv = (PropertyValue)var11.next();
if (pv.isConverted()) {
deepCopy.add(pv);
} else {
//获取属性名
String propertyName = pv.getName();
//获取属性值
Object originalValue = pv.getValue();
}
}
try {
//最后通过反射设置值
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
return;
}
}
}
}
初始化逻辑、前后置处理器
public Object postProcessBeforeInitialization(Object bean, String beanName) {
System.out.println("before");
return bean;
}
public Object postProcessAfterInitialization(Object bean, String beanName) {
System.out.println("after");
return bean;
}
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessBeforeInitialization初始化方法。
// 返回的Bean实例可能是原始Bean包装器
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//调用初始化方法，先调用bean的InitializingBean接口方法，后调用bean的自定义初始化方法
//也就是init-mothod
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()) {
// 将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessAfterInitialization方法。
// 返回的Bean实例可能是原始Bean包装器
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
if (mbd != null && bean.getClass() != NullBean.class) {
//获取init方法
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
//调用自定义的init方法，通过反射调用
this.invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
