3.Spring之IoC基础

IoC容器的概念

IoC容器就是具有依赖注入功能的容器，IoC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。应用程序无需直接在代码中new相关的对象，应用程序由IoC容器进行组装。在Spring中BeanFactory是IoC容器的实际代表者。在以前都是使用BeanFactory，但是现在基本都是使用应用上下文。

依赖和依赖注入

Spring IoC容器的依赖有两层含义：Bean依赖容器和容器注入Bean的依赖资源

• Bean依赖容器：也就是说Bean要依赖于容器，这里的依赖是指容器负责创建Bean并管理Bean的生命周期，正是由于由容器来控制创建Bean并注入依赖，也就是控制权被反转了，这也正是IoC名字的由来，此处的有依赖是指Bean和容器之间的依赖关系。
• 容器注入Bean的依赖资源：容器负责注入Bean的依赖资源，依赖资源可以是Bean、外部文件、常量数据等，在Java中都反映为对象，并且由容器负责组装Bean之间的依赖关系，此处的依赖是指Bean之间的依赖关系，可以认为是传统类与类之间的“关联”、“聚合”、“组合”关系。

应用依赖注入的优点：

• 动态替换Bean依赖对象，程序更灵活：替换Bean依赖对象，无需修改源文件，应用依赖注入后，由于可以采用配置文件方式实现，从而能随时动态的替换Bean的依赖对象，无需修改java源文件；
• 更好实践面向接口编程，代码更清晰，在Bean中只需指定依赖对象的接口，接口定义依赖对象完成的功能，通过容器注入依赖实现；
• 更好实践优先使用对象组合，而不是类继承，因为IoC容器采用注入依赖，也就是组合对象，从而更好的实践对象组合。增加Bean可复用性：依赖于对象组合，Bean更可复用且复用更简单；

• 降低Bean之间耦合：由于我们完全采用面向接口编程，在代码中没有直接引用Bean依赖实现，全部引用接口，而且不会出现显示的创建依赖对象代码，而且这些依赖是由容器来注入，很容易替换依赖实现类，从而降低Bean与依赖之间耦合；
• 代码结构更清晰：要应用依赖注入，代码结构要按照规约方式进行书写，从而更好的应用一些最佳实践，因此代码结构更清晰。

详解IoC容器

Ioc容器的代表就是org.springframework.beans包中的BeanFactory接口，BeanFactory接口提供了IoC容器最基本功能；而org.springframework.context包下的ApplicationContext接口扩展BeanFactory，还提供了与Spring AOP集成、国际化处理、事件传播及提供不同层次的context实现(如针对web应用的WebApplicationContext)。简单说，BeanFactory提供了IoC容器最基本功能，而ApplicationContext则增加了更多支持企业级功能支持。ApplicationContext完全继承BeanFactory，因而BeanFactory所具有的语义也适用于ApplicationContext。

容器实现一览：

• XmlBeanFactory：BeanFactory实现，提供基本的IoC容器功能，可以从classpath或文件系统等获取资源；

（1）File file = new File("fileSystemConfig.xml");

Resource resource = new FileSystemResource(file);

BeanFactory beanFactory = new XmlBeanFactory(resource);

（2）Resource resource = new ClassPathResource("classpath.xml");

BeanFactory beanFactory = new XmlBeanFactory(resource);

• ClassPathXmlApplicationContext：最常使用的方式，从Classpath设置路径中读取XML定义文件。

BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath.xml");

• FileSystemXmlApplicationContext：通过指定XML定义文件的相对路径或绝对路径加载配置文件。

BeanFactory beanFactory = new FileSystemXmlApplicationContext("fileSystemConfig.xml");

• XmlWebApplicationContext：在web应用的文件架构中，指定相对位置来加载配置文件。

ApplicationContext接口获取Bean方法简介：

• Object getBean(String name)?根据名称返回一个Bean，客户端需要自己进行类型转换；

