栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring生命周期笔记版-01

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring生命周期笔记版-01

1 环境搭建

虽然是研究Spring的生命周期,我们仍然可以使用springboot项目来研究
POM依赖



    4.0.0

    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.6.RELEASE
         
    

    com.itmark
    mongoDemo
    1.0-SNAPSHOT

    
        11
        11
    
    
        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
            org.projectlombok
            lombok
            true
        
    


一个实体类

package com.itmark.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.io.Serializable;


@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class SGRole implements Serializable {
    String id;
    String name;
    Integer age;
}

一个bean的配置文件,需要放在resources目录下





    
        
        
        
    


引入这个配置

@Configuration
@ImportResource(locations = "classpath:beans.xml")
public class RoleConfiguration {

}
}

在IOC容器中获取这个对象

@Slf4j
@SpringBootTest(classes = AppMongo.class)
@RunWith(SpringRunner.class)
public class SpringBeanTest {

    @Test
    public void getMongoData() {
        // 1.当作是一个IOC容器即可
        AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(RoleConfiguration.class);
        // 2.getBean
        SGRole sgRole2 = (SGRole) annotationConfigApplicationContext.getBean("sgRole2");
        System.out.println(sgRole2);
    }

}
2 DEBUG



目标是找到哪一个代码可以找到我们想要的对象实例。

发现debug到这行代码时候返回了对象

此时找到了容器IOC


下图分别为一级缓存三级缓存和二级缓存

既然可以从缓存中拿到对象,而且缓存就是Map集合所以如果能取到,那么spring一定在某个时刻put进去了我们的实例对象。如下。

通过断点表达式找到了什么时候put进去了。

但是是谁调用了put方法所在的方法呢?发现是IOC容器启动的过程中将所有的对象初始化好放到单例缓存池中。

注意:如果使用的是springboot的单元测试,你很难找到到底是谁最终调用了put方法,但是当你把代码放到一个main方法的时候,你很容易可以看到是IOC容器调用了PUT。

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
		synchronized (this.singletonObjects) {
		// 1 尝试从IOC一级缓存中拿对象
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				// 1.1 用于标记一个bean将要被创建防止其他线程重复创建
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
				// 2 初始化一个bean,而这个方法的调用者是一个lambda表达式
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
			
			return singletonObject;
		}
	}

当方法调用singletonObject = singletonFactory.getObject();时候lambda表达式会被调用。

现在研究一下 createBean 这个方法,最终调用了doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (instanceWrapper == null) {
		    // 0 创建这个bean的空对象
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final 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.
		// 1 spring是如何解决循环依赖的
		// 1.2 mbd.isSingleton()判断是否单例
		// 1.3 this.allowCircularReferences是否允许循环依赖
		// 1.4 isSingletonCurrentlyInCreation(beanName) 判断正在创建集合中是否包含现在的名称
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
		    // 2 包早起对象放到三级缓存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			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 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 " +
								"'getBeanNamesOfType' 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;
	}
3 核心调用堆栈总结
  • 重点方法一:org.springframework.beans.factory.support.AbstractBeanFactory#getBean

  • 重点方法二: org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

    • 别名解析org.springframework.beans.factory.support.AbstractBeanFactory#transformedBeanName
    • 获取当前bean定义org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition
    • 判断是否为抽象类org.springframework.beans.factory.support.AbstractBeanFactory#checkMergedBeanDefinition
    • 检测dependsOn属性org.springframework.beans.factory.support.AbstractBeanDefinition#getDependsOn
  • 重点方法三:返回对象org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton

    • org.springframework.beans.factory.support.AbstractBeanFactory#createBean
    • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
    • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance 通过反射创建空壳对象
    • org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingletonFactory 暴露早起对象(上一步创建的空壳对象,还没有进行属性赋值)暴露就是加入到三级缓存中(this.singletonFactories.put(beanName, singletonFactory);)
    • org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean给当前创建的空壳对象A注入属性B(通过注入早期对象来解决循环依赖的问题)(底层调用了getBean的方法来再次走一遍上面的流程把B的实例创建出来,那么三级缓存中也有B了,再给B的循环依赖属性进行赋值的时候,此时三级缓存中已经有A的早期对象实例了)处理完毕B的循环依赖A后,进行B的实例后续处理,把完整的实例返回给当前方法处理A的循环依赖B的问题
    • org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#getEarlyBeanReference三级缓存用于保证实例获取的是代理对象,可以进行一些增强,三级缓存在getBean的时候会触发当前方法
  • 所有对象在创建的过程中都会把自己的对象暴露到三级缓存中,从三级缓存到二级缓存中会记过一次代理,创建完毕后就会删除二级缓存放到一级缓存中。所已使用构造函数方法来注入循环依赖无法实现,因为空壳对象三级缓存中没有。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/950746.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号