2.2 spring5源码系列 -- ioc加载的整体流程

概述之前我们知道了spring ioc的加载过程, 具体如下图. 下面我们就来对照下图, 看看ioc加载的源代码. 下面在用装修类比, 看看个个组件都是怎么工作的. 接下来是源码分析的整体结构图. 对照上

之前我们知道了spring ioc的加载过程,具体如下图. 下面我们就来对照下图,看看ioc加载的源代码.

 下面在用装修类比,看看个个组件都是怎么工作的.

 

接下来是源码分析的整体结构图. 对照上面的思路梳理出来的

 

一、源码分析的入口 

通常,我们的入口都是从main方法进入. 这里我们也来定义一个main方法

public class MainStarter {    public static voID main(String[] args) {        // 第一步: 通过AnnotationConfigApplicationContext读取一个配置类        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainStarter.class);        context.scan("package name");        Car car = (Car) context.getBean("car");        System.out.println(car.getname());        context.close();    }}

 

顺便再来看看还有哪些相关的类

/** * 这是一个配置类,* 在配置类里面定义了扫描的包路径com.lxl.www.iocbeanlifecicle * 这是会将这个包下配置了注解的类扫描到ioc容器里面,成为一个成熟的bean */@Configuration@ComponentScan(basePackages = {"com.lxl.www.iocbeanlifecicle"})public class MainConfig {}

这个类有一个注解@Configuration,这样这个类会被扫描成bean

还有一个注解@ComponentScan(backPackage = {"com.lxl.www.iocbeanlifecicle"}) 他表示,请扫描com.lxl.www.iocbeanlifecicle包下所有的类.

com.lxl.www.iocbeanlifecicle 这个包下还有哪些类呢? 我们来看看项目结构

 

 

 这是这个包下完整的项目结构. 

下面会逐渐说明,每个类的用途

 

二. 最重要的类beanfactory

我们知道在将一个class加载为bean的过程中beanfactory是最最重要的,那么他是何时被加载的呢?

我们来跟踪一下带有一个参数的构造方法AnnotationConfigApplicationContext

    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {        // 进入构造函数,首先调用自身的构造方法this();        // 调用自身的构造方法之前,要先调用父类的构造方法        this();        // retister配置注册类        register(componentClasses);        // ioc容器shua新接口--非常重要        refresh();    }

这就是AnnotationConfigApplicationContext初始化的时候做的三件事

第一件事:  this();  //调用自身的无参构造方法. 同时调用父类的构造方法

第二件事: register(componentClasses); // 调用注册器,这里会加载两个BeanDeFinitionReader和BeanDeFinitionScanner. 这两位的角色是什么呢? 可以回忆一下之前的框架图

第三件事: refresh();  // 这是ioc容器刷新,非常重要. 无论是spring boot还是spring mvc都有这个方法. 这个方法包含了整个spring ioc加载的全生命流程. 也是我们要重点学习的方法

 

下面来看看beanfactory是何时被加载进来的呢?

在初始化方法的时候调用了自身的无参构造函数,在调用自身无参构造函数的时候,同时会调用父类的无参构造函数. 

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
　　......
} 

父类是GenericApplicationContext,其无参构造函数就做了一件事

