Java面试Spring源码分析 —— Spring IoC

Posted 醉恋学Java

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java面试Spring源码分析 —— Spring IoC相关的知识,希望对你有一定的参考价值。

 9、XmlBeanDefinitionReader解析载入的Bean定义资源文件:

 XmlBeanDefinitionReader类中的doLoadBeanDefinitions方法是从特定XML文件中实际载入Bean定义资源的方法,该方法在载入Bean定义资源之后将其转换为Document对象,接下来调用registerBeanDefinitions启动Spring IoC容器对Bean定义的解析过程,registerBeanDefinitions方法源码如下:

1    //按照Spring的Bean语义要求将Bean定义资源解析并转换为容器内部数据结构 
2    public int registerBeanDefinitions(Document doc, Resource resource)
throws BeanDefinitionStoreException {   3   //得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析
4   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();   5     //获得容器中注册的Bean数量
6     int countBefore = getRegistry().getBeanDefinitionCount();   7     //解析过程入口,这里使用了委派模式,BeanDefinitionDocumentReader只是个接口,
//具体的解析实现过程有实现类DefaultBeanDefinitionDocumentReader完成
8     documentReader.registerBeanDefinitions(doc, createReaderContext(resource));   9    //统计解析的Bean数量  
10    return getRegistry().getBeanDefinitionCount() - countBefore;   11  }   12   //创建BeanDefinitionDocumentReader对象,解析Document对象
13   protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {   14        return BeanDefinitionDocumentReader.class.cast(
BeanUtils.instantiateClass(this.documentReaderClass));   } 

Bean定义资源的载入解析分为以下两个过程:

首先,通过调用XML解析器将Bean定义资源文件转换得到Document对象,但是这些Document对象并没有按照Spring的Bean规则进行解析。这一步是载入的过程

其次,在完成通用的XML解析之后,按照Spring的Bean规则对Document对象进行解析。

按照Spring的Bean规则对Document对象解析的过程是在接口BeanDefinitionDocumentReader的实现DefaultBeanDefinitionDocumentReader中实现的。

10、DefaultBeanDefinitionDocumentReader对Bean定义的Document对象解析: 

BeanDefinitionDocumentReader接口通过registerBeanDefinitions方法调用其实现类DefaultBeanDefinitionDocumentReader对Document对象进行解析,解析的代码如下:

