开涛spring3(3.1) - DI的配置使用

3.1.1  依赖和依赖注入

       传统应用程序设计中所说的依赖一般指“类之间的关系”，那先让我们复习一下类之间的关系：

     泛化：表示类与类之间的继承关系、接口与接口之间的继承关系；

     实现：表示类对接口的实现；

     依赖：当类与类之间有使用关系时就属于依赖关系，不同于关联关系，依赖不具有“拥有关系”，而是一种“相识关系”，只在某个特定地方（比如某个方法体内）才有关系。

     关联：表示类与类或类与接口之间的依赖关系，表现为“拥有关系”；具体到代码可以用实例变量来表示；

     聚合：属于是关联的特殊情况，体现部分-整体关系，是一种弱拥有关系；整体和部分可以有不一样的生命周期；是一种弱关联；

     组合：属于是关联的特殊情况，也体现了体现部分-整体关系，是一种强“拥有关系”；整体与部分有相同的生命周期，是一种强关联；

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，从而改变Bean功能；
• 而如果采用类继承，Bean没有依赖Bean，而是采用继承方式添加新功能，，而且功能是在编译时就确定了，不具有动态性，而且采用类继承导致Bean与子Bean之间高度耦合，难以复用。

     增加Bean可复用性：依赖于对象组合，Bean更可复用且复用更简单；

     降低Bean之间耦合：由于我们完全采用面向接口编程，在代码中没有直接引用Bean依赖实现，全部引用接口，而且不会出现显示的创建依赖对象代码，而且这些依赖是由容器来注入，很容易替换依赖实现类，从而降低Bean与依赖之间耦合；

     代码结构更清晰：要应用依赖注入，代码结构要按照规约方式进行书写，从而更好的应用一些最佳实践，因此代码结构更清晰。

 

从以上我们可以看出，其实依赖注入只是一种装配对象的手段，设计的类结构才是基础，如果设计的类结构不支持依赖注入，Spring IoC容器也注入不了任何东西，从而从根本上说“如何设计好类结构才是关键，依赖注入只是一种装配对象手段”。

前边IoC一章我们已经了解了Bean依赖容器，那容器如何注入Bean的依赖资源，Spring IoC容器注入依赖资源主要有以下两种基本实现方式：

     构造器注入：就是容器实例化Bean时注入那些依赖，通过在在Bean定义中指定构造器参数进行注入依赖，包括实例工厂方法参数注入依赖，但静态工厂方法参数不允许注入依赖；

     setter注入：通过setter方法进行注入依赖；

     方法注入：能通过配置方式替换掉Bean方法，也就是通过配置改变Bean方法 功能。

 

我们已经知道注入实现方式了，接下来让我们来看看具体配置吧。

 

 

3.1.2  构造器注入

       使用构造器注入通过配置构造器参数实现，构造器参数就是依赖。除了构造器方式，还有静态工厂、实例工厂方法可以进行构造器注入。如图3-1所示：

 

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

 

 

3.1.3  setter注入

       setter注入，是通过在通过构造器、静态工厂或实例工厂实例好Bean后，通过调用Bean类的setter方法进行注入依赖，如图3-3所示：

 

 

 

       知道配置方式了，接下来先让我们来做个简单例子吧。

（1）准备测试类HelloImpl4，需要两个setter方法“setMessage”和“setIndex”：

 

package lqy.springh2;

public class HelloApi2  {  
    private String message;  
    private int index;  
    
    //setter方法  
    public void setMessage(String message) {  
        this.message = message;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
    
    public void sayHello() {  
        System.out.println(index + ":" + message);  
    }  
}  

 

（2）配置Bean定义

    <bean id="bean" class="lqy.springh2.HelloApi2">  
        <property name="message" value="Hello World!"/>  
        <property name="index">  
            <value>1</value>  
        </property>  
    </bean> 

 

3）该写测试进行测试一下是否满足能工作了

         BeanFactory beanFactory =  new ClassPathXmlApplicationContext("helloworld.xml");  
         HelloApi2 bean = beanFactory.getBean("bean", HelloApi2.class);  
         bean.sayHello();

 

知道如何配置了，但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”命名规范。

 

 

 3.1.4 注入

1.注入常量

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

<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容错做的非常好。