•T getBean(String name, Class<T> requiredType)根据名称和指定的类型返回一个Bean，客户端无需自己进行类型转换，如果类型转换失败，容器抛出异常；

•T getBean(Class<T> requiredType)根据指定的类型返回一个Bean，客户端无需自己进行类型转换，如果没有或有多于一个Bean存在容器将抛出异常；

•Map<String,T> getBeansOfType(Class<T> type)根据指定的类型返回一个键值为名字和值为Bean对象的Map，如果没有Bean对象存在则返回空的Map。

我们再以xml配置方式来分析一下IoC容器到底是如何工作的：

一、准备配置文件：在配置文件中声明Bean定义也就是为Bean配置元数据。

二、由IoC容器进行解析元数据： IoC容器的Bean Reader读取并解析配置文件，根据定义生成BeanDefinition配置元

数据对象，IoC容器根据BeanDefinition进行实例化、配置及组装Bean。

三、实例化IoC容器：由客户端实例化容器，获取需要的Bean。

IoC容器通过读取配置文件中的配置元数据，通过元数据对应用中的各个对象进行实例化及装配。一般使用基于xml配置文件进行配置元数据，而且Spring与配置文件完全解耦的，可以使用其他任何可能的方式进行配置元数据，比如注解、基于java文件的、基于属性文件的配置都可以。IoC容器管理的对象叫什么呢？这里我们引入另一个概念。

Bean的概念

由IoC容器管理的那些组成你应用程序的对象我们就叫它Bean，Bean就是由Spring容器初始化、装配及管理的对象，除此之外，bean就与应用程序中的其他对象没有什么区别了。那IoC怎样确定如何实例化Bean、管理Bean之间的依赖关系以及管理Bean呢？这就需要配置元数据，在Spring中由BeanDefinition代表。

Bean的生命周期

 

大体上看,任何处于 IoC 容器控制下的 JavaBean的生命周期都存在4个阶段：

• 实例化JavaBean。
• JavaBean实例的初始化,即通过 IoC注入其依赖性。这一阶段将完成 JavaBean 实例的初始化。
• 基于 Spring应用对 JavaBean实例的使用。
• Ioc容器销毁 JavaBean实例

 

Bean的配置

IoC容器目的就是管理Bean，这些Bean将根据配置文件中的Bean定义进行创建，而Bean定义在容器内部由BeanDefinition对象表示，该定义主要包含以下信息：

●全限定类名（FQN）：用于定义Bean的实现类;

●Bean行为定义：这些定义了Bean在容器中的行为；包括作用域（单例、原型创建）、是否

惰性初始化及生命周期等；

●Bean创建方式定义：说明是通过构造器还是工厂方法创建Bean；

●Bean之间关系定义：即对其他bean的引用，也就是依赖关系定义，这些引用bean也可以称之为同事bean或依赖bean，也就是依赖注入。

XML配置的结构

一般配置文件结构如下：

<beans>
<import resource=”resource1.xml”/>
<bean id=”bean1”class=””></bean>
<bean id=”bean2”class=””></bean>
<bean name=”bean2”class=””></bean>
<alias alias="bean3" name="bean2"/>
<import resource=”resource2.xml”/>
</beans>

1、<bean>标签主要用来进行Bean定义；

2、alias用于定义Bean别名；

3、import用于导入其他配置文件的Bean定义，这是为了加载多个配置文件，当然也可以把这些配置文件构造为一个数组（new String[] {“config1.xml”, config2.xml}）传给ApplicationContext实现进行加载多个配置文件，通常有多个Bean定义文件时，最好使用ApplicationContext的方式读取，好处是Bean定义文件之间是各自独立的；这两种方式都是通过调用Bean Definition Reader 读取Bean定义，内部实现没有任何区别。<import>标签可以放在<beans>下的任何位置，没有顺序关系。

4、每个Bean可以有一个或多个id（或称之为标识符或名字），我们把第一个id称为“标识符”，其余id叫做“别名”；这些id在IoC容器中必须唯一。通常有以下几种方式：

