BeanDefinition到实例Bean的源码分析

最新推荐文章于 2023-06-07 14:31:27 发布
最新推荐文章于 2023-06-07 14:31:27 发布
阅读量354 收藏 2
点赞数
文章标签： java
原文链接：https://juejin.im/post/5b810423e51d4557b85fc935
版权

#概述

spring ioc容器的核心类是AbstractApplicationContext，入口方法是refresh。这个方法是个模板方法，定义了加载到容器的全部过程。即spring将xml配置文件加载到内存的一个过程。（著名的dubbo分布式框架也利用了spring加载xml的机制，定制自己的xml解析器将对象接入到ioc容器中。）大致过程为：创建beanFactory用于存放转换后的信息->读取文件到输入流中->读取输入流里的数据，用NamespaceHandler里注册的解析器处理返回BeanDefinition->将BeanDefinition保存到DefaultListableBeanFactory的beanDefinitionMap中。

最终xml在spring中会放到一个以名称为key,beanDefinition为value的ConcurrentHashMap中。

当 BeanDefinition 注册完毕以后， Spring Bean 工厂就可以随时根据需要进行实例化了。

①：单例Bean：IOC启动时则实例化 ②：原型Bean:IOC启动时不实例化，真正使用时才实例化。

懒加载：只针对单例Bean，意思是IOC容器启动时单例Bean可以不实例化，真正调用的时候才实例化(类似原型Bean的初始化顺序)。 主要经过方法链：reflesh() 、 finishBeanFactoryInitialization (factory) 、 DefaultListableBeanFactory.preInstantiateSingletons (), 在这里会根据注册的 BeanDefinition 信息依此调用 getBean(beanName) 。而真正实例化的逻辑和 BeanFactory 是“殊途同归”的，所有有关 Bean 实例化都可以从 getBean(beanName) 入手。

#源码分析

##入口方法

public void refresh() throws BeansException, IllegalStateException {

    Object var1 = this.startupShutdownMonitor;
    synchronized(this.startupShutdownMonitor) {
        ／／准备刷新context
        this.prepareRefresh();
        ／／刷新子类beanFactory，注册beanDefinition
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        ／／准备beanfactory
        this.prepareBeanFactory(beanFactory);

        try {
            this.postProcessBeanFactory(beanFactory);
            this.invokeBeanFactoryPostProcessors(beanFactory);
            this.registerBeanPostProcessors(beanFactory);
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            ／／初始化非懒加载的bean实例
            this.finishBeanFactoryInitialization(beanFactory);
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}


protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            public String resolveStringValue(String strVal) {
                return AbstractApplicationContext.this.getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }

    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();
    ／／初始化非懒加载的bean实例
    beanFactory.preInstantiateSingletons();
}

##初始化非懒加载的bean实例

public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }

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

    while(true) {
        while(true) {
            String beanName;
            RootBeanDefinition bd;
            do {
                do {
                    do {
                        if (!var2.hasNext()) {
                            var2 = beanNames.iterator();

                            while(var2.hasNext()) {
                                beanName = (String)var2.next();
                                Object singletonInstance = this.getSingleton(beanName);
                                if (singletonInstance instanceof SmartInitializingSingleton) {
                                    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                    if (System.getSecurityManager() != null) {
                                        AccessController.doPrivileged(new PrivilegedAction<Object>() {
                                            public Object run() {
                                                smartSingleton.afterSingletonsInstantiated();
                                                return null;
                                            }
                                        }, this.getAccessControlContext());
                                    } else {
                                        smartSingleton.afterSingletonsInstantiated();
                                    }
                                }
                            }

                            return;
                        }

                        beanName = (String)var2.next();
                        bd = this.getMergedLocalBeanDefinition(beanName);
                    } while(bd.isAbstract());
                } while(!bd.isSingleton());
            } while(bd.isLazyInit());

            if (this.isFactoryBean(beanName)) {
                final FactoryBean<?> factory = (FactoryBean)this.getBean("&" + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = ((Boolean)AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                        public Boolean run() {
                            return ((SmartFactoryBean)factory).isEagerInit();
                        }
                    }, this.getAccessControlContext())).booleanValue();
                } else {
                    isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
                }

                if (isEagerInit) {
                    this.getBean(beanName);
                }
            } else {
                this.getBean(beanName);
            }
        }
    }
}
复制代码