1     //根据Spring DTD对Bean的定义规则解析Bean定义Document对象 
2     public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {   3         //获得XML描述符
4         this.readerContext = readerContext;   5         logger.debug("Loading bean definitions");   6         //获得Document的根元素
7         Element root = doc.getDocumentElement();   8         //具体的解析过程由BeanDefinitionParserDelegate实现,
9         //BeanDefinitionParserDelegate中定义了Spring Bean定义XML文件的各种元素
10        BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);   11        //在解析Bean定义之前,进行自定义的解析,增强解析过程的可扩展性
12        preProcessXml(root);   13        //从Document的根元素开始进行Bean定义的Document对象
14        parseBeanDefinitions(root, delegate);   15        //在解析Bean定义之后,进行自定义的解析,增加解析过程的可扩展性
16        postProcessXml(root);   17    }   18    //创建BeanDefinitionParserDelegate,用于完成真正的解析过程
19    protected BeanDefinitionParserDelegate createHelper(XmlReaderContext readerContext, Element root) {   20        BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);   21        //BeanDefinitionParserDelegate初始化Document根元素
22        delegate.initDefaults(root);   23        return delegate;   24    }   25    //使用Spring的Bean规则从Document的根元素开始进行Bean定义的Document对象
26    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {   27        //Bean定义的Document对象使用了Spring默认的XML命名空间
28        if (delegate.isDefaultNamespace(root)) {   29            //获取Bean定义的Document对象根元素的所有子节点
30            NodeList nl = root.getChildNodes();   31            for (int i = 0; i < nl.getLength(); i++) {   32                Node node = nl.item(i);   33                //获得Document节点是XML元素节点
34                if (node instanceof Element) {   35                    Element ele = (Element) node;   36                //Bean定义的Document的元素节点使用的是Spring默认的XML命名空间
37                    if (delegate.isDefaultNamespace(ele)) {   38                        //使用Spring的Bean规则解析元素节点
39                        parseDefaultElement(ele, delegate);   40                    }   41                    else {   42                        //没有使用Spring默认的XML命名空间,则使用用户自定义的解
//析规则解析元素节点
43                        delegate.parseCustomElement(ele);   44                    }   45                }   46            }   47        }   48        else {   49            //Document的根节点没有使用Spring默认的命名空间,则使用用户自定义的
50            //解析规则解析Document根节点
51            delegate.parseCustomElement(root);   52        }   53    }   54    //使用Spring的Bean规则解析Document元素节点
55    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {   56        //如果元素节点是<Import>导入元素,进行导入解析
57        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {   58            importBeanDefinitionResource(ele);   59        }   60        //如果元素节点是<Alias>别名元素,进行别名解析
61        else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {   62            processAliasRegistration(ele);   63        }   64        //元素节点既不是导入元素,也不是别名元素,即普通的<Bean>元素,
65        //按照Spring的Bean规则解析元素
66        else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {   67            processBeanDefinition(ele, delegate);   68        }   69    }   70    //解析<Import>导入元素,从给定的导入路径加载Bean定义资源到Spring IoC容器中
71    protected void importBeanDefinitionResource(Element ele) {   72        //获取给定的导入元素的location属性
73        String location = ele.getAttribute(RESOURCE_ATTRIBUTE);   74        //如果导入元素的location属性值为空,则没有导入任何资源,直接返回
75        if (!StringUtils.hasText(location)) {   76            getReaderContext().error("Resource location must not be empty", ele);   77            return;   78        }   79        //使用系统变量值解析location属性值
80        location = SystemPropertyUtils.resolvePlaceholders(location);   81        Set<Resource> actualResources = new LinkedHashSet<Resource>(4);   82        //标识给定的导入元素的location是否是绝对路径
83        boolean absoluteLocation = false;   84        try {   85            absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();   86        }   87        catch (URISyntaxException ex) {   88            //给定的导入元素的location不是绝对路径
89        }   90        //给定的导入元素的location是绝对路径
91        if (absoluteLocation) {   92            try {   93                //使用资源读入器加载给定路径的Bean定义资源
94                int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);   95                if (logger.isDebugEnabled()) {   96                    logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");   97                }   98            }   99            catch (BeanDefinitionStoreException ex) {   100                getReaderContext().error(   101                        "Failed to import bean definitions from URL location [" + location + "]", ele, ex);   102            }   103        }   104        else {   105            //给定的导入元素的location是相对路径
106            try {   107                int importCount;   108                //将给定导入元素的location封装为相对路径资源
109                Resource relativeResource = getReaderContext().getResource().createRelative(location);   110                //封装的相对路径资源存在
111                if (relativeResource.exists()) {   112                    //使用资源读入器加载Bean定义资源  113                    importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);   114                    actualResources.add(relativeResource);   115                }   116                //封装的相对路径资源不存在
117                else {   118                    //获取Spring IoC容器资源读入器的基本路径
119                    String baseLocation = getReaderContext().getResource().getURL().toString();   120                    //根据Spring IoC容器资源读入器的基本路径加载给定导入
121                    //路径的资源
122                    importCount = getReaderContext().getReader().loadBeanDefinitions(   123                            StringUtils.applyRelativePath(baseLocation, location), actualResources);   124                }   125                if (logger.isDebugEnabled()) {   126                    logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");   127                }   128            }   129            catch (IOException ex) {   130                getReaderContext().error("Failed to resolve current resource location", ele, ex);   131            }   132            catch (BeanDefinitionStoreException ex) {   133                getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",   134                        ele, ex);   135            }   136        }   137        Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);   138        //在解析完<Import>元素之后,发送容器导入其他资源处理完成事件
139        getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));   140    }   141    //解析<Alias>别名元素,为Bean向Spring IoC容器注册别名
142    protected void processAliasRegistration(Element ele) {   143        //获取<Alias>别名元素中name的属性值
144        String name = ele.getAttribute(NAME_ATTRIBUTE);   145        //获取<Alias>别名元素中alias的属性值
146        String alias = ele.getAttribute(ALIAS_ATTRIBUTE);   147        boolean valid = true;   148        //<alias>别名元素的name属性值为空
149        if (!StringUtils.hasText(name)) {   150            getReaderContext().error("Name must not be empty", ele);   151            valid = false;   152        }   153        //<alias>别名元素的alias属性值为空
154        if (!StringUtils.hasText(alias)) {   155            getReaderContext().error("Alias must not be empty", ele);   156            valid = false;   157        }   158        if (valid) {   159            try {   160                //向容器的资源读入器注册别名
161                getReaderContext().getRegistry().registerAlias(name, alias);   162            }   163            catch (Exception ex) {   164                getReaderContext().error("Failed to register alias '" + alias +   165                        "' for bean with name '" + name + "'", ele, ex);   166            }   167            //在解析完<Alias>元素之后,发送容器别名处理完成事件
168            getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));   169        }   170    }   171    //解析Bean定义资源Document对象的普通元素
172    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {   173        // BeanDefinitionHolder是对BeanDefinition的封装,即Bean定义的封装类  174        //对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现  BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);  175        if (bdHolder != null) {   176            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);   177            try {   178               //向Spring IoC容器注册解析得到的Bean定义,
//这是Bean定义向IoC容器注册的入口            
                 BeanDefinitionReaderUtils.registerBeanDefinition(
                 bdHolder, getReaderContext().getRegistry());
179 }   180            catch (BeanDefinitionStoreException ex) {   181                getReaderContext().error(
"Failed to register bean definition with name '" +   182                        bdHolder.getBeanName() + "'", ele, ex);   183            }   184            //在完成向Spring IoC容器注册解析得到的Bean定义之后,发送注册事件
185            getReaderContext().fireComponentRegistered(
new BeanComponentDefinition(bdHolder));   186        }   187    }