一、不指定id，只配置必须的全限定类名，由IoC容器为其生成一个标识，客户端必须通过接口 “T getBean(Class<T> requiredType)”获取Bean；

<bean class=”cn.spring.helloworld.HelloImpl”/>

二、指定id，必须在Ioc容器中唯一；

<bean id=”bean” class=” cn.spring.helloworld.HelloImpl”/>

三、指定name，这样name就是“标识符”，必须在Ioc容器中唯一；

<bean name=”bean” class=”cn.spring.helloworld.HelloImpl”/>

四、指定id和name，id就是标识符，而name就是别名，必须在Ioc容器中唯一；

<bean id=”bean1”name=”alias1” class=”cn.spring.helloworld.HelloImpl”/>

<!--如果id和name一样，IoC容器能检测到，并消除冲突-->

<bean id="bean3" name="bean3" class="cn.spring.helloworld.HelloImpl"/>

五、指定多个name，多个name用“，”、“；”、“ ”分割，第一个被用作标识符，其他的（alias1、alias2、alias3）是别名，所有标识符也必须在Ioc容器中唯一；

<bean name=”bean1;alias11,alias12;alias13 alias14” class=”cn.spring.helloworld.HelloImpl”/>

<!--当指定id时，name指定的标识符全部为别名-->

<bean id="bean2" name="alias21;alias22" class="cn.spring.helloworld.HelloImpl"/>

六、使用<alias>标签指定别名，别名也必须在IoC容器中唯一

<bean name="bean" class="cn.spring.helloworld.HelloImpl"/>

<alias alias="alias1" name="bean"/>

<alias alias="alias2" name="bean"/>

从命名方式来看，name或id如果指定它们中的一个时都作为“标识符”，那为什么还要同时指定id和name？原因就是当使用基于XML的配置元数据时，在XML中id是一个真正的XML id属性，因此当其他的定义来引用这个id时就体现出id的好处了——可以利用XML解析器来验证引用的这个id是否存在，从而更早的发现是否引用了一个不存在的bean，而使用name，则可能要在真正使用bean时才能发现引用一个不存在的bean。

实例化Bean

传统应用程序可以通过new和反射方式进行实例化Bean。而Spring IoC容器则需要根据Bean定义里的配置元数据使用反射机制来创建Bean。在Spring IoC容器中根据Bean定义创建Bean主要有以下几种方式：

一、使用构造器实例化Bean：这是最简单的方式，Spring IoC容器既能使用默认空构造器也能使用有参数构造器两种方式创建Bean，使用空构造器进行定义，使用此种方式，class属性指定的类必须有空构造器，使用有参数构造器进行定义，可以使用< constructor-arg >标签指定构造器参数值，构造器参数可以根据参数索引注入、参数类型注入或Spring3支持的参数名注入，但参数名注入是有限制的，需要使用在编译程序时打开调试模式（即在编译时使用“javac –g:vars”在class文件中生成变量调试信息，默认是不包含变量调试信息的，从而能获取参数名字，否则获取不到参数名字）

1.根据参数索引注入，使用标签“<constructor-arg index="1" value="1"/>”来指定注入的依赖，其中“index”表示索引，从0开始，即第一个参数索引为0，“value”来指定注入的常量值，配置方式如下：

2.根据参数类型进行注入，使用标签“<constructor-arg type="java.lang.String" value="Hello World!"/>”来指定注入的依赖，其中“type”表示需要匹配的参数类型，可以是基本类型也可以是其他类型，如“int”、“java.lang.String”，“value”来指定注入的常量值，配置方式如下：

3.根据参数名进行注入，使用标签“<constructor-arg name="message" value="Hello World!"/>”来指定注入的依赖，其中“name”表示需要匹配的参数名字，“value”来指定注入的常量值，配置方式如下：