   public GenericApplicationContext() {        // 构造了一个beanfactory.        // 在调用GenericApplicationContext父类构造函数,为ApplicationContext spring上下文对象初始化beanfactory        // 为什么初始化的是Defaultlistablebeanfactory呢?        // 我们在看beanfactory接口的时候发现Defaultlistablebeanfactory是最底层的实现,功能是最全的.        // 查看        this.beanfactory = new Defaultlistablebeanfactory();    }    

初始化Defaultlistablebeanfactory. 

问题: beanfactory有很多,为什么初始化的时候选择Defaultlistablebeanfactory呢?

我们来看看Defaultlistablebeanfactory的结构. 快捷键option + command + u --> Java Class Diagrams

 

 

 通过观察,我们发现, Defaultlistablebeanfactory实现了各种各样的beanfactory接口,同时还是先了BeanDeFinitionRegistry接口. 

也就是说, Defaultlistablebeanfactory不仅仅有beanfactory的能力,同时还有BeanDeFinitionRegistry的能力. 它的功能是最全的.

所以,我们使用的是一个功能非常强大的类Bean工厂类. 

 

AnnotationConfigApplicationContext继承了GenericApplicationContext,而 GenericApplicationContext 实现了AnnotationConfigRegistry接口.所以AnnotationConfigApplicationContext有AnnotationConfigRegistry的能力.

 

三. bean定义读取器AnnotatedBeanDeFinitionReader

接着上面,第一步调用的是this(). 也就是AnnotationConfigApplicationContext的无参构造函数. 在这个无参构造函数里一共做了两件事情

    public AnnotationConfigApplicationContext() {        /**         * 创建了一个Bean定义的读取器.         * 完成了spring内部BeanDeFinition的注册(主要是后置处理器)         * 读取了很多spring自定义的配置(主要是后置处理器). 这些类都是spring 的原始类.         */        this.reader = new AnnotatedBeanDeFinitionReader(this);        /**         * 创建BeanDeFinition扫描器         * 可以用来扫描包或者类,进而转换为bd         *         * Spring默认的扫描包不是这个scanner对象         * 而是自己new的一个ClasspathBeanDeFinitionScanner         * Spring在执行工程后置处理器ConfigurationClasspostProcessor时,去扫描包时会new一个ClasspathBeanDeFinitionScanner         *         * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法         * 通过调用context.scan("package name");扫描处理配置类         * 扫描         */        this.scanner = new ClasspathBeanDeFinitionScanner(this);    }

1. 初始化AnnotatedBeanDeFinitionReader.

2. 初始化ClasspathBeanDeFinitionScanner

我们先来看看AnnotatedBeanDeFinitionReader

 

 

 在这里的描述中,我们知道BeanDeFinitionReader是要去扫描配置或者注解,如果理解为销售的话,就是扫描楼盘. 这里面就有我们的潜在用户. 也就是我们需要将其转换为bean的对象. 

那么初始化的时候,AnnotatedBeanDeFinitionReader做了什么呢?

重点看这句

    public AnnotatedBeanDeFinitionReader(BeanDeFinitionRegistry registry,Environment environment) {        Assert.notNull(registry,"BeanDeFinitionRegistry must not be null");        Assert.notNull(environment,"Environment must not be null");        this.registry = registry;        this.conditionEvaluator = new ConditionEvaluator(registry,environment,null);
　　　　 // 注册注解类型配置的处理器        AnnotationConfigUtils.registerannotationConfigProcessors(this.registry);    }

注册注解类型配置的处理器

AnnotationConfigUtils.registerannotationConfigProcessors(this.registry);

　　 /**     * Register all relevant annotation post processors in the given registry.     * @param registry the registry to operate on     * @param source the configuration source element (already extracted)     * that this registration was triggered from. May be {@code null}.     * @return a Set of BeanDeFinitionHolders,containing all bean deFinitions     * that have actually been registered by this call     */    public static Set<BeanDeFinitionHolder> registerannotationConfigProcessors(            BeanDeFinitionRegistry registry,@Nullable Object source) {        // 获取到beanfactory        Defaultlistablebeanfactory beanfactory = unwrapDefaultlistablebeanfactory(registry);        /**         * 判断beanfactory中是否有AnnotationAwareOrderComparator和ContextAnnotationautowireCandIDateResolver         * 没有则添加         */        if (beanfactory != null) {            if (!(beanfactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {                beanfactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);            }            if (!(beanfactory.getautowireCandIDateResolver() instanceof ContextAnnotationautowireCandIDateResolver)) {                beanfactory.setautowireCandIDateResolver(new ContextAnnotationautowireCandIDateResolver());            }        }        // BeanDeFinitionHolder: 为BeanDeFinition设置名字和别名        Set<BeanDeFinitionHolder> beanDefs = new linkedHashSet<>(8);        // 1. 如果registry中没有ConfigurationClasspostProcessor配置类后置处理器,就添加一个        if (!registry.containsBeanDeFinition(CONfigURATION_ANNOTATION_PROCESSOR_BEAN_name)) {            RootBeanDeFinition def = new RootBeanDeFinition(ConfigurationClasspostProcessor.class);            def.setSource(source);            // 构建BeanDeFinitionHolder,并添加到beanDefs            beanDefs.add(registerPostProcessor(registry,def,CONfigURATION_ANNOTATION_PROCESSOR_BEAN_name));        }        // 2. 如果rigistry中,没有autowiredAnnotationBeanPostProcessor  autowired注解bean的后置处理器,则添加一个        if (!registry.containsBeanDeFinition(autoWIRED_ANNOTATION_PROCESSOR_BEAN_name)) {            RootBeanDeFinition def = new RootBeanDeFinition(autowiredAnnotationBeanPostProcessor.class);            def.setSource(source);            // 构建BeanDeFinitionHolder,autoWIRED_ANNOTATION_PROCESSOR_BEAN_name));        }        // Check for JsR-250 support,and if present add the CommonAnnotationBeanPostProcessor.        // 3. 检查对JsR-250的支持,如果rigistry中没有CommonAnnotationBeanPostProcessor通用注解后置处理器,则添加一个        if (Jsr250Present && !registry.containsBeanDeFinition(COMMON_ANNOTATION_PROCESSOR_BEAN_name)) {            RootBeanDeFinition def = new RootBeanDeFinition(CommonAnnotationBeanPostProcessor.class);            def.setSource(source);            // 构建BeanDeFinitionHolder,COMMON_ANNOTATION_PROCESSOR_BEAN_name));        }        // Check for JPA support,and if present add the PersistenceAnnotationBeanPostProcessor.        // 4. 检查对jpa的支持,如果不包含internalPersistenceAnnotationProcessor,持久化注解处理器,就添加一个        if (jpaPresent && !registry.containsBeanDeFinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_name)) {            RootBeanDeFinition def = new RootBeanDeFinition();            try {                def.setBeanClass(ClassUtils.forname(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_name,AnnotationConfigUtils.class.getClassLoader()));            }            catch (ClassNotFoundException ex) {                throw new IllegalStateException(                        "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_name,ex);            }            def.setSource(source);            beanDefs.add(registerPostProcessor(registry,PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_name));        }        // 5. 检查对事件监听的支持,如果不包含事件监听处理器internalEventListenerProcessor,就添加一个        if (!registry.containsBeanDeFinition(EVENT_ListENER_PROCESSOR_BEAN_name)) {            RootBeanDeFinition def = new RootBeanDeFinition(EventListenerMethodProcessor.class);            def.setSource(source);            beanDefs.add(registerPostProcessor(registry,EVENT_ListENER_PROCESSOR_BEAN_name));        }        // 6. 如果不包含事件监听工厂处理器internalEventListenerFactory,就添加一个        if (!registry.containsBeanDeFinition(EVENT_ListENER_FACTORY_BEAN_name)) {            RootBeanDeFinition def = new RootBeanDeFinition(DefaultEventListenerFactory.class);            def.setSource(source);            beanDefs.add(registerPostProcessor(registry,EVENT_ListENER_FACTORY_BEAN_name));        }        return beanDefs;    }

在这里注册了6个后置处理器.

 

 

 

四. bean定义扫描器ClasspathBeanDeFinitionScanner

 

　　public AnnotationConfigApplicationContext() {        /**         * 创建了一个Bean定义的读取器.         * 完成了spring内部BeanDeFinition的注册(主要是后置处理器)         * 读取了很多spring自定义的配置(主要是后置处理器). 这些类都是spring 的原始类.         */        this.reader = new AnnotatedBeanDeFinitionReader(this);        /**         * 创建BeanDeFinition扫描器         * 可以用来扫描包或者类,去扫描包时会new一个ClasspathBeanDeFinitionScanner         *         * 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法         * 通过调用context.scan("package name");扫描处理配置类         * 扫描         */        this.scanner = new ClasspathBeanDeFinitionScanner(this);    }

主要看加粗的部分. 这部分初始化了BeanDeFinition扫描器. 这里的这个scanner不是spring默认的扫描包. Spring默认的扫描包不是这个scanner对象,而是自己new的一个ClasspathBeanDeFinitionScanner, Spring在执行后置处理器ConfigurationClasspostProcessor时,去扫描包时会new一个ClasspathBeanDeFinitionScanner, 这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法, 通过调用context.scan("package name");扫描处理配置类

 比如,我们可以这样使用

    public static voID main(String[] args) {        // 第一步: 通过AnnotationConfigApplicationContext读取一个配置类        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainStarter.class);        context.scan("package name");        Car car = (Car) context.getBean("car");        System.out.println(car.getname());        context.close();    }

 

首先调用了ClasspathBeanDeFinitionScanner(this) 构造方法,然后调用registerDefaultFilter注册摩尔恩的过滤器,这里面默认的过滤器有两种: javax.annotation.ManagedBean 和 javax.inject.named. 同时隐含的会注册所有带有@Component @Repository @Controller关键字的注解

    @SuppressWarnings("unchecked")    protected voID registerDefaultFilters() {        this.includeFilters.add(new AnnotationTypeFilter(Component.class));        ClassLoader cl = ClasspathScanningCandIDateComponentProvIDer.class.getClassLoader();        try {            this.includeFilters.add(new AnnotationTypeFilter(                    ((Class<? extends Annotation>) ClassUtils.forname("javax.annotation.ManagedBean",cl)),false));            logger.trace("JsR-250 'javax.annotation.ManagedBean' found and supported for component scanning");        }        catch (ClassNotFoundException ex) {            // JsR-250 1.1 API (as included in Java EE 6) not available - simply skip.        }        try {            this.includeFilters.add(new AnnotationTypeFilter(                    ((Class<? extends Annotation>) ClassUtils.forname("javax.inject.named",false));            logger.trace("JsR-330 'javax.inject.named' annotation found and supported for component scanning");        }        catch (ClassNotFoundException ex) {            // JsR-330 API not available - simply skip.        }    }

 

在ClasspathBeanDeFinitionScanner中,有一个非常重要的方法,就是doScan(String ....beanPackages). 用来扫描传入的配置文件.

 

五.  注册配置方法

    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {        // 进入构造函数,要先调用父类的构造方法        this();        // register配置注册类        register(componentClasses);        // ioc容器shua新接口--非常重要        refresh();    }

这是AnnotationConfigApplicationContext方法的构造函数,里面第二步调用了register()方法. 

 

 

 

　　private <T> voID doRegisterBean(Class<T> beanClass,@Nullable String name,@Nullable Class<? extends Annotation>[] qualifIErs,@Nullable supplier<T> supplier,@Nullable BeanDeFinitionCustomizer[] customizers) {        // 将入参beanClass构建成AnnotatedGenericBeanDeFinition对象        AnnotatedGenericBeanDeFinition abd = new AnnotatedGenericBeanDeFinition(beanClass);        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {            return;        }        abd.setInstancesupplier(supplier);        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);        abd.setScope(scopeMetadata.getScopename());        String beanname = (name != null ? name : this.beannameGenerator.generateBeanname(abd,this.registry));        // 处理通用定义注解        AnnotationConfigUtils.processCommonDeFinitionAnnotations(abd);        if (qualifIErs != null) {            for (Class<? extends Annotation> qualifIEr : qualifIErs) {                if (Primary.class == qualifIEr) {                    abd.setPrimary(true);                }                else if (Lazy.class == qualifIEr) {                    abd.setLazyInit(true);                }                else {                    abd.addQualifIEr(new autowireCandIDateQualifIEr(qualifIEr));                }            }        }        if (customizers != null) {            for (BeanDeFinitionCustomizer customizer : customizers) {                customizer.customize(abd);            }        }        BeanDeFinitionHolder deFinitionHolder = new BeanDeFinitionHolder(abd,beanname);        deFinitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata,deFinitionHolder,this.registry);        BeanDeFinitionReaderUtils.registerBeanDeFinition(deFinitionHolder,this.registry);    }

AnnotationConfigUtils.processCommonDeFinitionAnnotations(abd);用来加载bean元数据中的注解

BeanDeFinitionReaderUtils.registerBeanDeFinition(deFinitionHolder,this.registry);用来注册bean定义. 经过一些列的教研,没有问题,然后将其让入到this.beanDeFinitionMap.put(beanname,beanDeFinition);中

具体做了哪些工作,可以看看上面的结构图

 六. Refresh() -- spring ioc容器刷新方法

    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {        // 进入构造函数,要先调用父类的构造方法        this();        // register配置注册类        register(componentClasses);        // ioc容器shua新接口--非常重要        refresh();    }

refresh()方法,spring有很多衍生品,比如spring mvc,spring boot,都有这个方法. refresh()里面定义了spring ioc中bean加载的全过程. 

    @OverrIDe    public voID refresh() throws BeansException,IllegalStateException {        synchronized (this.startupShutdownMonitor) {            // 1. 准备刷新上下文环境            prepareRefresh();            // Tell the subclass to refresh the internal bean factory.            //2. 获取告诉子类初始化bean工厂,不同工厂不同实现            Configurablelistablebeanfactory beanfactory = obtainFreshbeanfactory();            // Prepare the bean factory for use in this context.            //3. 对bean工厂进行填充属性            preparebeanfactory(beanfactory);            try {                // Allows post-processing of the bean factory in context subclasses.                // 4. 留个子类去实现该接口                postProcessbeanfactory(beanfactory);                // Invoke factory processors registered as beans in the context.                /*                 * 调用bean工厂的后置处理器                 * 1. 会再次class扫描成BeanDeFinition                 */                invokebeanfactoryPostProcessors(beanfactory);                // Register bean processors that intercept bean creation.                // 注册bean后置处理器                registerBeanPostProcessors(beanfactory);                // Initialize message source for this context.                // 初始化国际化资源处理器                initMessageSource();                // Initialize event multicaster for this context.                // 创建事件多播放器                initApplicationEventMulticaster();                // Initialize other special beans in specific context subclasses.                // 这个方法通用也是留个子类实现的,spring boot也是从这个方法进行启动                onRefresh();                // Check for Listener beans and register them.                // 将事件监听器注册到多播放器上                registerListeners();                // Instantiate all remaining (non-lazy-init) singletons.                // 实例化剩余的单实例bean                /**                 * 这个方法就是循环遍历BeanDeFinitionMap,调用getBean,去生产bean                 */                finishbeanfactoryInitialization(beanfactory);                // Last step: publish corresponding event.                //最后容器刷新 发布刷新时间(spring cloud是从这里启动的 )                finishrefresh();            }            catch (BeansException ex) {                if (logger.isWarnEnabled()) {                    logger.warn("Exception encountered during context initialization - " +                            "cancelling refresh attempt: " + ex);                }                // Destroy already created singletons to avoID dangling resources.                destroyBeans();                // reset 'active' flag.                cancelRefresh(ex);                // Propagate exception to caller.                throw ex;            }            finally {                // reset common introspection caches in Spring's core,since we                // might not ever need Metadata for singleton beans anymore...                resetCommonCaches();            }        }    }

这是refresh()的源码,在refresh()中做了很多很多事情,我们这次主要看和ioc中beanfactory创建bean有关的部分.

 

一个是: invokebeanfactoryPostProcessors(beanfactory);

另一个是: finishbeanfactoryInitialization(beanfactory);

 

6.1 invokebeanfactoryPostProcessors(beanfactory) 调用beanfactory的后置处理器

 在AnnotatedBeanDeFinitionReader这里扫描了所有后置处理器,将其解析到beanDeFinitionMap,在这里调用后置处理器

 

6.2 finishbeanfactoryInitialization 实例化剩余的单实例bean

 这个方法就是循环遍历BeanDeFinitionMap,去生产bean

 

这里第一个是: 冻结配置类,意思是说,我马上就要开始制造bean了,bean配置文件不能再修改了,所以被冻结

原理是有一个变量标记,设为true标记冻结.

    @OverrIDe    public voID freezeConfiguration() {        this.configurationFroZen = true;        this.froZenBeanDeFinitionnames = StringUtils.toStringArray(this.beanDeFinitionnames);    }

 

第二个是实例化创建bean

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.        // 确保此时的bean已经被解析了        Class<?> resolvedClass = resolveBeanClass(mbd,beanname);        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassname() != null) {            mbdToUse = new RootBeanDeFinition(mbd);            mbdToUse.setBeanClass(resolvedClass);        }        // Prepare method overrIDes.        try {            /**             * 验证和准备覆盖方法(近在xml方式中)             * lookup-method 和 replace-method             * 这两个配置存放在BeanDeFinition中的methodoverrIDes(仅在XML方式中)             * 在XML方式中,bean实例化的过程中如果检测到存在methodoverrIDes             * 则会动态的为当前bean生成代理并使用对应的拦截器为bean做增强处理             * 具体的实现我们后续分析. 现在先看mbdtoUse.prepareMethodoverrIDes()代码块             */            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.            /**             * 初始化之前的解析             * 第一次调用bean后置处理器             * 铜鼓bean的后置处理器来进行后置处理生成代理对象,一般情况下在此处不会生成代理对象             * 为什么不能生成代理对象? 不管是我们的JDK还是cglib代理都不会在此处进行代理,因为我们的真实对象没有生成,* 所以在这里不会生成代理对象             * 这一步是aop和事务的关键,因为在这解析我们的aop切面信息进行缓存.             */            Object bean = resolveBeforeInstantiation(beanname,mbdToUse);            if (bean != null) {                return bean;            }        }        catch (Throwable ex) {            throw new BeanCreationException(mbdToUse.getResourceDescription(),"BeanPostProcessor before instantiation of bean Failed",ex);        }        try {            /*             * 执行创建bean,这里就是执行创建bean的三个步骤             * 1. 实例化             * 2. 填充属性,@autowired @Value             * 3. 初始化  初始化initMethod方法和初始化destroy方法             */            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(),"Unexpected exception during bean creation",ex);        }    }

 

创建bean的三个步骤 

 

protected Object doCreateBean(final String beanname,final RootBeanDeFinition mbd,final @Nullable Object[] args)            throws BeanCreationException {        // Instantiate the bean.        BeanWrapper instanceWrapper = null;        if (mbd.isSingleton()) {            instanceWrapper = this.factorybeanInstanceCache.remove(beanname);        }        if (instanceWrapper == null) {            /**             * 第一步: 实例化             * 这里面的调用链非常深,后面再看             * bean实例化有两种方式             * 1. 使用反射:  使用反射也有两种方式,*         a. 通过无参构造函数 (默认的方式)             *             从beanDeFinition中可以得到beanClass,*             Classname = BeanDeFinition.beanclass             *             Class clazz = Class.forname(Classname);             *             clazz.newInstance();             *             这样就可以实例化bean了             *             *         b. 通过有参函数.             *            Classname = BeanDeFinition.beanclass             *             Class clazz = Class.forname(Classname);             *             Constractor con = class.getConstractor(args....)             *             con.newInstance();             *             * 2. 使用工厂             *         我们使用@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.        // 允许后置处理器修改已经合并的beanDeFinition        synchronized (mbd.postProcessingLock) {            if (!mbd.postProcessed) {                try {                    applyMergedBeanDeFinitionPostProcessors(mbd,beanType,beanname);                }                catch (Throwable ex) {                    throw new BeanCreationException(mbd.getResourceDescription(),"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) {            if (logger.isTraceEnabled()) {                logger.trace("Eagerly caching bean '" + beanname +                        "' to allow for resolving potential circular references");            }            addSingletonFactory(beanname,() -> getEarlyBeanReference(beanname,bean));        }        // Initialize the bean instance.        Object exposedobject = bean;        try {            // 第二步:填充属性,给属性赋值(调用set方法)  这里也是调用的后置处理器            populateBean(beanname,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(),"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(),"InvalID destruction signature",ex);        }        return exposedobject;    }

 

具体结构如下:

 

 

 

我的博客即将同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=1gx5pavn3x1pz

总结

以上是内存溢出为你收集整理的2.2 spring5源码系列 -- ioc加载的整体流程全部内容，希望文章能够帮你解决2.2 spring5源码系列 -- ioc加载的整体流程所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。