AbstractBeanFactory 有四个 getBean 的重载方法，不管调用哪个方法最终都是会调用另一个 doGetBean 方法：

public Object getBean(String name) throws BeansException {  
        return getBean(name, null, null);  
    }  
          
    public Object getBean(String name, Class requiredType) throws BeansException {  
        return getBean(name, requiredType, null);  
    }  
  
    public Object getBean(String name, Object[] args) throws BeansException {  
        return getBean(name, null, args);  
    }  
  
    /** 
     * Return an instance, which may be shared or independent, of the specified bean. 
     * @param name the name of the bean to retrieve 
     * @param requiredType the required type of the bean to retrieve 
     * @param args arguments to use if creating a prototype using explicit arguments to a 
     * static factory method. It is invalid to use a non-null args value in any other case. 
     * @return an instance of the bean 
     * @throws BeansException if the bean could not be created 
     */  
    public Object getBean(String name, Class requiredType, Object[] args) throws BeansException {  
        return doGetBean(name, requiredType, args, false);  
    }  


protected Object doGetBean(  
final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)   
throws BeansException {  

//bean name处理，去除FactoryBean前缀等  
     final String beanName = transformedBeanName(name);  
     Object bean = null;  
  
//先从singleton缓存中查看是否已经实例化过该Bean，根据是否有缓存分为两个分支分别处理  
    Object sharedInstance = getSingleton(beanName);  
    if (sharedInstance != null && args == null) {  
// 分支一，若缓存中获取到了并且该BeanDefinition信息表明该bean是singleton的，直接将获取到的缓存Bean  
//(有可能是半成品)交给getObjectForBeanInstance处理  
 /*.........省略logger部分代码............*/  
//调用getObjectForBeanInstance处理  
     bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  
    }else {  
// 分之二：没有缓存，则需要从头实例化该bean  
            // We're assumably within a circular reference.  
      if (isPrototypeCurrentlyInCreation(beanName)) {   
           throw new BeanCurrentlyInCreationException(beanName);
      }  
  
// 检查BeanDefinition是否在当前工厂或父工厂  
    BeanFactory parentBeanFactory = getParentBeanFactory();  
    if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {  
        // Not found -> check parent.  
        String nameToLookup = originalBeanName(name);  
        if (args != null) {  
        // 父工厂getBean  
            return parentBeanFactory.getBean(nameToLookup, args);  
        }  
        else {  
            // No args -> delegate to standard getBean method.  
            return parentBeanFactory.getBean(nameToLookup, requiredType);  
        }  
    }  
//将bean加入“正在创建”的集合，完成后会remove,对应afterSingletonCreation/afterPrototypeCreation方法  
            if (!typeCheckOnly) {  
                markBeanAsCreated(beanName);  
            }  
  
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  
            checkMergedBeanDefinition(mbd, beanName, args);  
  
// 解决依赖关系，将依赖的bean提前实例化  
    String[] dependsOn = mbd.getDependsOn();  
    if (dependsOn != null) {  
        for (int i = 0; i < dependsOn.length; i++) {  
            String dependsOnBean = dependsOn[i];  
            getBean(dependsOnBean);  
            registerDependentBean(dependsOnBean, beanName);  
        }  
    }  
  
// 这里又需要根据bean的类型分为三种情况：singleton、prototype、request/session  
    if (mbd.isSingleton()) {  
                   //通过自定义ObjectFactory实例化Bean，此结果可能是半成品(是FactoryBean等)  
        sharedInstance = getSingleton(beanName, new ObjectFactory() {  
            public Object getObject() throws BeansException {  
                try {  
                  //真正实例化装配的逻辑在createBean方法中  
                    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交给getObjectForBeanInstance方法处理  
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
            }  
  
            else if (mbd.isPrototype()) {  
                // It's a prototype -> create a new instance.  
                Object prototypeInstance = null;  
                try {  
                    beforePrototypeCreation(beanName);  
                     //真正实例化装配的逻辑在createBean方法中  
                    prototypeInstance = createBean(beanName, mbd, args);  
                }  
                finally {  
                    afterPrototypeCreation(beanName);  
                }  
                    //上一步半成品的Bean交给getObjectForBeanInstance方法处理  
               bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  
            }  
  
            else {  
                            //request、session 的bean  
                String scopeName = mbd.getScope();  
                final Scope scope = (Scope) this.scopes.get(scopeName);  
                if (scope == null) {  
        throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");  
                }  
                try {  
                    Object scopedInstance = scope.get(beanName, new ObjectFactory() {  
                        public Object getObject() throws BeansException {  
                            beforePrototypeCreation(beanName);  
                            try {  
                         //真正实例化装配的逻辑在createBean方法中  
                                return createBean(beanName, mbd, args);  
                            }  
                            finally {  
                                afterPrototypeCreation(beanName);  
                            }  
                        }  
                    });  
                       //上一步半成品的Bean交给getObjectForBeanInstance方法处理  
                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);  
                }  
            }  
        }  
  
        // Check if required type matches the type of the actual bean instance.  
        if (requiredType != null && bean != null &&  
                              !requiredType.isAssignableFrom(bean.getClass())) {  
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());  
        }  
        return bean;  
    }  
复制代码

通过注释，可以整理出较清晰的逻辑： 检查Bean缓存，已经有缓存的Bean对象(有可能是半成品)则交给getObjectForBeanInstance方法处理；否则先根据Bean的生命周期类型分别实例化，每种情况大致都分两步,第一步都交给createBean方法生产一个半成品的bean对象，然后同样是将半成品的bean交给getObjectForBeanInstance方法处理。

##以单例为例，是怎样实例化的

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {

    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Creating instance of bean '" + beanName + "'");
    }

    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);
    }

    try {
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException var7) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var7);
    }

    Object beanInstance;
    try {
        beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
        if (beanInstance != null) {
            return beanInstance;
        }
    } catch (Throwable var8) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var8);
    }

    beanInstance = this.doCreateBean(beanName, mbdToUse, args);
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Finished creating instance of bean '" + beanName + "'");
    }

    return beanInstance;
}