二、使用静态工厂方式实例化Bean，使用这种方式除了指定必须的class属性，还要指定factory-method属性来指定实例化Bean的方法，而且使用静态工厂方法也允许指定方法参数，IoC容器将调用此属性指定的方法来获取Bean，例如instantiatingBean.xml：

<!-- 通过静态工厂参数索引方式依赖注入 -->
<bean id="byIndex" class="com.spring.di.DependencyInjectByStaticFactory" factory-method="newInstance">
    <constructor-arg index="0" value="Hello World!"/>
    <constructor-arg index="1" value="1"/>
</bean>
<!-- 通过静态工厂参数类型方式依赖注入 -->
<bean id="byType" class="com.spring.di.DependencyInjectByStaticFactory" factory-method="newInstance">
    <constructor-arg type="java.lang.String" value="Hello World!"/>
    <constructor-arg type="int" value="2"/>
</bean>
<!-- 通过静态工厂参数名称方式依赖注入 -->
<bean id="byName" class="com.spring.di.DependencyInjectByStaticFactory" factory-method="newInstance">
    <constructor-arg name="message" value="Hello World!"/>
    <constructor-arg name="index" value="3"/>
</bean>

静态工厂类如下

public static HelloApi newInstance(String message, int index) {
   return new HelloImpl3(message, index);
}

测试一下：

//使用静态工厂方法
BeanFactory beanFactory = new ClassPathXmlApplicationContext("di/staticFactoryDependencyInject.xml");
//获取根据参数索引依赖注入的Bean
HelloApi byIndex = beanFactory.getBean("byIndex", HelloApi.class);
byIndex.sayHello();
//获取根据参数类型依赖注入的Bean
HelloApi byType = beanFactory.getBean("byType", HelloApi.class);
byType.sayHello();
//获取根据参数名字依赖注入的Bean
HelloApi byName = beanFactory.getBean("byName", HelloApi.class);
byName.sayHello();

三、使用实例工厂方法实例化Bean，使用这种方式不能指定class属性，此时必须使用factory-bean属性来指定工厂Bean，factory-method属性指定实例化Bean的方法，而且使用实例工厂方法允许指定方法参数，方式和使用构造器方式一样

<bean id="instanceFactory" class="com.spring.di.DependencyInjectByInstanceFactory"/>
   <!-- 通过实例工厂参数索引方式依赖注入 -->
<bean id="byIndex" factory-bean="instanceFactory" factory-method="newInstance">
       <constructor-arg index="0" value="Hello World!"/>
    <constructor-arg index="1" value="1"/>
</bean> 
<!-- 通过实例工厂参数类型方式依赖注入 -->
<bean id="byType" factory-bean="instanceFactory" factory-method="newInstance">
   <constructor-arg type="java.lang.String" value="Hello World!"/>
   <constructor-arg type="int" value="2"/>
</bean> 
<!-- 通过实例工厂参数名称方式依赖注入 -->
<bean id="byName" factory-bean="instanceFactory" factory-method="newInstance">
   <constructor-arg name="message" value="Hello World!"/>
   <constructor-arg name="index" value="3"/>
</bean> 

测试代码和构造器方式完全一样，只是配置文件不一样，大家只需把测试文件改一下就可以了。还有一点需要大家注意就是静态工厂方式和实例工厂方式根据参数名字注入的方式只支持通过在class文件中添加“变量调试信息”方式才能运行，ConstructorProperties注解方式不能工作，它只对构造器方式起作用，不建议使用根据参数名进行构造器注入。

依赖注入的实现

在Spring中依赖注入的实现方式有两种：

1、有参构造器注入

使用有参数构造器进行定义，可以使用< constructor-arg >标签指定构造器参数值，构造器参数可以根据参数索引注入、参数类型注入或Spring3支持的参数名注入，但参数名注入是有限制的，需要使用在编译程序时打开调试模式（即在编译时使用“javac –g:vars”在class文件中生成变量调试信息，默认是不包含变量调试信息的，从而能获取参数名字，否则获取不到参数名字）