    测试类  
    public class BooleanTestBean {  
        private boolean success;  
        public void setSuccess(boolean success) {  
            this.success = success;  
        }  
        public boolean isSuccess() {  
            return success;  
        }  
    }  
    配置文件（chapter3/booleanInject.xml）片段：  
    <!-- boolean参数值可以用on/off -->  
    <bean id="bean2" class="cn.javass.spring.chapter3.bean.BooleanTestBean">  
        <property name="success" value="on"/>  
    </bean>  
    <!-- boolean参数值可以用yes/no -->  
    <bean id="bean3" class="cn.javass.spring.chapter3.bean.BooleanTestBean">  
        <property name="success" value="yes"/>  
    </bean>  
    <!-- boolean参数值可以用1/0 -->  
    <bean id="bean4" class="cn.javass.spring.chapter3.bean.BooleanTestBean">  
        <property name="success" value="1"/>  
    </bean>  

 

2.注入Bean ID

 

3.注入集合、数组和字典

 

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

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

       （1）List类型：需要使用<list>标签来配置注入，其具体配置如下：

       让我们来写个测试来练习一下吧：

准备测试类：

package lqy.springh3;

import java.util.List;  
public class ListTestBean {  
    private List<String> values;  
    public List<String> getValues() {  
        return values;  
    }  
    public void setValues(List<String> values) {  
        this.values = values;  
    }  
}

 

进行Bean定义，在配置文件

<bean id="listBean" class="lqy.springh3.ListTestBean">  
    <property name="values">  
        <list>  
            <value>1</value>  
            <value>2</value>  
            <value>3</value>  
        </list>  
   </property>  
</bean> 

 

测试

         BeanFactory beanFactory =  new ClassPathXmlApplicationContext("helloworld.xml");  
         ListTestBean listBean = beanFactory.getBean("listBean", ListTestBean.class);  
         System.out.println(listBean.getValues().size());

 

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

public class CollectionTestBean {  
    private Collection<String> values;  
    public void setValues(Collection<String> values) {  
        this.values = values;  
    }  
    public Collection<String> getValues() {  
        return values;  
    }  
} 

<bean id="setBean" class="cn.javass.spring.chapter3.bean.SetTestBean">  
<property name="values">  
<set>  
<value>1</value>  
<value>2</value>  
<value>3</value>  
</set>  
</property>  
</bean>

 

（2）Collection类型：因 为Collection类型是Set和List类型的基类型，所以使用<set>或<list>标签都可以进行注入，配置方式完 全和以上配置方式一样，只是将测试类属性改成“Collection”类型，如果配置有问题，可参考 cn.javass.spring.chapter3.DependencyInjectTest测试类中的testCollectionInject测 试方法中的代码。

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

 

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

 

       如果练习时遇到配置问题，可以参考“cn.javass.spring.chapter3.DependencyInjectTest”测试类中的testMapInject测试方法中的代码。

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

 

到此我们已经把简单类型及集合类型介绍完了，大家可能会问怎么没见注入“Bean之间关系”的例子呢？接下来就让我们来讲解配置Bean之间依赖关系，也就是注入依赖Bean。

 

 

 

4.引用其它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：

 

三、接下来让我们用个具体例子来讲解一下具体使用吧：

1.使用构造器注入

 1.1实现类

package lqy.springh2;

public class HelloApi2  {  
    private String message;  
    private int index;  
    
    //setter方法  
    public void setMessage(String message) {  
        this.message = message;  
    }  
    public void setIndex(int index) {  
        this.index = index;  
    }  
    
    public void sayHello() {  
        System.out.println(index + ":" + message);  
    }  
}  

1.2.使用类

package lqy.springh4;

import lqy.springh2.HelloApi2;

public class HelloApiDecorator {  
private HelloApi2 helloApi2;  
//空参构造器  
    public HelloApiDecorator() {  
}  
//有参构造器  
    public HelloApiDecorator(HelloApi2 helloApi2) {  
        this.helloApi2 = helloApi2;  
}    

    
    public void sayHello() {  
        System.out.println("==========装饰一下===========");  
        helloApi2.sayHello();  
        System.out.println("==========装饰一下===========");  
    }  
}  

1.3.配置

<!-- 定义依赖Bean -->  
<bean id="helloApi2" class="lqy.springh2.HelloApi2"/>  
<!-- 通过构造器注入 -->  
<bean id="bean1" class="lqy.springh4.HelloApiDecorator">  
<constructor-arg index="0" ref="helloApi2"/>  
</bean>  

1.4.测试