##真正去创建bean

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

    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }

    if (instanceWrapper == null) {
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

    final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
    Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
    mbd.resolvedTargetType = beanType;
    Object var7 = mbd.postProcessingLock;
    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;
        }
    }

    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, new ObjectFactory<Object>() {
            public Object getObject() throws BeansException {
                return AbstractAutowireCapableBeanFactory.this.getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }

    Object exposedObject = bean;

    try {
        this.populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            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);
    }

    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 'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                }
            }
        }
    }

    try {
        this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
        return exposedObject;
    } catch (BeanDefinitionValidationException var16) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
    }
}


protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {

    Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    } else if (mbd.getFactoryMethodName() != null) {
        return this.instantiateUsingFactoryMethod(beanName, mbd, args);
    } else {
    
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            Object var7 = mbd.constructorArgumentLock;
            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 {
            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);
        }
    }
}


protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {

    try {
        Object beanInstance;
        if (System.getSecurityManager() != null) {
            beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    return AbstractAutowireCapableBeanFactory.this.getInstantiationStrategy().instantiate(mbd, beanName, AbstractAutowireCapableBeanFactory.this);
                }
            }, this.getAccessControlContext());
        } else {
            beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
        }

        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        this.initBeanWrapper(bw);
        return bw;
    } catch (Throwable var6) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
    }
}