1.根据参数索引注入，使用标签“<constructor-arg index="1" value="1"/>”来指定注入的依赖，其中“index”表示索引，从0开始，即第一个参数索引为0，“value”来指定注入的常量值，配置方式如下：

 

2.根据参数类型进行注入，使用标签“<constructor-arg type="java.lang.String" value="Hello World!"/>”来指定注入的依赖，其中“type”表示需要匹配的参数类型，可以是基本类型也可以是其他类型，如“int”、“java.lang.String”，“value”来指定注入的常量值，配置方式如下：

3.根据参数名进行注入，使用标签“<constructor-arg name="message" value="Hello World!"/>”来指定注入的依赖，其中“name”表示需要匹配的参数名字，“value”来指定注入的常量值，配置方式如下：

2、setter注入方式

setter注入是通过在构造器、静态工厂或实例工厂实例好Bean后，通过调用Bean类的setter方法进行注入依赖，setter注入方式只有一种——根据setter名字进行注入

 

 

（1）写一个测试类HelloImpl4，包含两个setter方法，“setMessage”和“setIndex”

 

public class HelloImpl4 implements HelloApi {
    private String message;
    private int index;    
    //需要空的构造器
    public HelloImpl4() {
    }
    public void setMessage(String message) {
        this.message = message;
    }    
    public void setIndex(int index) {
        this.index = index;
    }   
    @Override
    public void sayHello() {
        System.out.println(index + ":" + message);
    }    
}

（2）配置Bean定义，具体配置如下：

 

<!-- 通过setter方式进行依赖注入 -->
<bean id="bean" class="com.spring.di.HelloImpl4">
    <property name="message" value="Hello World!"/>
    <property name="index" value="1"/>
</bean>

要让Spring知道setter方法，则方法名是要遵守约定的，setter注入的方法名要遵循“JavaBean getter/setter 方法命名约定”：

JavaBean：本质就是一个POJO类，但具有以下限制：

该类必须要有公共的无参构造器，如public HelloImpl4() {}；

属性为private访问级别，不建议public，如private String message;

属性必要时通过一组setter（修改器）和getter（访问器）方法来访问；

setter方法，以“set” 开头，后跟首字母大写的属性名，如“setMesssage”,简单属性一般只有一个方法参数，方法返回值通常为“void”;

getter方法，一般属性以“get”开头，对于boolean类型一般以“is”开头，后跟首字母大写的属性名，如

“getMesssage”，“isOk”；

还有一些其他特殊情况，比如属性有连续两个大写字母开头，如“URL”,则setter/getter方为：“setURL”

和“getURL”，其他一些特殊情况请参看“Java Bean”命名规范。

注入常量

注入常量是依赖注入中最简单的。配置方式如下所示：

<property name="message" value="Hello World!"/>

或

<property name="index"><value>1</value></property>

以上两种方式都可以，从配置来看第一种更简洁。注意此处“value”中指定的全是字符串，由Spring容器将此字符串转换成属性所需要的类型，如果转换出错，将抛出相应的异常。

Spring容器目前能对各种基本类型把配置的String参数转换为需要的类型。

注：Spring类型转换系统对于boolean类型进行了容错处理，除了可以使用“true/false”标准的Java值进行注入，还能使用“yes/no”、“on/off”、“1/0”来代表“真/假”，所以大家在学习或工作中遇到这种类似问题不要觉得是人家配置错了，而是Spring容错做的非常好。

注入Bean ID

用于注入Bean的ID，ID是一个常量不是引用，且类似于注入常量，但提供错误验证功能，首先来看下官方文档上给出的两个例子： 

第一个：

<bean id="theTargetBean" class="..."/>
<bean id="theClientBean" class="...">
    <property name="targetName">
        <idref bean="theTargetBean" />
    </property>
</bean>

第二个：

<bean id="theTargetBean" class="..." />
<bean id="client" class="...">
    <property name="targetName" value="theTargetBean" />
