【第三章】 DI 之 3.1.2 DI的配置使用 ——跟我学spring3

3.1.4  注入常量

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

 

java代码：

查看复制到剪贴板打印

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

2. 或  

3. <property name="index"><value>1</value></property><span class="Apple-style-span" style="font-size: 14px; white-space: normal; background-color: #ffffff;"> </span>  

 

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

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

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

 

java代码：

查看复制到剪贴板打印

1. 测试类  

2. public class BooleanTestBean {  

3.     private boolean success;  

4.     public void setSuccess(boolean success) {  

5.         this.success = success;  

6.     }  

7.     public boolean isSuccess() {  

8.         return success;  

9.     }  

10. }  

11. 配置文件（chapter3/booleanInject.xml）片段：  

12. <!-- boolean参数值可以用on/off -->  

13. <bean id="bean2" class="cn.javass.spring.chapter3.bean.BooleanTestBean">  

14.     <property name="success" value="on"/>  

15. </bean>  

16. <!-- boolean参数值可以用yes/no -->  

17. <bean id="bean3" class="cn.javass.spring.chapter3.bean.BooleanTestBean">  

18.     <property name="success" value="yes"/>  

19. </bean>  

20. <!-- boolean参数值可以用1/0 -->  

21. <bean id="bean4" class="cn.javass.spring.chapter3.bean.BooleanTestBean">  

22.     <property name="success" value="1"/>  

23. </bean>  

3.1.5    注入Bean ID

用于注入Bean的ID，ID是一个常量不是引用，且类似于注入常量，但提供错误验证功能，配置方式如下所示：

 

java代码：

查看复制到剪贴板打印

1. <property name="id"><idref bean="bean1"/></property>  

 

 

java代码：

查看复制到剪贴板打印

1. <property name="id"><idref local="bean2"/></property>  

 

两种方式都可以，上述配置本质上在运行时等于如下方式

 

java代码：

查看复制到剪贴板打印

1. <bean id="bean1" class="……"/>  

2. <bean id="idrefBean1" class="……">  

3. <property name="id" value ="bean1"/>  

4. </bean>  

 

第二种方式（<idref bean="bean1"/>）可以在容器初始化时校验被引用的Bean是否存在，如果不存在将抛出异常，而第一种方式（<idref local="bean2"/>）只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第二种方式。

接下来学习一下如何使用吧：

 

首先定义测试Bean：

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter3.bean  

2. public class IdRefTestBean {  

3.     private String id;  

4.     public String getId() {  

5.         return id;  

6.     }  

7.     public void setId(String id) {  

8.         this.id = id;  

9.     }  

10. }  

 

其次定义配置文件（chapter3/idRefInject.xml）：

 

java代码：

查看复制到剪贴板打印

1. <bean id="bean1" class="java.lang.String">  

2. <constructor-arg index="0" value="test"/>  

3. </bean>  

4. <bean id="bean2" class="java.lang.String">  

5.     <constructor-arg index="0" value="test"/>  

6. </bean>  

 

 

java代码：

查看复制到剪贴板打印

1. <bean id="idrefBean1" class="cn.javass.spring.chapter3.bean.IdRefTestBean">  

2.         <property name="id"><idref bean="bean1"/></property>  

3. </bean>  

4. <bean id="idrefBean2" class="cn.javass.spring.chapter3.bean.IdRefTestBean">  

5.     <property name="id"><idref local="bean2"/></property>  

6. </bean>  

 

       从配置中可以看出，注入的Bean的ID是一个java.lang.String类型，即字符串类型，因此注入的同样是常量，只是具有校验功能。

<idref bean="……"/>将在容器初始化时校验注入的ID对于的Bean是否存在，如果不存在将抛出异常。

<idref local="……"/>将在XML解析时校验注入的ID对于的Bean在当前配置文件中是否存在，如果不存在将抛出异常，它不同于<idref bean="……"/>，<idref local="……"/>是校验发生在XML解析式而非容器初始化时，且只检查当前配置文件中是否存在相应的Bean。

 

3.1.6  注入集合、数组和字典

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

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

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

 

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

             准备测试类：

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter3.bean;  

2. import java.util.List;  