public class SimpleInstantiationStrategy implements InstantiationStrategy {
private static final ThreadLocal<Method> currentlyInvokedFactoryMethod = new ThreadLocal();

public SimpleInstantiationStrategy() {
}

public static Method getCurrentlyInvokedFactoryMethod() {
    return (Method)currentlyInvokedFactoryMethod.get();
}

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
    if (bd.getMethodOverrides().isEmpty()) {
        Object var5 = bd.constructorArgumentLock;
        Constructor constructorToUse;
        synchronized(bd.constructorArgumentLock) {
            constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse == null) {
                final Class<?> clazz = bd.getBeanClass();
                if (clazz.isInterface()) {
                    throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }

                try {
                    if (System.getSecurityManager() != null) {
                        constructorToUse = (Constructor)AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
                            public Constructor<?> run() throws Exception {
                                return clazz.getDeclaredConstructor((Class[])null);
                            }
                        });
                    } else {
                        constructorToUse = clazz.getDeclaredConstructor((Class[])null);
                    }

                    bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                } catch (Throwable var9) {
                    throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                }
            }
        }

        return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
    } else {
        return this.instantiateWithMethodInjection(bd, beanName, owner);
    }
}复制代码
weixin_34032621
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【第五天】如何让自己定义类，自动完成spring 实例化如何实现beanDefinition
qq_18846731的博客
11-03 324
自己定义如何实现beanDefinition 第一步：先定义一个需要Spring 注入的类 package com.xiangxue.jack.beanDefinition; import lombok.Data; @Data public class BeanClass { private String username; } 第二步：新建一个实现BeanDefinitionRegistoryPostprocessor接口的类 【目的是把定制BeanClass的这个类变成BeanDefi
spring源码分析之BeanDefinition相关
热门推荐
liushangzaibeijing的博客
03-28 6万+
BeanDeifntion是spring比较核心的组件，它将我们定义的bean都会抽像成对应的BeanDefintion实例对象。了解其相关的知识点对于我们以后通读spring源码以及更加得心应手的应用有很多的好处。本篇博文针对BeanDefintion的家族相关的类与接口进行相关的介绍，同时针对我们项目中相关xml中定义相关的bean(各种各样bean)的属性进行了使用以及应用场景的介绍。以后会追加相关注解（好像没必要相关xml概念可以直接移植到注解的使用方式也是可用的）。
Spring BeanDefinition 详解与案例
作草分茶
04-12 1148
介绍 BeanDefinition 是 Spring 用来描述用来生成 Bean 的类的元数据信息的一个接口。容器中的 BeanDefinitionMap 是 IOC 的一个基础的组成部分，也是非常重要的一个组件。 BeanDefinition 是一个接口，它的继承关系如下： AbstractBeanDefinition是一个抽象类，它的三个子类都具有各自的特点，下会重点分析。 BeanDefi...
Spring的bean定义 3 : BeanDefinition实现类例子演示
Details Inside Spring
12-31 1386
演示源码 辅助演示使用的bean类 package tut.zero; import lombok.Data; @Data public class Pet { String type; String name; } 演示BeanDefinition各个实现类例如何被使用 package tut.zero; import lombok.extern.slf4j.Slf4j...
手动注册BeanDefinition获取bean实例
u013995395的博客
12-21 4843
简单实现一下如何手动注册BeanDefinition，从而让beanFactory返回给我们一个spring容器管理的单例bean(如果不显示设置，默认为单例)。首先让一个类注解为@Component的类实现接口BeanFactoryAware,实现如下方法，从而获取beanFactory: @Override public void setBeanFactory(BeanFactor...
深入浅出弄明白Spring的BeanDefinition，Spring-Beans部分源码分析
秃了也弱了
12-21 793
该文对spring初学者不友好，学习讨论spring-beans模块源码的大佬们请批评指正。Bean 的类名Bean 行为配置元素，如作用域、自动绑定的模式，生命周期回调等其他 Bean 引用，又可称作合作者（collaborators）或者依赖（dependencies）配置设置，比如 Bean 属性（Properties）在xml中我们可以使用id属性自定义命名：每个bean的id（身份证号）都不同，但可以有相同的name （人名）。
Spring源码解析之BeanDefinition
azhida的博客
06-18 580
Spring源码解析之BeanDefinition通过阅读本文你能获得什么为什么要学习BeanDefinitionBeanDefinition在Spring中的作用BeanDefinition的定义BeanDefinition的类型BeanDefinition的实战 通过阅读本文你能获得什么 1、什么是BeanDefinition 2、怎么用BeanDefinition定制化开发 为什么要学习BeanDefinition BeanDefinition看名称可以大致明白是用来描述spring中bean的
SpringBoot的Bean Definition 生成过程（源码分析）
小样
04-16 3433
1、目的： 从源码的角度分析整个springboot的启动流程、了解springboot项目在整个启动过程都干了一些什么。 因为spring项目的启动主要是分为两步，一个是bean definition的获取，一个是根据bean definition 生成bean。本篇主要涉及 2、demo项目结构的简单描述。 基本的东西都是有的，包括dao，service、model、且包含myba...
Spring 源码分析（Bean的初始化）
12-21
接下来，Spring会创建`BeanDefinition`对象来存储每个`<bean>`元素的元数据，包括类名、依赖关系、初始化方法、属性值等。`BeanDefinition`是Spring IOC容器中Bean定义的抽象表示，它包含了Bean的所有配置信息。 ...
spring源码分析系列2:Bean与BeanDefinition关系
2017年
10-08 1769
Bean与BeanDefinitionBeanDefinition定义动作(操作)其他形态Bean定义操作其他形态 接口表示一种能力，实现了一个接口，即拥有一种能力。 BeanDefinition与Bean的关系, 就好比类与对象的关系. 类在spring的数据结构就是BeanDefinition.根据BeanDefinition得到的对象就是我们需要的Bean. 我认为理解Bean与Bean...
spring源码阅读之BeanDefinition，解析文件，读取Bean，解析Bean，注册Bean
strideahead的博客
07-14 2174
分为三个层次，核心、组件、应用1 spring Framework（Core）核心，类似于操作系统的kernel，IOC容器和AOP模块。用Ioc管理POJO对象，AOP动态和非侵入式的方式增强服务。简化JavaEE体现在，为应用开发提供了许多即开即用的系统组件和服务，如事务处理、webMVC、jdbc、orm、远端调用，类似于操作系统的驱动。* spring IOC  最基本的IOC容器Bean...
BeanDefinition数据流
tmmh
07-08 97
[size=medium]BeanDefinition是Spring配置文件中bean定义的内存表现形式，我们先来看看bean的创建。在下图中不同的元素的解析路线用不同的颜色标注 [color=red]主线部分[/color] [list=1] [*] 实例化xmlApplicationContext [*] 实例化XmlBeanDefinitionReader [*] Resourc...
Spring - Bean的实例化流程及生命周期
weixin_51351637的博客
06-07 1388
加载xml配置文件，解析获取配置中的每个的信息，封装成一个个的BeanDefinition对象将BeanDefinition存储在一个名为beanDefinitionMap的Map中ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象创建好的Bean实例对象，被存储到一个名为singletonObjects的Map中。
依赖注入之Bean实例化前的准备
程旭元的博客
03-08 2965
IOC容器虽然已经构造好，但现在的容器只是一个壳，对象间的依赖关系还未进行填充。那么接下来便分析填充依赖关系的过程，即依赖注入。依赖注入主要有两个过程，一个是实例化Bean，另一个是将依赖关系注入到Bean中。 依赖注入的入口是我们熟悉的getBean方法。 AbstractBeanFactory的doGetBean方法是具体实现依赖注入的地方 方法中的代码较多
Spring源码系列(二):BeanDefinition对象
wyg1973017714的博客
04-11 679
Spring源码系列二:BeanDefinition对象 BeanDefinition可以看作是一个bean在Spring中的描述。 首先大体介绍BeanDefinition这个对象，它描述了bean的一些基本信息，包括：bean的class名、作用域(单例、原型)、懒加载、FactoryBean、构造函数、属性值、描述以及bean的来源，spring会根据这些信息来实例化bean。 BeanDefinition对象在org.springframework.beans.factory.config包下，我们
spring容器的bean什么时候被实例化
java_gchsh的博客
09-27 6214
spring容器实例化
Spring什么时候实例化Bean的？
特别享受思考问题的过程
05-16 2558
今天忽然想到一个问题，Spring是什么时候实例化Bean的？ 1、是spring容器启动的时候？ 2、还是第一次用到bean的时候实例化？ 于是决定看一下源码 N年以前，spring还没有现在这么强大的时候，我们是如何使用spring的呢？使用XML文件配置，如下： public class SchoolServiceImpl { public String getTimeStr(){ return LocalDateTime.now().format(DateTim
Spring源码：Bean的实例化及初始化过程
个人站点：javatv.net
11-03 4565
1. 概述 在前面的文章中，我们把 refresh() 中 obtainFreshBeanFactory、invokeBeanFactoryPostProcessors、方法都梳理了一遍，其中还有一个 registerBeanPostProcessors，但个人觉得实际上和 invokeBeanFactoryPostProcessors类似，所以没有单独写一篇文章去描述的，尽管它非常重要，但是你可以自己去分析一下或者看看这篇文章：registerBeanPostProcessors 详解。 refresh(
spring bean 生命周期 源码分析
最新发布
07-28
Spring的Bean生命周期是由...以上是一个简单的概述，实际的源码分析涉及到Spring框架的很多细节，包括BeanDefinition、BeanFactory、ApplicationContext等。你可以参考Spring源码来深入了解Bean生命周期的实现细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值