【Spring源码--IOC容器的实现】(五)Bean对象的创建

前言:

1.第一次直接用CSDN原生的编辑器写博客,格式排版还有点陌生,见谅。

2.前面的文章我们写了IOC容器的启动,也就是把xml里面的配置都解析成Spring的内部结构BeanDefinition,并存储在Spring的容器中。下面我们将分析IOC容器室怎样对bean的依赖关系进行注入的。依赖注入的过程是第一次向IOC容器索要bean时触发的(例外:lazy-init实现bean的预实例化),也就是getBean方法。

3.依赖注入可以分为两个过程,一是bean所包含的Java对象的创建,二是对bean对象的初始化,依赖注入也就是发生在这里的。

Bean对象的创建:

getBean创建Bean

查看BeanFactory的getBean的实现方法,有三个类实现了该方法:SimpleJndiBeanFactory,StaticListableBeanFactory和AbstractApplicationContext。我们比较熟悉的是AbstractApplicationContext这个类,那也就以这个类来看看getBean的源码:

代码1.1:AbstractApplicationContext类的getBean方法:

//根据Bean名称,向容器获取指定名称的Bean
public Object getBean(String name) throws BeansException {
        return getBeanFactory().getBean(name);
    }
    //根据Bean名称和类型,向容器获取指定名称和类型的Bean
    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return getBeanFactory().getBean(name, requiredType);
    }
    //根据Bean的类型,向容器获取指定类型的Bean
    public <T> T getBean(Class<T> requiredType) throws BeansException {
        return getBeanFactory().getBean(requiredType);
    }
    //根据Bean名称和一些指定参数,向IoC容器获取符合条件的Bean
    public Object getBean(String name, Object... args) throws BeansException {
        return getBeanFactory().getBean(name, args);
}  

通过上面这4个getBean方法源码可以看出,真正实现向IoC容器索取被管理的Bean的功能的是getBeanFactory().getBean方法。继续追踪getBeanFactory()方法看到返回的对象是DefaultListableBeanFactory容器对象,DefaultListableBeanFactory容器的父类AbstractBeanFactory中实现了getBean方法。所以,我们继续看AbstractBeanFactory的getBean方法,可想而知会有很多的方法重载。

代码1.2:AbstractBeanFactory类的getBean方法:

public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }
    public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
        return doGetBean(name, requiredType, null, false);
    }
    public Object getBean(String name, Object... args) throws BeansException {
        return doGetBean(name, null, args, false);
    }
    public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
        return doGetBean(name, requiredType, args, false);
    }