3. public class ListTestBean {  

4.     private List<String> values;  

5.     public List<String> getValues() {  

6.         return values;  

7.     }  

8.     public void setValues(List<String> values) {  

9.         this.values = values;  

10.     }  

11. }  

 

              进行Bean定义，在配置文件（resources/chapter3/listInject.xml）中配置list注入：

 

java代码：

查看复制到剪贴板打印

1. <bean id="listBean" class="cn.javass.spring.chapter3.bean.ListTestBean">  

2.     <property name="values">  

3.         <list>  

4.             <value>1</value>  

5.             <value>2</value>  

6.             <value>3</value>  

7.         </list>  

8.    </property>  

9. </bean>  

 

              测试代码：

 

java代码：

查看复制到剪贴板打印

1. @Test   

2. public void testListInject() {  

3.    BeanFactory beanFactory =  

4. new ClassPathXmlApplicationContext("chapter3/listInject.xml");  

5. ListTestBean listBean = beanFactory.getBean("listBean", ListTestBean.class);  

6. System.out.println(listBean.getValues().size());  

7. Assert.assertEquals(3, listBean.getValues().size());  

8. }  

 

 

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

              准备测试类：

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter3.bean;  

2. import java.util.Collection;  

3. public class CollectionTestBean {  

4.     private Collection<String> values;  

5.     public void setValues(Collection<String> values) {  

6.         this.values = values;  

7.     }  

8.     public Collection<String> getValues() {  

9.         return values;  

10.     }  

11. }  

 

              进行Bean定义，在配置文件（resources/chapter3/listInject.xml）中配置list注入：

 

java代码：

查看复制到剪贴板打印

1. <bean id="setBean" class="cn.javass.spring.chapter3.bean.SetTestBean">  

2. <property name="values">  

3. <set>  

4. <value>1</value>  

5. <value>2</value>  

6. <value>3</value>  

7. </set>  

8. </property>  

9. </bean>  

              具体测试代码就不写了，和listBean测试代码完全一样。

 

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

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

 

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

三、注入字典（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>来指定键值对，具体配置如下：

 

 

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

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

 

 

 

3.1.7  引用其它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）首先让我们定义测试引用Bean的类，在此我们可以使用原有的HelloApi实现，然后再定义一个装饰器来引用其他Bean，具体装饰类如下：

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter3.bean;  

2. import cn.javass.spring.chapter2.helloworld.HelloApi;  

3. public class HelloApiDecorator implements HelloApi {  

4. private HelloApi helloApi;  

5. //空参构造器  

6.     public HelloApiDecorator() {  

7. }  

8. //有参构造器  

9.     public HelloApiDecorator(HelloApi helloApi) {  

10.         this.helloApi = helloApi;  

11. }    

12. public void setHelloApi(HelloApi helloApi) {  

13.         this.helloApi = helloApi;  

14.     }  

15.     @Override  

16.     public void sayHello() {  

17.         System.out.println("==========装饰一下===========");  

18.         helloApi.sayHello();  

19.         System.out.println("==========装饰一下===========");  

20.     }  

21. }  

 

       （2）定义好了测试引用Bean接下来该在配置文件(resources/chapter3/beanInject.xml)进行配置Bean定义了，在此将演示通过构造器及setter方法方式注入依赖Bean：

 

java代码：

查看复制到剪贴板打印

1. <!-- 定义依赖Bean -->  

2. <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>  

3. <!-- 通过构造器注入 -->  

4. <bean id="bean1" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">  

5. <constructor-arg index="0" ref="helloApi"/>  

6. </bean>  

7. <!-- 通过构造器注入 -->  

8. <bean id="bean2" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">  

9.     <property name="helloApi"><ref bean=" helloApi"/></property>  

10. </bean>  

 

 

（3）测试一下吧，测试代码(cn.javass.spring.chapter3.DependencyInjectTest)片段如下：

 

java代码：

查看复制到剪贴板打印

1. @Test   

2. public void testBeanInject() {  

3.     BeanFactory beanFactory =  

4. new ClassPathXmlApplicationContext("chapter3/beanInject.xml");  

5.     //通过构造器方式注入  

6.     HelloApi bean1 = beanFactory.getBean("bean1", HelloApi.class);  

7.     bean1.sayHello();  

8.     //通过setter方式注入  

9.     HelloApi bean2 = beanFactory.getBean("bean2", HelloApi.class);  

10.     bean2.sayHello();  

11. }  

转载于:https://my.oschina.net/u/435621/blog/401789