您现在的位置是:首页 > 正文

spring加载流程refresh之finishBeanFactoryInitialization(beanFactory)

2024-04-01 02:48:27阅读 1


注释: 到了spring加载流程最复杂的一步,开始实例化所有的bd

AbstractApplicationContext.finishBeanFactoryInitialization()

// 实例化所有的bd
this.finishBeanFactoryInitialization(beanFactory);
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 判断是否有bdName为conversionService的bd(实现ConversionService接口),有的话注册为格式转换器服务类
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }
    // 获取LoadTimeWeaverAware类型的bd,提前实例化
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;
    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader((ClassLoader)null);
    // 冻结上下文,不允许再进行修改配置
    beanFactory.freezeConfiguration();
    // 实例化预处理
    beanFactory.preInstantiateSingletons();
}

判断是否有bdName为conversionService的bd(实现ConversionService接口)

这里是结合spring MVC使用的,类似页面传递String类型的时间格式到后台可以格式化为Date类型
容器初始化完成后,默认是没有格式转换器的
在这里插入图片描述
spring内部有个DefaultConversionService,但是没有注册进容器,所以spring找不到。
可以通过配置注入容器,然后spring在这一步就会找到DefaultConversionService并注册到conversionService
DefaultConversionService会注册很多spring自带的格式转换器,包括时间,集合等

@Bean
public ConversionService conversionService(){
    DefaultConversionService ConversionService = new DefaultConversionService();
    return ConversionService;
}

在这里插入图片描述

判断是否有LoadTimeWeaverAware类型的bd

这里会提前实例化LoadTimeWeaverAware类型的bd,this.getBean(bdName)方法会进行实例化bd,后面具体分析

DefaultListableBeanFactory.preInstantiateSingletons()预处理

this.beanDefinitionNames就是之前注册bd的时候添加的bdName集合

List<String> beanNames = new ArrayList(this.beanDefinitionNames);
Iterator var2 = beanNames.iterator();

跳过抽象、原型、懒加载的bd

懒加载与原型的bd,不实例化进ioc容器,在调用的时候才会去实例化

String beanName;
RootBeanDefinition bd;
do {
    do {
        do {
              .
              .
              .
            beanName = (String)var2.next();
            // 获取bd
            bd = this.getMergedLocalBeanDefinition(beanName);
        } while(bd.isAbstract());// 如果是抽象的则继续循环
    } while(!bd.isSingleton());// 如果不是单例则继续循环
} while(bd.isLazyInit());// 如果是懒加载的则继续循环

判断是否是FactoryBean

if (this.isFactoryBean(beanName)) {
    // 如果是FactoryBean
    FactoryBean<?> factory = (FactoryBean)this.getBean("&" + beanName);
    boolean isEagerInit;
    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
        isEagerInit = ((Boolean)AccessController.doPrivileged(() -> {
            return ((SmartFactoryBean)factory).isEagerInit();
        }, this.getAccessControlContext())).booleanValue();
    } else {
        isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
    }

    if (isEagerInit) {
        this.getBean(beanName);
    }
} else {
    this.getBean(beanName);
}

实现FactoryBean接口的bd是spring中一种特殊的bean,获取该bd其实是getObject()返回的内容,但是可以通过"&" + beanName获取到该bd本身。

AbstractApplicationContext.getBean(bdName)

public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}

跳到doGetBean

处理bdName去掉&

这里有可能传进来的是个FactoryBean,所以需要处理下bdName

String beanName = this.transformedBeanName(name);

做个记录,标识bd正在实例化

if (!typeCheckOnly) {
   this.markBeanAsCreated(beanName);
}

判断bd是否有@DependsOn

@DependsOn控制bean的加载顺序

// 根据bdName获取bd
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
// 判断是否存在@DependsOn
String[] dependsOn = mbd.getDependsOn();
String[] var11;
if (dependsOn != null) {
    var11 = dependsOn;
    int var12 = dependsOn.length;
    for(int var13 = 0; var13 < var12; ++var13) {
        String dep = var11[var13];
        if (this.isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }

        this.registerDependentBean(dep, beanName);
        // 先实例化@DependsOn中的bd
        this.getBean(dep);
    }
}

判断bd的作用域分别进行实例化

有人说前面不是判断跳过了原型的bd吗,这里为什么还要判断是单例还是原型?因为前面是获取容器中所有的bd进行实例化做的判断,如果单单只是调用某一个bdgetBean(bdName)的话,比如

EmailService service = context.getBean("emailService ");

也是需要先判断一下作用域,然后进行实例化

if (mbd.isSingleton()) {
    sharedInstance = this.getSingleton(beanName, () -> {
        try {
            return this.createBean(beanName, mbd, args);
        } catch (BeansException var5) {
            this.destroySingleton(beanName);
            throw var5;
        }
    });
    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
    var11 = null;

    Object prototypeInstance;
    try {
        this.beforePrototypeCreation(beanName);
        prototypeInstance = this.createBean(beanName, mbd, args);
    } finally {
        this.afterPrototypeCreation(beanName);
    }

    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

AbstractAutowireCapableBeanFactory.createBean

实现自动注入功能的工厂

通过BeanPostProcessor实例化bd

这里可以通过BeanPostProcessor实例化bd,不需要进行后面的流程,记住有这么个东西,一般没用。。。

beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
if (beanInstance != null) {
    return beanInstance;
}
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = this.determineTargetType(beanName, mbd);
            if (targetType != null) {
                bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }

        mbd.beforeInstantiationResolved = bean != null;
    }

    return bean;
}

doCreateBean

判断是否有缓存,没有则创建bean实例

BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
    // 注意factoryBeanInstanceCache是ConcurrentMap,remove方法会返回删除的键值(如果不存在返回null)
    instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
    // 如果factoryBeanInstanceCache没有缓存对应的BeanWrapper,则重新创建bean实例
    instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
确定构造函数然后实例化

createBeanInstance方法内部

// 确定bd的构造函数
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
return ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args) ? this.instantiateBean(beanName, mbd) : this.autowireConstructor(beanName, mbd, ctors, args);

如果为空(没有带参构造函数),则this.instantiateBean(beanName, mbd),否则this.autowireConstructor(beanName, mbd, ctors, args);,这里先不具体分析怎么实例化bd

MergedBeanDefinitionPostProcessor后处理器修改已合并的bean定义

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放入singletonFactories,这里是个面试点,会单独出一篇文章详解

// 提前缓存ObjectFactory以解决bean之间的循环依赖
// mbd.isSingleton()->是否单例
// allowCircularReferences->是否允许循环依赖
// isSingletonCurrentlyInCreation->该bean是否创建中
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
    }

    this.addSingletonFactory(beanName, () -> {
        return this.getEarlyBeanReference(beanName, mbd, bean);
    });
}

填充bean属性populateBean

会单独出一篇文章详解

this.populateBean(beanName, mbd, instanceWrapper);

bean的初始化initializeBean

会单独出一篇文章详解

 exposedObject = this.initializeBean(beanName, exposedObject, mbd);
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 {
        // 完成几个特殊*Aware接口的setter方法的注入
        this.invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 执行bpp初始化之前执行的方法
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    }

    try {
        // 执行初始化方法(如果该bean实现了InitializingBean方法)
        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()) {
        // 执行bpp初始化之后执行的方法(aop增强就是在这里完成的)
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

网站文章

  • nginx的配置、虚拟主机、负载均衡和反向代理--03

    第3篇主要讲 URL路由重写 和 读写分离nginx中的 location 正则模块nginx中的URL重写怎么做。url重写模块,主要是在location模块面来实现,我们一点一点的看。首先看下location 正则匹配的使用。还记得之前是如何用location来定位.php文件的吗?location ~ \.php$ { fastcgi_pass 127.0.0.1:9000

    2024-04-01 02:48:18
  • SQL_数据库基础之级联删除和级联更新

    SQL_数据库基础之级联删除和级联更新

    原文: 级联删除 删除包含主键值的行的操作,该值由其它表的现有行中的外键列引用。在级联删除中,还删除其外键值引用删除的主键值的所有行。 语法: FOREIGN KEY(COLUMN[,...n]) REFERENCES referenced_table_name[(ref_column[,...n])] [ON DELETE cascade] [ON UPDATE cascad

    2024-04-01 02:48:11
  • 博客-地图

    本页面用来博客文章整理。在未来一段时间的计划中,本文将是唯一的置顶文章,以方便查看博客的所有内容。本博客所有内容都是与视觉SLAM相关的内容,希望本博客可以对读者您有所帮助,如有改进意见,欢迎评论区留言批评指正!由于本人的个人博客网站暂时不维护了,所以将博客内的一些文章重新搬过来。

    2024-04-01 02:47:27
  • go语言中slice的容量和内存地址

    slice是引用这个我就不说了,不会有人不知道吧?对于slice的赋值语句,如果没有指定容量,那么容量会与赋值等式的右值一致。var arr = []int{0,1,2}nrr := arr[:1] ...

    2024-04-01 02:47:20
  • Linux内存管理 - PAGE_OFFSET理解

    Linux内存管理 - PAGE_OFFSET理解     PAGE_OFFSET 代表的是内核空间和用户空间对虚拟地址空间的划分,对不同的体系结构不同。比如在32位系统中3G-4G 属于内核使用的内存空间,所以 PAGE_OFFSET = 0xC0000000。在X86-64架构下是ffff880000000000。可以看到内核程序可以可以访问从PAGE_OFFSET 之

    2024-04-01 02:47:13
  • 达梦8全量备份和增量备份备份策略

    达梦8全量备份和增量备份备份策略

    使用SYSDBA登录数据库manager工具,输入以下SQL语句,并执行。

    2024-04-01 02:46:32
  • 软件测试员200题(练习)

    所谓的“录制-回放”,就是先使用自动化工具由手工完成一遍需要测试的流程,同时由计算机记录下这个流程期间操作,并形成特定的( )。① 测试用例 ② 测试人员的分配 ③ 测试的度量标准 ④ 测试工具的选用...

    2024-04-01 02:46:24
  • 项目启动报java.lang.IllegalAccessError: tried to access method 热门推荐

    项目启动报java.lang.IllegalAccessError: tried to access method 热门推荐

    最近在对接京东代扣相关的业务,拿到京东的Demo,可以很快地把整套的流程跑下来,但当把Demo集成到项目中时,只要启动项目就不停地报错,错误信息如下:2017-10-13 19:34:18 ERROR _500_jsp _jspService - Handler processing failed; nested exception is java.lang.IllegalAccessError:

    2024-04-01 02:46:16
  • Tor

    Tor

    先打开这个网站 https://bridges.torproject.org/ Step #1:下载Tor浏览器 Step #2:获取bridges Step #3:在Tor浏览器上添加网桥 Step #4:调出项目结构管理区域 把网桥全部复制进去 在点击连接 注:连接第一次的时候比较慢 -End- 暗网搜索引擎 http://www.onion.l

    2024-04-01 02:45:37
  • CPU缓存那些事儿

    CPU缓存那些事儿

    CPU高速缓存集成于CPU的内部,其是CPU可以高效运行的成分之一,本文围绕下面三个话题来讲解CPU缓存的作用:为什么需要高速缓存?高速缓存的内部结构是怎样的?如何利用好cache,优化代码执行效率?...

    2024-04-01 02:45:29