</bean>

官方的说明：The above bean definition snippet is exactly equivalent (at runtime) to the following snippet（大概意思：这两个片段配置是等价的在运行的时候）.从第二个例子可以看出来targetName注入的是“theTargetBean”字符串。那么idref的作用是什么？同样看下官方给出的说明：The idref element is simply an error-proof way to pass the id (string value - not a reference) of another bean in the container to a or element.（通过或者注入bean的时候通过idref来检查注入的bean是否在容器中的一种检查错误的方式）。

<bean id="theTargetBean" class="..."/>
<bean id="theClientBean" class="...">
    <property name="targetName">
        <ref bean="theTargetBean" />
    </property>
</bean>

然而如果是ref标签那么就是注入”theTargetBean”实例。 两者的区别就是ref注入的是bean的实例，

idref注入的是string。<ref>提供了如下几方面的属性 ：

• bean:在当前 Spring XML 配置文件中,或者在同一 BeanFactory(ApplicationContext)中的其他 JavaBean中 。
• local:在当前 Spring XML配置文件中。其依赖的 JavaBean必须存在于当前 Spring XML配置文件中。如果借助于 Spring IDE,则在编译期可对其依赖的 Java进行验证。基于local方式,开发者能够使用到 XML本身提供的优势,而进行验证。
• parent:用于指定其依赖的父JavaBean定义。

注入集合、数组和字典

Spring不仅能注入简单类型数据，还能注入集合（Collection、无序集合Set、有序集合List）类型、数组(Array)类型、字典(Map)类型数据、Properties类型数据，接下来就让我们一个个看看如何注入这些数据类型的数据。

一、注入集合类型：包括Collection类型、Set类型、List类型数据：

（1）List类型：需要使用<list>标签来配置注入，“value-type”属性（可选），表示列表中条目的数据类型，默认为String类型，也可以使用泛型，Spring能根据泛型数据自动检测到List的数据类型

（2）Set类型：需要使用<set>标签来配置注入，其配置参数及含义和<lsit>标签完全一样

（3）Collection类型：因为Collection类型是Set和List类型的基类型，所以使用<set>或<list>标签都可以进行注入，配置方式完全和以上配置方式一样，只是将测试类属性改成“Collection”类型

二、注入数组类型：需要使用<array>标签来配置注入，其中标签属性“value-type”和“merge”和<list>标签含义完全一样，具体配置如下

<bean id="arrayBean" class="com.spring.di.bean.ArrayTestBean">
    <property name="array">
        <!--一维数组注入-->
        <array value-type="java.lang.String" merge="default">
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </array>
    </property>
    
    <property name="array2">
        <!--二维数组注入-->
        <array>
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
            <array>
                <value>4</value>
                <value>5</value>
                <value>6</value>
            </array>
        </array>
        
    </property>
</bean>

三、注入字典（Map）类型：字典类型是包含键值对数据的数据结构，需要使用<map>标签来配置注入，其属性“key-type”和“value-type”分别指定“键”和“值”的数据类型，其含义和<list>标签的“value-type”含义一样，并使用<key>子标签来指定键数据，<value>子标签来指定键对应的值数据

四、Properties注入：Spring能注入java.util.Properties类型数据，需要使用<props>标签来配置注入，键和值类型必须是String，子标签<prop key=”键”>值</prop>来指定键值对，具体配置如下：

<bean id="propertiesBean" class="com.spring.di.bean.PropertiesTestBean">
    <property name="values">
        <!--value-type属性并不起作用，Prpperties键和值全是String类型-->
        <props value-type="int" merge="default">
            <prop key="1">12sw</prop>
            <prop key="2">2</prop>
        </props>
    </property>
</bean>

<bean id="propertiesBean2" class="com.spring.di.bean.PropertiesTestBean">
    <property name="values">
        <!--分隔符可以是“换行”、“;”、“,”，推荐使用第一种方式-->
        <value>
           1=11
           2=22,
           3=33;
           4=44
        </value>   
    </property>