         BeanFactory beanFactory =  new ClassPathXmlApplicationContext("helloworld.xml");  
         HelloApiDecorator bean1 = beanFactory.getBean("bean1", HelloApiDecorator.class);  
         bean1.sayHello();

 

2.使用setter注入

package lqy.springh4;

import lqy.springh2.HelloApi2;

public class HelloApiDecorator {  
    
private HelloApi2 helloApi2;  

//setter注入  
public void setHelloApi2(HelloApi2 helloApi2) {
    this.helloApi2 = helloApi2;
}
    public void sayHello() {  
        System.out.println("==========装饰一下===========");  
        helloApi2.sayHello();  
        System.out.println("==========装饰一下===========");  
    }  
}  

配置

<!-- 定义依赖Bean -->  
<bean id="helloApi2" class="lqy.springh2.HelloApi2"/>  

<!-- 通过构造器注入 -->  
<bean id="bean2" class="lqy.springh4.HelloApiDecorator">  
    <property name="helloApi2"><ref bean="helloApi2"/></property>  
</bean> 

 

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

（1）<ref local=””/>配置方式：用于引用通过<bean id=”beanName”>方式中通过id属性指定的Bean，它能利用XML解析器的验证功能在读取配置文件时来验证引用的Bean是否存在。 因此如果在当前配置文件中有相互引用的Bean可以采用<ref local>方式从而如果配置错误能在开发调试时就发现错误。

如果引用一个在当前配置文件中不存在的Bean将抛出如下异常：

org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line21 inXML document from class path resource [chapter3/beanInject2.xml] is invalid; nested exception is org.xml.sax.SAXParseException: cvc-id.1: There is no ID/IDREF binding for IDREF 'helloApi'.

<ref local>具体配置方式如下：

 

（2）<ref parent=””/>配置方式：用于引用父容器中的Bean，不会引用当前容器中的Bean，当然父容器中的Bean和当前容器的Bean是可以重名的，获取顺序是直接到父容器找。具体配置方式如下：

接下来让我们用个例子演示一下<ref local>和<ref parent>的配置过程：

首先还是准备测试类：

 

1.HelloBean.java

package lqy.localparent;

public class HelloBean {  
    private String hello;  
  
    public String getHello() {  
        return hello;  
    }  
  
    public void setHello(String hello) {  
        this.hello = hello;  
    }  
}

2.

package lqy.localparent;

import java.util.Date;  

public class HelloDate {  
    private Date date;  
  
    private HelloBean hb;  
  
    public void setDate(Date date) {  
        this.date = date;  
    }  
  
    public void setHb(HelloBean hb) {  
        this.hb = hb;  
    }  
  
    public void sayHello() {  
        System.out.println(hb.getHello());  
    }  
  
}

 

3.父容器-parent.xml

    <bean id="helloBean" class="lqy.localparent.HelloBean">  
        <property name="hello" value="Hello! Javamxj." />  
    </bean>  
      
    <bean id="helloBeanParent" class="lqy.localparent.HelloBean">  
        <property name="hello" value="Hello! Parent Bean." />  
    </bean>

4.子容器-beans.xml

    <bean id="helloBean" class="lqy.localparent.HelloBean">  
        <property name="hello" value="Hello! Child Bean." />  
    </bean>  
      
    <bean id="dateBean" name="#date" class="java.util.Date"/>  
      
    <bean id="hd1" class="lqy.localparent.HelloDate">  
        <property name="hb"> <ref bean="helloBeanParent"/>  </property>  
        <property name="date">  
            <ref bean="#date"/>  
            <!--<ref bean="dateBean"/>-->  
        </property>  
    </bean>  
     
 
    <bean id="hd2" class="lqy.localparent.HelloDate">  
        <property name="hb">  
            <ref local="helloBean"/>  
        </property>  
        <property name="date">  
            <ref local="dateBean"/>  
        </property>  
    </bean>  
      
    <bean id="hd3" class="lqy.localparent.HelloDate">  
        <property name="hb">  
            <ref parent="helloBean"/>  
        </property>  
        <property name="date">  
            <bean class="java.util.Date"/>  
        </property>  
    </bean>  

 

5.测试

package lqy.localparent;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

    public static void main(String[] args) {

        //初始化父容器  
        ApplicationContext parentBeanContext =  new ClassPathXmlApplicationContext("parent.xml");  
        //初始化当前容器  
        ApplicationContext beanContext = new ClassPathXmlApplicationContext( new String[] {"beans.xml"}, parentBeanContext);        
        HelloDate hd1 = (HelloDate) beanContext.getBean("hd1");  
        HelloDate hd2 = (HelloDate) beanContext.getBean("hd2");  
        HelloDate hd3 = (HelloDate) beanContext.getBean("hd3");  
  
        hd1.sayHello();  
        hd2.sayHello();  
        hd3.sayHello(); 
        

    }

}