通过上述Spring IoC容器对载入的Bean定义Document解析可以看出,我们使用Spring时,在Spring配置文件中可以使用<Import>元素来导入IoC容器所需要的其他资源,Spring IoC容器在解析时会首先将指定导入的资源加载进容器中。使用<Ailas>别名时,Spring IoC容器首先将别名元素所定义的别名注册到容器中。

对于既不是<Import>元素,又不是<Alias>元素的元素,即Spring配置文件中普通的<Bean>元素的解析由BeanDefinitionParserDelegate类的parseBeanDefinitionElement方法来实现。


11、BeanDefinitionParserDelegate解析Bean定义资源文件中的<Bean>元素:

Bean定义资源文件中的<Import>和<Alias>元素解析在DefaultBeanDefinitionDocumentReader中已经完成,对Bean定义资源文件中使用最多的<Bean>元素交由BeanDefinitionParserDelegate来解析,其解析实现的源码如下:


1    //解析<Bean>元素的入口  2    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {  
3        return parseBeanDefinitionElement(ele, null);  
4    }  
5    //解析Bean定义资源文件中的<Bean>元素,这个方法中主要处理<Bean>元素的id,name  6    //和别名属性  7    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
8        //获取<Bean>元素中的id属性值  9        String id = ele.getAttribute(ID_ATTRIBUTE);  
10        //获取<Bean>元素中的name属性值  11        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
12        ////获取<Bean>元素中的alias属性值  13        List<String> aliases = new ArrayList<String>();  
14        //将<Bean>元素中的所有name属性值存放到别名中  15        if (StringUtils.hasLength(nameAttr)) {  
16            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS);  
17            aliases.addAll(Arrays.asList(nameArr));  
18        }  
19        String beanName = id;  
20        //如果<Bean>元素中没有配置id属性时,将别名中的第一个值赋值给beanName  21        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {  
22            beanName = aliases.remove(0);  
23            if (logger.isDebugEnabled()) {  
24                logger.debug("No XML 'id' specified - using '" + beanName +  
25                        "' as bean name and " + aliases + " as aliases");  
26            }  
27        }  
28        //检查<Bean>元素所配置的id或者name的唯一性,containingBean标识<Bean>  29        //元素中是否包含子<Bean>元素  30        if (containingBean == null) {  
31            //检查<Bean>元素所配置的id、name或者别名是否重复  32            checkNameUniqueness(beanName, aliases, ele);  
33        }  
34        //详细对<Bean>元素中配置的Bean定义进行解析的地方  35        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);  
36        if (beanDefinition != null) {  
37            if (!StringUtils.hasText(beanName)) {  
38                try {  
39                    if (containingBean != null) {  
40                        //如果<Bean>元素中没有配置id、别名或者name,且没有包含子//<Bean>元素,为解析的Bean生成一个唯一beanName并注册  41                        beanName = BeanDefinitionReaderUtils.generateBeanName(  
42                                beanDefinition, this.readerContext.getRegistry(), true);  
43                    }  
44                    else {  
45                        //如果<Bean>元素中没有配置id、别名或者name,且包含了子//<Bean>元素,为解析的Bean使用别名向IoC容器注册  46                        beanName = this.readerContext.generateBeanName(beanDefinition);  
47                        //为解析的Bean使用别名注册时,为了向后兼容                                    //Spring1.2/2.0,给别名添加类名后缀  48                        String beanClassName = beanDefinition.getBeanClassName();  
49                        if (beanClassName != null &&  
50                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&  
51                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {  
52                            aliases.add(beanClassName);  
53                        }  
54                    }  
55                    if (logger.isDebugEnabled()) {  
56                        logger.debug("Neither XML 'id' nor 'name' specified - " +  
57                                "using generated bean name [" + beanName + "]");  
58                    }  
59                }  
60                catch (Exception ex) {  
61                    error(ex.getMessage(), ele);  
62                    return null;  
63                }  
64            }  
65            String[] aliasesArray = StringUtils.toStringArray(aliases);  
66            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);  
67        }  
68        //当解析出错时,返回null  69        return null;  
70    }  
71    //详细对<Bean>元素中配置的Bean定义其他属性进行解析,由于上面的方法中已经对//Bean的id、name和别名等属性进行了处理,该方法中主要处理除这三个以外的其他属性数据  72    public AbstractBeanDefinition parseBeanDefinitionElement(  
73            Element ele, String beanName, BeanDefinition containingBean) {  
74        //记录解析的<Bean>  75        this.parseState.push(new BeanEntry(beanName));  
76        //这里只读取<Bean>元素中配置的class名字,然后载入到BeanDefinition中去  77        //只是记录配置的class名字,不做实例化,对象的实例化在依赖注入时完成  78        String className = null;  
79        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {  
80            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();  
81        }  
82        try {  
83            String parent = null;  
84            //如果<Bean>元素中配置了parent属性,则获取parent属性的值  85            if (ele.hasAttribute(PARENT_ATTRIBUTE)) {  
86                parent = ele.getAttribute(PARENT_ATTRIBUTE);  
87            }  
88            //根据<Bean>元素配置的class名称和parent属性值创建BeanDefinition  89            //为载入Bean定义信息做准备  90            AbstractBeanDefinition bd = createBeanDefinition(className, parent);  
91            //对当前的<Bean>元素中配置的一些属性进行解析和设置,如配置的单态(singleton)属性等  92            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);  
93            //为<Bean>元素解析的Bean设置description信息 bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));  94            //对<Bean>元素的meta(元信息)属性解析  95            parseMetaElements(ele, bd);  
96            //对<Bean>元素的lookup-method属性解析  97            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());  
98            //对<Bean>元素的replaced-method属性解析  99            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());  
100            //解析<Bean>元素的构造方法设置  101            parseConstructorArgElements(ele, bd);  
102            //解析<Bean>元素的<property>设置  103            parsePropertyElements(ele, bd);  
104            //解析<Bean>元素的qualifier属性  105            parseQualifierElements(ele, bd);  
106            //为当前解析的Bean设置所需的资源和依赖对象  107            bd.setResource(this.readerContext.getResource());  
108            bd.setSource(extractSource(ele));  
109            return bd;  
110        }  
111        catch (ClassNotFoundException ex) {  
112            error("Bean class [" + className + "] not found", ele, ex);  
113        }  
114        catch (NoClassDefFoundError err) {  
115            error("Class that bean class [" + className + "] depends on not found", ele, err);  
116        }  
117        catch (Throwable ex) {  
118            error("Unexpected failure during bean definition parsing", ele, ex);  
119        }  
120        finally {  
121            this.parseState.pop();  
122        }  
123        //解析<Bean>元素出错时,返回null  124        return null;  
125    } 