//真正实现向IoC容器获取Bean的功能,也是触发依赖注入功能的地方
    @SuppressWarnings("unchecked")
    protected <T> T doGetBean(
            final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {
        //根据指定的名称获取被管理Bean的名称,剥离指定名称中对容器的相关依赖如果指定的是别名,将别名转换为规范的Bean名称
        final String beanName = transformedBeanName(name);
        Object bean;
        //先从缓存中取是否已经有被创建过的单态类型的Bean,对于单态模式的Bean整个IoC容器中只创建一次,不需要重复创建
        Object sharedInstance = getSingleton(beanName);
        //IoC容器创建单态模式Bean实例对象
        if (sharedInstance != null && args == null) {
            if (logger.isDebugEnabled()) {
                //如果指定名称的Bean在容器中已有单态模式的Bean被创建,直接返回已经创建的Bean
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            //获取给定Bean的实例对象,主要是完成FactoryBean的相关处理
            //注意:BeanFactory是管理容器中Bean的工厂,而FactoryBean是创建创建对象的工厂Bean,两者之间有区别
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {//缓存没有正在创建的单态模式Bean
            //缓存中已经有已经创建的原型模式Bean,但是由于循环引用的问题导致实例化对象失败
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            //对IoC容器中是否存在指定名称的BeanDefinition进行检查,首先检查是否能在当前的BeanFactory中获取的所需要的Bean,如果不能则委托当前容器
            //的父级容器去查找,如果还是找不到则沿着容器的继承体系向父级容器查找
            BeanFactory parentBeanFactory = getParentBeanFactory();
            //当前容器的父级容器存在,且当前容器中不存在指定名称的Bean
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                //解析指定Bean名称的原始名称
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    //委派父级容器根据指定名称和显式的参数查找
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    //委派父级容器根据指定名称和类型查找
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }
            //创建的Bean是否需要进行类型验证,一般不需要
            if (!typeCheckOnly) {
                //向容器标记指定的Bean已经被创建
                markBeanAsCreated(beanName);
            }
        //根据指定Bean名称获取其父级的Bean定义,主要解决Bean继承时子类合并父类公共属性问题
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            //获取当前Bean所有依赖Bean的名称
            String[] dependsOn = mbd.getDependsOn();
            //如果当前Bean有依赖Bean
            if (dependsOn != null) {
                for (String dependsOnBean : dependsOn) {
                    //递归调用getBean方法,获取当前Bean的依赖Bean
                    getBean(dependsOnBean);
                    //把被依赖Bean注册给当前依赖的Bean
                    registerDependentBean(dependsOnBean, beanName);
                }
            }
            //创建单态模式Bean的实例对象
            if (mbd.isSingleton()) {
            //这里使用了一个匿名内部类,创建Bean实例对象,并且注册给所依赖的对象
                sharedInstance = getSingleton(beanName, new ObjectFactory() {
                    public Object getObject() throws BeansException {
                        try {
<span style="white-space:pre">			</span>//创建一个指定Bean实例对象,如果有父级继承,则合并子类和父类的定义
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            //显式地从容器单态模式Bean缓存中清除实例对象
                            destroySingleton(beanName);
                            throw ex;
                        }
                    }
                });
                //获取给定Bean的实例对象
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }
            //IoC容器创建原型模式Bean实例对象
            else if (mbd.isPrototype()) {
                //原型模式(Prototype)是每次都会创建一个新的对象
                Object prototypeInstance = null;
                try {
<span style="white-space:pre">		</span>//回调beforePrototypeCreation方法,默认的功能是注册当前创建的原型对象
                    beforePrototypeCreation(beanName);
                    //创建指定Bean对象实例
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
<span style="white-space:pre">		</span>//回调afterPrototypeCreation方法,默认的功能告诉IoC容器指//定Bean的原型对象不再创建了
                    afterPrototypeCreation(beanName);
                }
                //获取给定Bean的实例对象
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }
            //要创建的Bean既不是单态模式,也不是原型模式,则根据Bean定义资源中的生命周期范围,选择实例化Bean的合适方法,这种在Web应用程序中
<span style="white-space:pre">		</span>//比较常用,如:request、session、application等生命周期
            else {
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                //Bean定义资源中没有配置生命周期范围,则Bean定义不合法
                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 {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        }
                    });
                    //获取给定Bean的实例对象
                    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);
                }
            }
        }
        //对创建的Bean实例对象进行类型检查
        if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
        return (T) bean;
    } 

这里面有几个地方要好好看一下:

  • 对于单例模式的bean的创建:只创建一次,所以会先检查再创建。
  • BeanFactory是对象工厂,里面存的是bean的对象,可以从这里面取bean对象。FactoryBean是一个Bean,只不过这个bean有生产对象能力的工厂bean。
  • 注意getBean里面的递归调用,也就是直到找到一个没有依赖的bean创建出来,再依次把前面的bean创建。

上面那些代码只是定义了不同类型的bean采用不同的创建方式,归根到底还是没有创建bean,所以我们继续走主线:看createBean方法,这里一样,用了委派模式,具体的Bean实例创建过程交由其实现类AbstractAutowireCapableBeanFactory完成。来看源码:

代码1.3:AbstractAutowireCapableBeanFactory的createBean方法

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
            throws BeanCreationException {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating instance of bean '" + beanName + "'");
        }
        //判断需要创建的Bean是否可以实例化,即是否可以通过当前的类加载器加载
        resolveBeanClass(mbd, beanName);
        //校验和准备Bean中的方法覆盖
        try {
            mbd.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }
        try {
<span style="white-space:pre">	</span>//如果Bean配置了初始化前和初始化后的处理器,则试图返回一个需要创建Bean的代理对象
            Object bean = resolveBeforeInstantiation(beanName, mbd);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }
        //创建Bean的入口
        Object beanInstance = doCreateBean(beanName, mbd, args);
        if (logger.isDebugEnabled()) {
            logger.debug("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    }  

上面的代码只是对Bean进行了一些检测和其他处理,具体的代码还要看doCreateBean()方法。

代码1.4:AbstractAutowireCapableBeanFactory类的doCreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
        //封装被创建的Bean对象
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()){//单态模式的Bean,先从容器中缓存中获取同名Bean
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            //创建实例对象
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
        //获取实例化对象的类型
        Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
        //调用PostProcessor后置处理器
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                mbd.postProcessed = true;
            }
        }
        // Eagerly cache singletons to be able to resolve circular references
        //向容器中缓存单态模式的Bean对象,以防循环引用
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            //这里是一个匿名内部类,为了防止循环引用,尽早持有对象的引用
            addSingletonFactory(beanName, new ObjectFactory() {
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }
        //Bean对象的初始化,依赖注入在此触发
        //这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean
        Object exposedObject = bean;
        try {
            //将Bean实例对象封装,并且Bean定义中配置的属性值赋值给实例对象
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                //初始化Bean对象
                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) {
            //获取指定名称的已注册的单态模式Bean对象
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                //根据名称获取的以注册的Bean和正在实例化的Bean是同一个
                if (exposedObject == bean) {
                    //当前实例化的Bean初始化完成
                    exposedObject = earlySingletonReference;
                }
                //当前Bean依赖其他Bean,并且当发生循环引用时不允许新创建实例对象
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
                    //获取当前Bean所依赖的其他Bean
                    for (String dependentBean : dependentBeans) {
                        //对依赖Bean进行类型检查
                        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.");
                    }
                }
            }
        }
        //注册完成依赖注入的Bean
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
        return exposedObject;
    }  

上面的代码有两个关键的地方:createBeanInstance:创建对象的方法;populateBean:完成属性注入,初始化依赖注入等。我们重点关注createBeanInstance方法。

代码1.5:AbstractAutowireCapableBeanFactory类的createBeanInstance方法

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
        //检查确认Bean是可实例化的
        Class beanClass = resolveBeanClass(mbd, beanName);
        //使用工厂方法对Bean进行实例化
        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());
        }
        if (mbd.getFactoryMethodName() != null)  {
            //调用工厂方法实例化
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
        //使用容器的自动装配方法进行实例化
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            if (autowireNecessary) {
                //配置了自动装配属性,使用容器的自动装配实例化容器的自动装配是根据参数类型匹配Bean的构造方法
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                //使用默认的无参构造方法实例化
                return instantiateBean(beanName, mbd);
            }
        }
        //使用Bean的构造方法进行实例化
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            //使用容器的自动装配特性,调用匹配的构造方法实例化
            return autowireConstructor(beanName, mbd, ctors, args);
        }
        //使用默认的无参构造方法实例化
        return instantiateBean(beanName, mbd);
    }
//使用默认的无参构造方法实例化Bean对象
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
        try {
            Object beanInstance;
            final BeanFactory parent = this;
            //获取系统的安全管理接口,JDK标准的安全管理API
            if (System.getSecurityManager() != null) {
                //这里是一个匿名内置类,根据实例化策略创建实例对象
                beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        return getInstantiationStrategy().instantiate(mbd, beanName, parent);
                    }
                }, getAccessControlContext());
            }
            else {
                //将实例化的对象封装起来
                beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
            }
            BeanWrapper bw = new BeanWrapperImpl(beanInstance);
            initBeanWrapper(bw);
            return bw;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
        }
    } 

上面的代码我们可以看到,对于通过工厂方法和自动装配的Bean的实例化比较清晰,调用具体的工厂方法和参数匹配构造方法就可完成对象的创建(具体的方法不

看了,因为我只知道在那里具体创建,具体创建的过程不是特明白,所以不耽误人)。但是我们一般用的最多的是无参构造器方法,讲道理确实很少配置工厂方法

的bean,带构造器参数的还算常见。所以需要具体的实例化策略,继续看getInstantiationStrategy().instantiate方法:

代码1.6:SimpleInstantiationStrategy类的instantiate方法:

public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {
        //如果Bean定义中没有方法覆盖,则就不需要CGLIB父类类的方法
        if (beanDefinition.getMethodOverrides().isEmpty()) {
            Constructor<?> constructorToUse;
            synchronized (beanDefinition.constructorArgumentLock) {
                //获取对象的构造方法或工厂方法
                constructorToUse = (Constructor<?>) beanDefinition.resolvedConstructorOrFactoryMethod;
                //如果没有构造方法且没有工厂方法
                if (constructorToUse == null) {
                    //使用JDK的反射机制,判断要实例化的Bean是否是接口
                    final Class clazz = beanDefinition.getBeanClass();
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
                    try {
                        if (System.getSecurityManager() != null) {
                           //这里是一个匿名内置类,使用反射机制获取Bean的构造方法
                            constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor>() {
                                public Constructor run() throws Exception {
                                    return clazz.getDeclaredConstructor((Class[]) null);
                                }
                            });
                        }
                        else {
                            constructorToUse =  clazz.getDeclaredConstructor((Class[]) null);
                        }
                        beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
                    }
                    catch (Exception ex) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                    }
                }
            }
<span style="white-space:pre">	</span>    //使用BeanUtils实例化,通过反射机制调用”构造方法.newInstance(arg)”来进行实例化
            return BeanUtils.instantiateClass(constructorToUse);
        }
        else {
            //使用CGLIB来实例化对象
            return instantiateWithMethodInjection(beanDefinition, beanName, owner);
        }
    } 

在这里我们可以看到,是通过是否有方法替换来决定是采用反射还算采用CGLIB方法实例对象。这里我要多一点:beanDefinition.getMethodOverrides()这个地方取到的值是我们在解析BeanDefinition的lookup-method和replace-method,忘记的同学可以返回到BeanDefinitionParserDelegate类的parseBeanDefinitionElement方法中查看parseLookupOverrideSubElements(ele,
bd.getMethodOverrides())和parseReplacedMethodSubElements(ele, bd.getMethodOverrides())子方法。也就是说,如果bean中有配置这两个属性,我们就采取cglib方法创建对象,如果没有,就采用无参构造器方法创建对象。具体的创建方法,大家具体去看下,我目前还不是能说的太明白。

所以,到这里我们的对象也就创建完成了。

lookup-method和replace-method:

lookup-method:

lookup-method是一种method-injection,这个属性使Spring克服当一个bena依赖其他不同生命周期的bean的情况。比如当一个单例的bean依赖一个非单例的bean。因为bean是单例的,只实例化一次,所以也就值setter了一次这个非单例的bean。这时使用

 <lookup-method bean=”原型bean的id” name=”方法名称”/>

属性即可解决上述问题。

replace-method:
<replaced-method name=”被替换的方法” replacer=”替换类,该类必须实现MethodReplacer接口”>
<arg-type></arg-type>//如果这个被替换的方法被重载了,那么必须写arg-type
    </replaced-method>

<arg-type match=”String”></arg-type>,这样才会被解析成一个为String类型的参数,而<arg-type>String</arg-type>这样只会被解析成拦截只有一个参数的某方法。

时间: 2024-10-16 12:12:45

【Spring源码--IOC容器的实现】(五)Bean对象的创建的相关文章

Spring源码学习-容器BeanFactory(一) BeanDefinition的创建-解析资源文件

写在前面 从大四实习至今已一年有余,作为一个程序员,一直没有用心去记录自己工作中遇到的问题,甚是惭愧,打算从今日起开始养成写博客的习惯.作为一名java开发人员,Spring是永远绕不过的话题,它的设计精巧,代码优美,值得每一名开发人员学习阅读. 在我最开始学习javaEE时,第一次接触Spring是从一个S(Struts)S(Spring)H(Herbinate)的框架开始.由java原生开发到框架开发转换过程中,那时我的印象里Struts负责控制层,herbinate负责数据层,而Sprin

Spring技术内幕——Spring Framework的IOC容器实现(五)(大结局)