打印

 

  OK！这里主要分析beans.xml、Main.java这两个文件。对于Main.java要注意的是如何加载“parent”的，重点看看beans.xml中ref元素的用法。

  首先定义两个bean：helloBean、dateBean，分别指向HelloBean类和Date类。然后定义了hd1、hd2、hd3等三个bean，都指向HelloDate类。

·hd1：
  property标签中的“helloBeanParent”并不存在于beans.xml中，而是在parent.xml中，使用<ref bean="someBean">可以从其它bean配置文件中寻找需要加载的目标bean。bean属性的值可以同目标bean的id属性相同，也可以同它的name属性中任意的一个值相同。

·hd2：
   property标签中的“helloBean”如果不存在于beans.xml中，则XML解析器会提示错误。<ref local="someBean">只能这个bean配置文件中寻找需要加载的目标bean，而且local属性值必须同目标bean的id属性相同。

·hd3：
   property标签中的“helloBean”同时存在于beans.xml和parent.xml中，使用<ref bean="someBean">则会优先从beans.xml中寻找需要加载的目标bean，如果需要从parent.xml中加载目标bean，则需使用<ref parent="someBean">。在设置date时，使用的是内联bean，这时可以不要任何id或name定义。

 

 

 参考：http://ontheroad-luckhouge.iteye.com/blog/850066

 

 

内部Bean定义

 

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

 

（1）让我们写个例子测试一下吧

 

 

 

 

 

处理null值

        Spring通过<value>标签或value属性注入常量值，所有注入的数据都是字符串，那如何注入null值呢？通过“null”值 吗？当然不是因为如果注入“null”则认为是字符串。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]进行导航，其中“[]”里的是基本类型，无法放置引用类型。

       让我们来练习一下吧。首先准备测试类，在此我们需要三个测试类，以便实现对象图导航功能演示：

        NavigationC类用于打印测试代码，从而观察配置是否正确；具体类如下所示：

package lqy.Navigation;

public class NavigationC {  
    public void sayNavigation() {  
        System.out.println("===navigation c");  
    }  
} 

 

 

NavigationB类，包含对象和列表、Properties、数组字典数据类型导航，而且这些复合数据类型保存的条目都是对象，正好练习一下如何往复合数据类型中注入对象依赖。具体类如下所示：

package lqy.Navigation;

import java.util.List;  
import java.util.Map;  
import java.util.Properties;  
public class NavigationB {  

    private NavigationC navigationC;  
    private List<NavigationC> list;  
    private Properties properties;  
    private NavigationC[] array = new NavigationC[1];  
    private Map<String, NavigationC> map;  

    
    public NavigationC getNavigationC() {
        return navigationC;
    }
    public void setNavigationC(NavigationC navigationC) {
        this.navigationC = navigationC;
    }
    public List<NavigationC> getList() {
        return list;
    }
    public void setList(List<NavigationC> list) {
        this.list = list;
    }
    public Properties getProperties() {
        return properties;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public NavigationC[] getArray() {
        return array;
    }
    public void setArray(NavigationC[] array) {
        this.array = array;
    }
    public Map<String, NavigationC> getMap() {
        return map;
    }
    public void setMap(Map<String, NavigationC> map) {
        this.map = map;
    }
    
    
} 

 

 