</bean>

引用其它Bean

上面已经介绍了注入常量、集合等基本数据类型和集合数据类型，接下来将介绍注入依赖Bean及注入内部Bean。

引用其他Bean的步骤与注入常量的步骤一样，可以通过构造器注入及setter注入引用其他Bean，只是引用其他Bean的注入配置稍微变化了一下：可以将“<constructor-arg index="0" value="Hello World!"/>”和“<property name="message" value="Hello World!"/>”中的value属性替换成bean属性，其中bean属性指定配置文件中的其他Bean的id或别名。另一种是把<value>标签替换为<ref bean=”beanName”>，bean属性也是指定配置文件中的其他Bean的id或别名。

一、构造器注入方式：

（1）通过” <constructor-arg>”标签的ref属性来引用其他Bean，这是最简化的配置

（2）通过” <constructor-arg>”标签的子<ref>标签来引用其他Bean，使用bean属性来指定引用的Bean

二、setter注入方式：

（1）通过” <property>”标签的ref属性来引用其他Bean，这是最简化的配置

（2）通过” <property>”标签的子<ref>标签来引用其他Bean，使用bean属性来指定引用的Bean

三、其他引用方式：除了最基本配置方式以外，Spring还提供了更高级的配置方式<ref parent=””/>：

用于引用父容器中的Bean，不会引用当前容器中的Bean，当然父容器中的Bean和当前容器的Bean是可以重名的，获取顺序是先查找当前容器中的Bean，如果找不到再从父容器找。下面写两个配置文件

parentBeanInject.xml

<!--注意此处可能子容器也定义一个该Bean-->
<bean id="helloApi" class="com.spring.di.HelloImpl4">
    <property name="index" value="1"/>
    <property name="message" value="Hello Parent!"/>
</bean>

childBeanInject.xml

<!-- 注意父容器中也定义了id 为 helloApi的Bean -->

<!-- 注意父容器中也定义了id 为 helloApi的Bean -->
<bean id="helloApi" class="com.spring.di.HelloImpl4">
    <property name="index" value="2"/>
    <property name="message" value="Hello Local!"/>
</bean>
<!-- 通过parent注入 -->
<bean id="bean1" class="com.spring.di.bean.HelloApiDecorator">
    <property name="helloApi"><ref parent="helloApi"/></property>
</bean>

内部Bean定义

内部Bean就是在<property>或<constructor-arg>内通过<bean>标签定义的Bean，该Bean不管是否指定id或name，该Bean都会有唯一的匿名标识符，而且不能指定别名，该内部Bean对其他外部Bean不可见

处理null值

Spring通过<value>标签或value属性注入常量值，所有注入的数据都是字符串。所以Spring通过<null/>标签注入null值。

对象图导航注入支持

所谓对象图导航是指类似a.b.c这种点缀访问形式的访问或修改值。Spring支持对象图导航方式依赖注入。对象图导航依赖注入有一个限制就是比如a.b.c对象导航图注入中a和b必须为非null值才能注入c，否则将抛出空指针异常。

Spring不仅支持对象的导航，还支持数组、列表、字典、Properties数据类型的导航，对Set数据类型无法支持，因为无法导航。

数组和列表数据类型可以用array[0]、list[1]导航，注意”[]”里的必须是数字，因为是按照索引进行导航，对于数组类型注意不要数组越界错误。

字典Map数据类型可以使用map[1]、map[str]进行导航，其中“[]”里的是基本类型，无法放置引用类型

 

参考：

http://sishuok.com/forum/blogPost/list/2427.html

https://www.cnblogs.com/softidea/p/5815785.html

http://sishuok.com/forum/blogPost/list/2447.html

http://blog.csdn.net/ljbmxsm/article/details/50408886

http://blog.csdn.net/z69183787/article/details/8222103

https://www.cnblogs.com/caoyc/p/5622986.html