只要使用过Spring,对Spring配置文件比较熟悉的人,通过对上述源码的分析,就会明白我们在Spring配置文件中<Bean>元素的中配置的属性就是通过该方法解析和设置到Bean中去的。

注意:在解析<Bean>元素过程中没有创建和实例化Bean对象,只是创建了Bean对象的定义类BeanDefinition,将<Bean>元素中的配置信息设置到BeanDefinition中作为记录,当依赖注入时才使用这些记录信息创建和实例化具体的Bean对象。 

上面方法中一些对一些配置如元信息(meta)、qualifier等的解析,我们在Spring中配置时使用的也不多,我们在使用Spring的<Bean>元素时,配置最多的是<property>属性,因此我们下面继续分析源码,了解Bean的属性在解析时是如何设置的。

12、BeanDefinitionParserDelegate解析<property>元素:

BeanDefinitionParserDelegate在解析<Bean>调用parsePropertyElements方法解析<Bean>元素中的<property>属性子元素,解析源码如下:


1    //解析<Bean>元素中的<property>子元素  2    public void parsePropertyElements(Element beanEle, BeanDefinition bd) {  
3        //获取<Bean>元素中所有的子元素  4        NodeList nl = beanEle.getChildNodes();  
5        for (int i = 0; i < nl.getLength(); i++) {  
6            Node node = nl.item(i);  
7            //如果子元素是<property>子元素,则调用解析<property>子元素方法解析  8            if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {  
9                parsePropertyElement((Element) node, bd);  
10            }  
11        }  
12    }  
13    //解析<property>元素  14    public void parsePropertyElement(Element ele, BeanDefinition bd) {  
15        //获取<property>元素的名字   16        String propertyName = ele.getAttribute(NAME_ATTRIBUTE);  
17        if (!StringUtils.hasLength(propertyName)) {  
18            error("Tag 'property' must have a 'name' attribute", ele);  
19            return;  
20        }  
21        this.parseState.push(new PropertyEntry(propertyName));  
22        try {  
23            //如果一个Bean中已经有同名的property存在,则不进行解析,直接返回。  24            //即如果在同一个Bean中配置同名的property,则只有第一个起作用  25            if (bd.getPropertyValues().contains(propertyName)) {  
26                error("Multiple 'property' definitions for property '" + propertyName + "'", ele);  
27                return;  
28            }  
29            //解析获取property的值  30            Object val = parsePropertyValue(ele, bd, propertyName);  
31            //根据property的名字和值创建property实例  32            PropertyValue pv = new PropertyValue(propertyName, val);  
33            //解析<property>元素中的属性  34            parseMetaElements(ele, pv);  
35            pv.setSource(extractSource(ele));  
36            bd.getPropertyValues().addPropertyValue(pv);  
37        }  
38        finally {  
39            this.parseState.pop();  
40        }  
41    }  
42    //解析获取property值  43    public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {  
44        String elementName = (propertyName != null) ?  
45                        "<property> element for property '" + propertyName + "'" :  
46                        "<constructor-arg> element";  
47        //获取<property>的所有子元素,只能是其中一种类型:ref,value,list等  48        NodeList nl = ele.getChildNodes();  
49        Element subElement = null;  
50        for (int i = 0; i < nl.getLength(); i++) {  
51            Node node = nl.item(i);  
52            //子元素不是description和meta属性  53            if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&  
54                    !nodeNameEquals(node, META_ELEMENT)) {  
55                if (subElement != null) {  
56                    error(elementName + " must not contain more than one sub-element", ele);  
57                }  
58                else {//当前<property>元素包含有子元素  59                    subElement = (Element) node;  
60                }  
61            }  
62        }  
63        //判断property的属性值是ref还是value,不允许既是ref又是value  64        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);  
65        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);  
66        if ((hasRefAttribute && hasValueAttribute) ||  
67                ((hasRefAttribute || hasValueAttribute) && subElement != null)) {  
68            error(elementName +  
69                    " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);  
70        }  
71        //如果属性是ref,创建一个ref的数据对象RuntimeBeanReference,这个对象  72        //封装了ref信息  73        if (hasRefAttribute) {  
74            String refName = ele.getAttribute(REF_ATTRIBUTE);  
75            if (!StringUtils.hasText(refName)) {  
76                error(elementName + " contains empty 'ref' attribute", ele);  
77            }  
78            //一个指向运行时所依赖对象的引用  79            RuntimeBeanReference ref = new RuntimeBeanReference(refName);  
80            //设置这个ref的数据对象是被当前的property对象所引用  81            ref.setSource(extractSource(ele));  
82            return ref;  
83        }  
84         //如果属性是value,创建一个value的数据对象TypedStringValue,这个对象  85        //封装了value信息  86        else if (hasValueAttribute) {  
87            //一个持有String类型值的对象  88            TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));  
89            //设置这个value数据对象是被当前的property对象所引用  90            valueHolder.setSource(extractSource(ele));  
91            return valueHolder;  
92        }  
93        //如果当前<property>元素还有子元素  94        else if (subElement != null) {  
95            //解析<property>的子元素  96            return parsePropertySubElement(subElement, bd);  
97        }  
98        else {  
99            //propery属性中既不是ref,也不是value属性,解析出错返回null        error(elementName + " must specify a ref or value", ele);  100            return null;  
101        }  
    } 

通过对上述源码的分析,我们可以了解在Spring配置文件中,<Bean>元素中<property>元素的相关配置是如何处理的:

a. ref被封装为指向依赖对象一个引用。 

b.value配置都会封装成一个字符串类型的对象。

c.ref和value都通过“解析的数据类型属性值.setSource(extractSource(ele));”方法将属性值/引用与所引用的属性关联起来。

在方法的最后对于<property>元素的子元素通过parsePropertySubElement 方法解析,我们继续分析该方法的源码,了解其解析过程。

以上是关于Java面试Spring源码分析 —— Spring IoC的主要内容,如果未能解决你的问题,请参考以下文章

Java面试Spring源码分析 —— Spring IoC

Java面试Spring源码分析 —— Spring IoC

Java面试Spring源码分析 —— Spring IoC

Spring源码分析专题——目录

详解Spring mvc工作原理及源码分析

【面试题解析】从 Vue 源码分析 key 的作用