这里通过使用BeanDefinitionResolver来对BeanDefinition进行解析,然后注入到property中.下面到BeanDefinitionValueResolver中看一下解析过程,以对Bean reference进行解析为例 /** * Resolve a reference to another bean in the factory. * class BeanDefinitionValueResolver */ private Object resolveRefer

Spring源码学习-容器BeanFactory(五) Bean的创建-探寻Bean的新生之路

写在前面 上面四篇文章讲了Spring是如何将配置文件一步一步转化为BeanDefinition的整个流程,下面就到了正式创建Bean对象实例的环节了,我们一起继续学习吧. 2.初始化Bean对象实例 Resource resource = new ClassPathResource("beanFactory.xml"); BeanFactory beanFactory = new XmlBeanFactory(resource); Student student = beanFact

【spring】spring源码阅读之xml读取、bean注入(BeanFactory)

前言 此源码其实是在4月中旬就看了,而且当初也写了一份word文档,但不打算直接把word发上来.还是跟着以前的笔记.跟踪代码边看边写吧. 其实当初看源码的理由很简单,1.才进新公司,比较有空闲.2.面试老是问spring的问题,我理论又不好,所以想看下. 但现在,我重新看的目的其实不在于其实现原理,而是想学习和写出好的编码风格.(当初大概花了1周看,记得那时把看到的都理解深刻了,但现在基本不记得什么了.毕竟开发用不到) 一.如何开始阅读源码? 最初我也一头雾水,不知道从哪开始看.怎么看.看源码

Spring源码系列 — BeanDefinition扩展点

前言 前文介绍了Spring Bean的生命周期,也算是XML IOC系列的完结.但是Spring的博大精深,还有很多盲点需要摸索.整合前面的系列文章,从Resource到BeanDefinition,再到容器扩展点,最后到Bean创键,这个过程中无处不存在Spring预留的扩展口. 本篇文章介绍Spring的另一种扩展点:BeanDefinition扩展点,该扩展点是为处理BeanDefinition而设计.本文主要从以下几点分析: BeanDefinition扩展点的几种方式 BeanDef

【spring源码分析】IOC容器初始化(总结)

前言:在经过前面十二篇文章的分析,对bean的加载流程大致梳理清楚了.因为内容过多,因此需要进行一个小总结. 经过前面十二篇文章的漫长分析,终于将xml配置文件中的bean,转换成我们实际所需要的真正的bean对象. 总结 [spring源码分析]IOC容器初始化(一):主要分析了Spring是如何解析占位符以及BeanFactory的最终实现类DefaultListableBeanFactory. [spring源码分析]IOC容器初始化(二):以loadBeanDefinitions函数为切

Ioc容器(3)-BeanPostProcessor-Spring 源码

Ioc容器BeanPostProcessor-Spring 源码(3) 目录: Ioc容器beanDefinition-Spring 源码(1) Ioc容器依赖注入-Spring 源码(2) Ioc容器BeanPostProcessor-Spring 源码(3) 如果这个接口的某个实现类被注册到某个容器,那么该容器的每个受管Bean在调用初始化方法之前,都会获得该接口实现类的一个回调.容器调用接口定义的方法时会将该受管Bean的实例和名字通过参数传入方法,进过处理后通过方法的返回值返回给容器.

Spring源码阅读:IOC容器的设计与实现(二)——ApplicationContext

上一主题中,了解了IOC容器的基本概念,以及BeanFactory的设计与实现方式,这里就来了解一下ApplicationContext方式的实现. ApplicationContext 在Spring的参考文档中,为啥要推荐使用ApplicationContext?它能给我们的应用带来什么好处呢?作为BeanFactory的实现之一,它又是如何设计的?在SpringMVC中使用的WebApplictionContext\XmlApplicationContext与之有何关联? Applicat

Spring 源码学习(二) IOC容器启动过程

这一节主要是记录一下Spring Ioc 容器的启动过程. Spring 的 Ioc 容器是怎么被加载和使用的? web容器为它提供了宿主环境 ServlectContext,  Tomcat 启动时会读取web.xml. 并且实例化web.xml中配置的ContextLoaderListener ,下面看一下ContextLoaderListener的创建过程: 在实例化ContextLoaderListener 之后,通过接口回调执行ContextLoaderListener 类中的cont