  NavigationA类是我们的前端类，通过对它的导航进行注入值，具体代码如下：

package lqy.Navigation;

public class NavigationA {  
    private NavigationB navigationB;  
    public void setNavigationB(NavigationB navigationB) {  
        this.navigationB = navigationB;  
    }  
    public NavigationB getNavigationB() {  
        return navigationB;  
    }  
} 

 

接下来该进行Bean定义配置

首先让我们配置一下需要被导航的数据，NavigationC和NavigationB类，其中配置NavigationB时注意要确保比如array字 段不为空值，这就需要或者在代码中赋值如“NavigationC[] array = new NavigationC[1];”，或者通过配置文件注入如“<list></list>”注入一个不包含条目的列表。具体配置 如下：

<bean id="c" class="lqy.Navigation.NavigationC"/>  
<bean id="b" class="lqy.Navigation.NavigationB">  
<property name="list"><list></list></property>  
    <property name="map"><map></map></property>  
    <property name="properties"><props></props></property>  
</bean> 

 

配置完需要被导航的Bean定义了，该来配置NavigationA导航Bean了，在此需要注意，由于“navigationB”属性为空值，在此需要首先注入“navigationB”值；还有对于数组导航不能越界否则报错；具体配置如下：

<bean id="c" class="lqy.Navigation.NavigationC"/>  
<bean id="b" class="lqy.Navigation.NavigationB">  
<property name="list"><list></list></property>  
    <property name="map"><map></map></property>  
    <property name="properties"><props></props></property>  
</bean> 

<bean id="a" class="lqy.Navigation.NavigationA">  
<!-- 首先注入navigatiionB 确保它非空 -->  
<property name="navigationB" ref="b"/>  
<!-- 对象图导航注入 -->  
<property name="navigationB.navigationC" ref="c"/>  
<!-- 注入列表数据类型数据 -->  
<property name="navigationB.list[0]" ref="c"/>  
<!-- 注入map类型数据 -->  
<property name="navigationB.map[key]" ref="c"/>  
<!-- 注入properties类型数据 -->  
<property name="navigationB.properties[0]" ref="c"/>  
<!-- 注入properties类型数据 -->  
<property name="navigationB.properties[1]" ref="c"/>  
<!-- 注入数组类型数据 ，注意不要越界-->  
<property name="navigationB.array[0]" ref="c"/>  
</bean> 

让我们看下测试代码吧：

 

package lqy.Navigation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class testNavigationBeanInject {

    /**
     * @param args
     */
    public static void main(String[] args) {


        ApplicationContext context =  new ClassPathXmlApplicationContext("navigation.xml");         
                NavigationA navigationA = context.getBean("a", NavigationA.class);  
                navigationA.getNavigationB().getNavigationC().sayNavigation();  
                navigationA.getNavigationB().getList().get(0).sayNavigation();  
                navigationA.getNavigationB().getMap().get("key").sayNavigation();  
                navigationA.getNavigationB().getArray()[0].sayNavigation();  
                ((NavigationC)navigationA.getNavigationB().getProperties().get("1"))  
                .sayNavigation();  
        

    }

}

结果

测试完毕，应该输出5个“===navigation c”，是不是很简单，注意这种方式是不推荐使用的，了解一下就够了，最好使用3.1.5一节使用的配置方式。

 

 

 

配置简写

让我们来总结一下依赖注入配置及简写形式，其实我们已经在以上部分穿插着进行简化配置了：

 

一、构造器注入：

1）常量值

简写：<constructor-arg index="0" value="常量"/>

全写：<constructor-arg index="0"><value>常量</value></constructor-arg>

2）引用

简写：<constructor-arg index="0" ref="引用"/>

全写：<constructor-arg index="0"><ref bean="引用"/></constructor-arg>

 

二、setter注入：      

       1）常量值

        简写：<property name="message" value="常量"/>

        全写：<property name="message"><value>常量</value></ property>

       2）引用

        简写：<property name="message" ref="引用"/>

        全写：<property name="message"><ref bean="引用"/></ property>

       3）数组：<array>没有简写形式

       4）列表：<list>没有简写形式

       5）集合：<set>没有简写形式

       6）字典

          简写：<map>

             <entry key="键常量" value="值常量"/>

             <entry key-ref="键引用" value-ref="值引用"/>

            </map>

         全写：<map>

             <entry><key><value>键常量</value></key><value>值常量</value></entry>

             <entry><key><ref bean="键引用"/></key><ref bean="值引用"/></entry>

           </map>

       7）Properties：没有简写形式

 

三、使用p命名空间简化setter注入：

       使用p命名空间来简化setter注入，具体使用如下：

    <?xml version="1.0" encoding="UTF-8"?>  
    <beans  xmlns="http://www.springframework.org/schema/beans"  
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
            xmlns:p="http://www.springframework.org/schema/p"  
            xsi:schemaLocation="  
               http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
    <bean id="bean1" class="java.lang.String">  
            <constructor-arg index="0" value="test"/>  
        </bean>  
    <bean id="idrefBean1" class="cn.javass.spring.chapter3.bean.IdRefTestBean"  
    p:id="value"/>  
    <bean id="idrefBean2" class="cn.javass.spring.chapter3.bean.IdRefTestBean"  
    p:id-ref="bean1"/>  
    </beans>  

• xmlns:p="http://www.springframework.org/schema/p" ：首先指定p命名空间；
• <bean id="……" class="……" p:id="value"/> ：常量setter注入方式，其等价于<property name="id" value="value"/>；
  •  
    • <bean id="……" class="……" p:id-ref="bean1"/> ：引用setter注入方式，其等价于<property name="id" ref="bean1"/>。