今天解读spring最重要的方法之一 finishBeanFactoryInitialization(beanFactory);
此方法用来初始化、实例化用户在系统中定义的单例bean,具体有哪些bean会被初始化跟实例化可以在refresh 方法的第五步 invokeBeanFactoryPostProcessors(beanFactory); 这个方法执行完成后查看BeanFactory中的BeanDefinitionMap集合中的数据，BeanDefinitionMap集合中的数据就是即将被初始化跟实例化的bean，当然也可能在之前的步骤中已经被初始化了，那这里就会被忽略。。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
// 给spring的bean增加一些处理特殊数据类型的 Conversion
// 比如说 前端页面传递一个 浙江省_杭州市_下城区 服务端用省市区三个字段的 address实体类来接受
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 BeanFactoryPostProcessor
// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
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.
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
// 实例化用户定义的在之前环节还未被实例化的单例bean的接口方法
// 实现类为 DefaultListableBeanFactory 中的 preInstantiateSingletons 方法
beanFactory.preInstantiateSingletons();
}这里是给要被初始化或实例化的bean增加一些额外的配置比如可以能要进行时间解析、字符串解析等相关处理
beanFactory.preInstantiateSingletons(); -> ConfigurableListableBeanFactory ->
void preInstantiateSingletons() throws BeansException; ->
DefaultListableBeanFactory -> preInstantiateSingletons() throws BeansException
@Override
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.
// 获取在之前loadBeanDefinition阶段、BeanDefinitionRegistryPostProcessor、阶段扫描到的所有BeanDefinitionNames集合
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
//遍历 beanNames 集合挨个创建对应的单例bean
for (String beanName : beanNames) {
//根据beanName 到 beanFactory 中获取对应的BenDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//根据beanDefinition中的信息判断此还没被创建的bean是是抽象、是单例、是否是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断此bean是否是FactoryBean的实现类
// 如果是factoryBean的实现类
// 则 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); 会创建此factoryBean 的实现类
// 之后如果用户有获取此factoryBean创建的实际bean对象时，才会调用factoryBean 的getObject方法创建实际的bean
/**
* 1、这里容器在创建时会创建 PersonFactoryBean 这个对象并放到 singletonObjects单例一级缓存中
* ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("FactoryBean.xml");
*
* 2、这里用户在获取 personFactoryBean 这个对象时会调用 PersonFactoryBean 的getObject对象创建 Person对象
* 并将person对象放到factoryBeanObjectCache中
* Person person = applicationContext.getBean("personFactoryBean", Person.class);
* */
if (isFactoryBean(beanName)) {
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) {
//调用 AbstractBeanFactory 中的 getBean创建 bean
getBean(beanName);
}
}
}
else {
//调用 AbstractBeanFactory 中的 getBean创建 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();
}
}
}
}之后经过一系列的调用 getBean -> doGetBean -> createBean -> doCreateBean
首先是doGetBean
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
//这里可能需要处理下bean的名字比如此bean实现了FactoryBean接口那么他的名字就会加上 & 这个符号
//如果此bean指定了别名那就返回此bean的别名
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 在创建bean之前先从三级缓存 (DefaultSingletonRegistry) 中获取一下，看看是否在之前的某个环节已经提前创建好了这个bean
// 此处的环节大概在BeanFactoryPostProcessor的实现类 或 BeanDefinitionRegistryPostProcessor的实现类中
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
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) {
markBeanAsCreated(beanName);
}
try {
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 这里会判断当前bean是否有需要依赖的bean
// 如果有则先创建依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
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.
// 是否是单例bean
if (mbd.isSingleton()) {
//创建单例bean
sharedInstance = getSingleton(beanName, () -> {
try {
// 调用 AbstractAutoWireCapableBeanFactory createBean 创建bean
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是FactoryBean的实现类则调用FactoryBean的getObject方法获取具体的bean
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//是否是原型bean
else if (mbd.isPrototype()) {
// 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 {
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;
}createBean
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 这里看上面的翻译是说给 BeanPostProcessors 一个机会来返回一个代理对象对于目标对象
// 其实这里面做了很多事情，并且容易让人误解
// 首先这里返回的不是spring 的代理对象而是由用户实现的某个类的对象可以是new出来的，也可以是经过代理实现的
// 其次如果系统有aop的相关配置，这里会实例化aop的相关配置类，但是不会返回具体对象的代理对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
//先准备一个实例bean的包装类,然后在下面的步骤中实例化一个bean并设置到包装类中
//
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
//这里首先实例化一个bean，实例化的方法有很多种
/**
* 1、Supplier 的方式 - 属于用户自定义方式
* 2、factoryMethod 的方式 - 属于用户自定义方式(其中在@Configucationz注解、 @Component注解 类中定义的 @bean注解类就是走的这种方式)
* 3、在某个注解类中通过在构造函数上加 @Autowire 注解的方式注入其他bean 这种用法较少
* 4、通过反射调用类的构造方法进行实例化 - 如果用户没有进行上面三种方式的设置，那默认就会用第四种反射调用构造方法进行实例化
* 这里的反射调用类的构造方法也有两种分类、一种是普通类调用构造方法实例化，一种是代理类调用构造方法实例化
* 普通类调用构造方法实例化后，就完成了。但是代理类最终返回的是代理对象，但这里有两种方式
*
* 一种方式是在生成类的Class时就直接生成代理类的Class比如使用@Configuration 注解的类在前面 BeanFactoryPostProcessor
* 的实现类@ConfigurationClassPostProcessor 的beanFactoryPostProcessor 方法执行时直接返回的就是代理类的Class，
* 然后调用代理类的构造方法生成代理对象
*
* 另一种方式是先生成普通对象然后在BeanPostProcessor 的实现类 AspectJAwareAdvisorAutoProxyCreator(当在配置文件中配置了aop tx事务、等等
* 需要生成代理对象时， spring 框架会帮我们自动注入 AspectJAwareAdvisorAutoProxyCreator 这个类,具体怎么注入的 可以看下 AopNamespaceHandler
* 这个类里面的AspectJAutoProxyBeanDefinitionParser 这个类, 具体的加载关系在之前的章节已经聊过了就不说了) 的 getEarlyBeanReference 方法中
* 判断当前类是否要进行代理生成，如果要被代理生成则调用 jdk的 proxy或者 cglib的 Enhancer 进行代理类的生成，并替换之前生成的普通类
* 这里有可能有同学在 AspectJAwareAdvisorAutoProxyCreator 里面找不到 getEarlyBeanReference 这个方法， 在 AbstractAutoProxyCreator里面
* */
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
/**
* 这里会对注解的bean中的相关属性注解(@AutoWire、@value、@Resource、@PostConstruct、@PreDestroy)进行解析(只是解析，并不会实际注入)
* 实际的属性注入要到 InstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor
* DestructionAwareBeanPostProcessor 等 BeanPostProcessor 的子接口的 相关方法被调用时才会被注入
*
* @AutoWire、@value 会被 CommonAnnotationBeanPostProcessor 的 postProcessMergedBeanDefinition 这个方法解析到
* @Resource 会被 CommonAnnotationBeanPostProcessor 的 postProcessMergedBeanDefinition 这个方法解析到
* @PostConstruct、@PreDestroy 会被 InitDestroyAnnotationBeanPostProcessor 的 postProcessMergedBeanDefinition 这个方法解析到
*
* */
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.
/**
* 这里是处理循环引用的关键,spring会将只经过实例化但是未经过初始化的对象统一都放入三级缓存的第三级缓存中
* DefaultSingletonBeanRegistry -> Map<String, ObjectFactory<?>> singletonFactories
* 可以看到 singletonFactories是一个map结构，里面的key是 bean的名称 value是 ObjectFactory
* 实际注入的 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
* key是bean的名称value是 lambda表达式 () -> getEarlyBeanReference(beanName, mbd, bean)
* 后面在它被依赖引用的时候可以根据是否需要注入代理对象决定是返回原始对象还是调用 getEarlyBeanReference 返回代理对象
* */
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
/**
* 给刚刚实例化之后的对象的属性进行初始化
* 这里的初始化主要是给对象属性赋值
* 包括基本属性、引用属性等,实际上很复杂包括基本数据类型的赋值，集合类型的赋值、配置文件类型的属性赋值
* */
populateBean(beanName, mbd, instanceWrapper);
/**
* 给刚刚实例化并给属性赋值之后的对象在进行一些初始化
* 这里的初始化主要是指调用相关的初始化方法
* 包括对 Aware 的实现类 BeanNameAware、BeanClassLoaderAware、BeanFactoryAware这三个接口的方法调用
* 包括对 InitDestroyAnnotationBeanPostProcessor @PostConstruct 注解的方法的调用
* 包括对 InitializingBean 的 afterPropertiesSet 方法的调用
* 包括对BeanPostProcessor的 相关子接口的 postProcessBeforeInitialization、postProcessAfterInitialization 的方法的调用
* */
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;
}这里只是理出了大概的主线实际上这里的 createBeanInstance、
applyMergedBeanDefinitionPostProcessors、
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
populateBean、initializeBean、registerDisposableBeanIfNecessary 等方法中都是有更深层次的业务逻辑处理流程需要慢慢去整理的
213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
