`
jinnianshilongnian
  • 浏览: 21513902 次
  • 性别: Icon_minigender_1
博客专栏
5c8dac6a-21dc-3466-8abb-057664ab39c7
跟我学spring3
浏览量：2420516
D659df3e-4ad7-3b12-8b9a-1e94abd75ac3
Spring杂谈
浏览量：3010259
43989fe4-8b6b-3109-aaec-379d27dd4090
跟开涛学SpringMVC...
浏览量：5640608
1df97887-a9e1-3328-b6da-091f51f886a1
Servlet3.1规范翻...
浏览量：260219
4f347843-a078-36c1-977f-797c7fc123fc
springmvc杂谈
浏览量：1597953
22722232-95c1-34f2-b8e1-d059493d3d98
hibernate杂谈
浏览量：250370
45b32b6f-7468-3077-be40-00a5853c9a48
跟我学Shiro
浏览量：5860615
Group-logo
跟我学Nginx+Lua开...
浏览量：702889
5041f67a-12b2-30ba-814d-b55f466529d5
亿级流量网站架构核心技术
浏览量：785757
社区版块
存档分类
最新评论

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

spring 
阅读更多

 

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所示：

 

图3-1 实例化

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

首先让我们准备测试构造器类HelloImpl3.java，该类只有一个包含两个参数的构造器：

 

java代码：
查看复制到剪贴板打印
  1. package cn.javass.spring.chapter3.helloworld;  
  2. public class HelloImpl3 implements HelloApi {  
  3.     private String message;  
  4. private int index;  
  5. //@java.beans.ConstructorProperties({"message", "index"})  
  6.     public HelloImpl3(String message, int index) {  
  7.         this.message = message;  
  8.         this.index = index;  
  9.     }  
  10.     @Override  
  11.     public void sayHello() {  
  12.         System.out.println(index + ":" + message);  
  13.     }  
  14. }  

 

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

 

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

 

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

 

四、让我们来用具体的例子来看一下构造器注入怎么使用吧。

（1）首先准备Bean类，在此我们就使用“HelloImpl3”这个类。

（2）有了Bean类，接下来要进行Bean定义配置，我们需要配置三个Bean来完成上述三种依赖注入测试，其中Bean ”byIndex”是通过索引注入依赖；Bean ”byType”是根据类型进行注入依赖；Bean ”byName”是根据参数名字进行注入依赖，具体配置文件（resources/chapter3/ constructorDependencyInject.xml）如下：

 

java代码：
查看复制到剪贴板打印
  1. <!-- 通过构造器参数索引方式依赖注入 -->  
  2. <bean id="byIndex" class="cn.javass.spring.chapter3.HelloImpl3">  
  3. <constructor-arg index="0" value="Hello World!"/>  
  4.     <constructor-arg index="1" value="1"/>  
  5. </bean>  
  6. <!-- 通过构造器参数类型方式依赖注入 -->  
  7. <bean id="byType" class="cn.javass.spring.chapter3.HelloImpl3">  
  8.    <constructor-arg type="java.lang.String" value="Hello World!"/>  
  9.    <constructor-arg type="int" value="2"/>  
  10. </bean>  
  11. <!-- 通过构造器参数名称方式依赖注入 -->  
  12. <bean id="byName" class="cn.javass.spring.chapter3.HelloImpl3">  
  13.    <constructor-arg name="message" value="Hello World!"/>  
  14.    <constructor-arg name="index" value="3"/>  
  15. </bean>  
  16.    
  17.    

 

（3）配置完毕后，在测试之前，因为我们使用了通过构造器参数名字注入方式，请确保编译时class文件包含“变量信息”，具体查看编译时是否包含“变量调试信息”请右击项目，在弹出的对话框选择属性；然后在弹出的对话框选择“Java Compiler”条目，在“Class 文件 生成”框中选择“添加变量信息到Class文件（调试器使用）”，具体如图3-2：

 

图3-2 编译时打开“添加变量信息选项”

（4）接下来让我们测试一下配置是否工作，具体测试代码（cn.javass.spring.chapter3. DependencyInjectTest）如下：

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testConstructorDependencyInjectTest() {        
  3. BeanFactory beanFactory =  new ClassPathXmlApplicationContext("chapter3/constructorDependencyInject.xml");  
  4. //获取根据参数索引依赖注入的Bean  
  5. HelloApi byIndex = beanFactory.getBean("byIndex", HelloApi.class);  
  6. byIndex.sayHello();  
  7. //获取根据参数类型依赖注入的Bean  
  8. HelloApi byType = beanFactory.getBean("byType", HelloApi.class);  
  9. byType.sayHello();  
  10. //获取根据参数名字依赖注入的Bean  
  11. HelloApi byName = beanFactory.getBean("byName", HelloApi.class);  
  12. byName.sayHello();  
  13. }  

 

       通过以上测试我们已经会基本的构造器注入配置了，在测试通过参数名字注入时，除了可以使用以上方式，还可以通过在构造器上添加@java.beans.ConstructorProperties({"message", "index"})注解来指定参数名字，在HelloImpl3构造器上把注释掉的“ConstructorProperties”打开就可以了，这个就留给大家做练习，自己配置然后测试一下。

 

五、大家已经会了构造器注入，那让我们再看一下静态工厂方法注入和实例工厂注入吧，其实它们注入配置是完全一样，在此我们只示范一下静态工厂注入方式和实例工厂方式配置，测试就留给大家自己练习：

       （1）静态工厂类

 

java代码：
查看复制到剪贴板打印
  1. //静态工厂类  
  2. package cn.javass.spring.chapter3;  
  3. import cn.javass.spring.chapter2.helloworld.HelloApi;  
  4. public class DependencyInjectByStaticFactory {  
  5.        public static HelloApi newInstance(String message, int index) {  
  6.               return new HelloImpl3(message, index);  
  7.        }  
  8. }  

 

        静态工厂类Bean定义配置文件（chapter3/staticFactoryDependencyInject.xml）

 

 

java代码：
查看复制到剪贴板打印
  1. <bean id="byIndex"  
  2. class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">  
  3. <constructor-arg index="0" value="Hello World!"/>  
  4. <constructor-arg index="1" value="1"/>  
  5. </bean>  
  6. <bean id="byType"  
  7. class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">  
  8. <constructor-arg type="java.lang.String" value="Hello World!"/>  
  9.        <constructor-arg type="int" value="2"/>  
  10. </bean>  
  11. <bean id="byName"  
  12. class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">  
  13.        <constructor-arg name="message" value="Hello World!"/>  
  14.        <constructor-arg name="index" value="3"/>  
  15. </bean>  

 

 

（2）实例工厂类

 

java代码：
查看复制到剪贴板打印
  1. //实例工厂类  
  2. package cn.javass.spring.chapter3;  
  3. import cn.javass.spring.chapter2.helloworld.HelloApi;  
  4. public class DependencyInjectByInstanceFactory {  
  5.     public HelloApi newInstance(String message, int index) {  
  6.         return new HelloImpl3(message, index);  
  7.     }  
  8. }  

 

        实例工厂类Bean定义配置文件（chapter3/instanceFactoryDependencyInject.xml）

 

 

java代码：
查看复制到剪贴板打印
  1. <bean id="instanceFactory"  
  2. class="cn.javass.spring.chapter3.DependencyInjectByInstanceFactory"/>  
  3.    
  4. <bean id="byIndex"  
  5. factory-bean="instanceFactory"  factory-method="newInstance">  
  6.     <constructor-arg index="0" value="Hello World!"/>  
  7.        <constructor-arg index="1" value="1"/>  
  8. </bean>  
  9. <bean id="byType"  
  10. factory-bean="instanceFactory" factory-method="newInstance">  
  11. <constructor-arg type="java.lang.String" value="Hello World!"/>  
  12. <constructor-arg type="int" value="2"/>  
  13. </bean>  
  14. <bean id="byName"  
  15. factory-bean="instanceFactory" factory-method="newInstance">  
  16. <constructor-arg name="message" value="Hello World!"/>  
  17. <constructor-arg name="index" value="3"/>  
  18. </bean>  

 

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

 

 

3.1.3  setter注入

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

 

图3-3 setter注入方式

       setter注入方式只有一种根据setter名字进行注入：

 

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

 

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

 

java代码：
查看复制到剪贴板打印
  1. package cn.javass.spring.chapter3;  
  2. import cn.javass.spring.chapter2.helloworld.HelloApi;  
  3. public class HelloImpl4 implements HelloApi {  
  4.     private String message;  
  5.     private int index;  
  6. //setter方法  
  7.     public void setMessage(String message) {  
  8.         this.message = message;  
  9.     }  
  10.     public void setIndex(int index) {  
  11.         this.index = index;  
  12.     }  
  13.     @Override  
  14.     public void sayHello() {  
  15.         System.out.println(index + ":" + message);  
  16.     }  
  17. }  

 

       （2）配置Bean定义，具体配置文件（resources/chapter3/setterDependencyInject.xml）片段如下：

 

java代码：
查看复制到剪贴板打印
  1. <!-- 通过setter方式进行依赖注入 -->  
  2.     <bean id="bean" class="cn.javass.spring.chapter3.HelloImpl4">  
  3.         <property name="message" value="Hello World!"/>  
  4.         <property name="index">  
  5.             <value>1</value>  
  6.         </property>  
  7.     </bean>  

 

 

（3）该写测试进行测试一下是否满足能工作了，其实测试代码一点没变，变的是配置：

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testSetterDependencyInject() {  
  3.     BeanFactory beanFactory =  
  4. new ClassPathXmlApplicationContext("chapter3/setterDependencyInject.xml");  
  5.    HelloApi bean = beanFactory.getBean("bean", HelloApi.class);  
  6.     bean.sayHello();  
  7. }  

 

       知道如何配置了，但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  注入常量

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

 

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. }  

 

       四、其他引用方式：除了最基本配置方式以外，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>的配置过程：

首先还是准备测试类，在此我们就使用以前写好的HelloApiDecorator和HelloImpl4类；其次进行Bean定义，其中当前容器bean1引用本地的”helloApi”，而”bean2”将引用父容器的”helloApi”，配置如下：

 

java代码：
查看复制到剪贴板打印
  1. <!-- sources/chapter3/parentBeanInject.xml表示父容器配置-->  
  2. <!--注意此处可能子容器也定义一个该Bean-->  
  3. <bean id="helloApi" class="cn.javass.spring.chapter3.HelloImpl4">  
  4. <property name="index" value="1"/>  
  5. <property name="message" value="Hello Parent!"/>  
  6. </bean>  

 

 

java代码：
查看复制到剪贴板打印
  1. <!-- sources/chapter3/localBeanInject.xml表示当前容器配置-->  
  2. <!-- 注意父容器中也定义了id 为 helloApi的Bean -->  
  3. <bean id="helloApi" class="cn.javass.spring.chapter3.HelloImpl4">  
  4. <property name="index" value="1"/>  
  5.     <property name="message" value="Hello Local!"/>  
  6. </bean>  
  7. <!-- 通过local注入 -->  
  8. <bean id="bean1" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">  
  9. <constructor-arg index="0"><ref local="helloApi"/></constructor-arg>  
  10. </bean>  
  11. <!-- 通过parent注入 -->  
  12. <bean id="bean2" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">  
  13. <property name="helloApi"><ref parent="helloApi"/></property>  
  14. </bean>  

 

（3）写测试类测试一下吧，具体代码片段如下： 

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testLocalAndparentBeanInject() {  
  3. //初始化父容器  
  4. ApplicationContext parentBeanContext =  
  5. new ClassPathXmlApplicationContext("chapter3/parentBeanInject.xml");  
  6. //初始化当前容器  
  7. ApplicationContext beanContext = new ClassPathXmlApplicationContext(  
  8. new String[] {"chapter3/localBeanInject.xml"}, parentBeanContext);  
  9.     HelloApi bean1 = beanContext.getBean("bean1", HelloApi.class);  
  10.     bean1.sayHello();//该Bean引用local bean  
  11. HelloApi bean2 = beanContext.getBean("bean2", HelloApi.class);  
  12. bean2.sayHello();//该Bean引用parent bean  
  13. }  

 

 “bean1”将输出“Hello Local!”表示引用当前容器的Bean，”bean2”将输出“Hello Paren!”，表示引用父容器的Bean，如配置有问题请参考cn.javass.spring.chapter3.DependencyInjectTest中的testLocalAndparentBeanInject测试方法。

 

3.1.8  内部Bean定义

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

 

（1）让我们写个例子测试一下吧，具体配置文件如下：

 

java代码：
查看复制到剪贴板打印
  1. <bean id="bean" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">  
  2. <property name="helloApi">  
  3. <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>  
  4. </property>  
  5. </bean>  

 

 

 （2）测试代码（cn.javass.spring.chapter3.DependencyInjectTest.testInnerBeanInject）：

 

java代码：
查看复制到剪贴板打印
  1. @Test  
  2. public void testInnerBeanInject() {  
  3. ApplicationContext context =  
  4. new ClassPathXmlApplicationContext("chapter3/innerBeanInject.xml");  
  5. HelloApi bean = context.getBean("bean", HelloApi.class);  
  6. bean.sayHello();  
  7. }  

 

3.1.9  处理null值

        Spring通过<value>标签或value属性注入常量值，所有注入的数据都是字符串，那如何注入null值呢？通过“null”值吗？当然不是因为如果注入“null”则认为是字符串。Spring通过<null/>标签注入null值。即可以采用如下配置方式：

 

3.1.10 对象图导航注入支持

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

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

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

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

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

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

 

java代码：
查看复制到剪贴板打印
  1. package cn.javass.spring.chapter3.bean;  
  2. public class NavigationC {  
  3.     public void sayNavigation() {  
  4.         System.out.println("===navigation c");  
  5.     }  
  6. }  

 

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

 

 

java代码：
查看复制到剪贴板打印
  1. package cn.javass.spring.chapter3.bean;  
  2. import java.util.List;  
  3. import java.util.Map;  
  4. import java.util.Properties;  
  5. public class NavigationB {  
  6.     private NavigationC navigationC;  
  7.     private List<NavigationC> list;  
  8.     private Properties properties;  
  9.     private NavigationC[] array = new NavigationC[1];  
  10.     private Map<String, NavigationC> map;  
  11.    //由于setter和getter方法占用太多空间，故省略，大家自己实现吧  
  12. }  

 

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

 

java代码：
查看复制到剪贴板打印
  1. package cn.javass.spring.chapter3.bean;  
  2. public class NavigationA {  
  3.     private NavigationB navigationB;  
  4.     public void setNavigationB(NavigationB navigationB) {  
  5.         this.navigationB = navigationB;  
  6.     }  
  7.     public NavigationB getNavigationB() {  
  8.         return navigationB;  
  9.     }  
  10. }  

 

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

 

java代码：
查看复制到剪贴板打印
  1. <bean id="c" class="cn.javass.spring.chapter3.bean.NavigationC"/>  
  2. <bean id="b" class="cn.javass.spring.chapter3.bean.NavigationB">  
  3. <property name="list"><list></list></property>  
  4.     <property name="map"><map></map></property>  
  5.     <property name="properties"><props></props></property>  
  6. </bean>  

 

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

 

java代码：
查看复制到剪贴板打印
  1. <bean id="a" class="cn.javass.spring.chapter3.bean.NavigationA">  
  2. <!-- 首先注入navigatiionB 确保它非空 -->  
  3. <property name="navigationB" ref="b"/>  
  4. <!-- 对象图导航注入 -->  
  5. <property name="navigationB.navigationC" ref="c"/>  
  6. <!-- 注入列表数据类型数据 -->  
  7. <property name="navigationB.list[0]" ref="c"/>  
  8. <!-- 注入map类型数据 -->  
  9. <property name="navigationB.map[key]" ref="c"/>  
  10. <!-- 注入properties类型数据 -->  
  11. <property name="navigationB.properties[0]" ref="c"/>  
  12. <!-- 注入properties类型数据 -->  
  13. <property name="navigationB.properties[1]" ref="c"/>  
  14. <!-- 注入数组类型数据 ，注意不要越界-->  
  15. <property name="navigationB.array[0]" ref="c"/>  
  16. </bean>  
  17.    

        配置完毕，具体测试代码在cn.javass.spring.chapter3. DependencyInjectTest，让我们看下测试代码吧：

 

java代码：
查看复制到剪贴板打印
  1. //对象图导航  
  2. @Test  
  3. public void testNavigationBeanInject() {  
  4. ApplicationContext context =  
  5. new ClassPathXmlApplicationContext("chapter3/navigationBeanInject.xml");         
  6. NavigationA navigationA = context.getBean("a", NavigationA.class);  
  7. navigationA.getNavigationB().getNavigationC().sayNavigation();  
  8. navigationA.getNavigationB().getList().get(0).sayNavigation();  
  9. navigationA.getNavigationB().getMap().get("key").sayNavigation();  
  10. navigationA.getNavigationB().getArray()[0].sayNavigation();  
  11. ((NavigationC)navigationA.getNavigationB().getProperties().get("1"))  
  12. .sayNavigation();         
  13. }  
  14.    

 

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

 

3.1.11配置简写

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

 

一、构造器注入：

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注入，具体使用如下：

 

 

java代码：
查看复制到剪贴板打印
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans  xmlns="http://www.springframework.org/schema/beans"  
  3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.         xmlns:p="http://www.springframework.org/schema/p"  
  5.         xsi:schemaLocation="  
  6.            http://www.springframework.org/schema/beans  
  7.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">  
  8. <bean id="bean1" class="java.lang.String">  
  9.         <constructor-arg index="0" value="test"/>  
  10.     </bean>  
  11. <bean id="idrefBean1" class="cn.javass.spring.chapter3.bean.IdRefTestBean"  
  12. p:id="value"/>  
  13. <bean id="idrefBean2" class="cn.javass.spring.chapter3.bean.IdRefTestBean"  
  14. p:id-ref="bean1"/>  
  15. </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"/>。 
原创内容，转载请注明【http://sishuok.com/forum/posts/list/2447.html】
 

 

分享到：
| 【第二章】 IoC 之 2.3 IoC的配置使用—— ...
评论
57 楼 wuchangqing 2017-04-08  
静态工厂方法参数不允许注入依赖？ 请问这个是什么意思？我看后边有通过配置文件将参数注入了呢
56 楼 xiaofenglu 2016-01-07   
      <!-- 定义依赖Bean -->
    <bean id="helloApi" class="cn.javass.spring.chapter2.helloworld.HelloImpl"/>
    <!-- 通过构造器注入 -->
    <bean id="bean1" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">
        <constructor-arg index="0" ref="helloApi"/>
    </bean>
    <!-- 通过构造器注入 -->
    <bean id="bean2" class="cn.javass.spring.chapter3.bean.HelloApiDecorator">
        <property name="helloApi"><ref bean=" helloApi"/></property>
    </bean>


<property name="helloApi"><ref bean=" helloApi"/></property> 这句bean=" helloApi" 这里有个空格，需要去掉，不然报找不到hellApi
55 楼 lazy_cpp 2015-11-26  
sorriest-siben 写道
开涛，文章里提到的构造器注入，
实现类里面有个有参构造器，
public HelloImpl(int age, String name) {
   System.out.println("--这是有参构造器, 第一个参数是：" + age +"   ，第二个参数是：" + name);
}
配置文件是，
<!-- 通过构造器参数索引方式依赖注入 --> 
<bean id="byIndex" class="cn.just4u.spring3.hw.HelloImpl">   
    <constructor-arg index="0" value="20"/> 
    <constructor-arg index="1" value="张三"/>
</bean> 

<!-- 通过构造器参数类型方式依赖注入 --> 
<bean id="byType" class="cn.just4u.spring3.hw.HelloImpl">    
   <constructor-arg type="int" value="30"/> 
   <constructor-arg type="java.lang.String" value="李四"/> 
</bean> 

<!-- 通过构造器参数名称方式依赖注入 --> 
<bean id="byName" class="cn.just4u.spring3.hw.HelloImpl">    
   <constructor-arg name="age" value="40"/> 
   <constructor-arg name="name" value="王五"/> 
</bean>
但是测试类里面只是ctx.getBean("byIndex"); 我想应该只输出张三  20这个信息，可是实际运行结果是把张三李四王五都输出来了，

这是什么原因呢，谢谢



容器启动三个bean都实例化了，你的打印写在构造函数里面，你可以单独写个和作者例子里的sayhello()一样，写个printInfo(）这样的函数，获得bean后调用，就可以做到只打印一条信息了，嘿嘿！
54 楼 newboy2004 2015-11-18  
((NavigationC)navigationA.getNavigationB().getProperties().get("0")).sayNavigation();
这应该取0而不是1
53 楼 西斧头帮老大-_- 2015-11-03  
构造器注入：就是容器实例化Bean时注入那些依赖，通过在在Bean定义中指定构造器参数进行注入依赖，包括实例工厂方法参数注入依赖，但静态工厂方法参数不允许注入依赖；---------这个“但静态工厂方法参数不允许注入依赖”，后面不是有静态工厂方法注入吗？（ 静态工厂类Bean定义配置文件（chapter3/staticFactoryDependencyInject.xml））我理解错了？

52 楼 cslqj 2015-09-22  
真乃神人也！受教了，谢谢     
51 楼 1990yalong 2015-08-21  
我想问问：3.1.10中XML的配置，为什么不加<property name="array"><array></array></property>可以运行？而我加上就不可以运行？
50 楼 dfb198998 2015-08-01  
大爱，非常地通俗易懂~
49 楼 渺渺兮予怀 2015-06-17  
public HelloImpl4(int record,String name,String message){
this.record=record;
this.name=name;
this.message=message;
}
//@java.beans.ConstructorProperties({"message", "name","record"})
public HelloImpl4(String message,String name,int record){
this.message=message;
this.name=name;
this.record=record;
}
就是想验证下通过构造器参数类型注入，当上述这样情况下，怎么确定容器调用的是哪个构造器方法呢？
<!-- 通过构造器参数索引方式依赖注入-->
<bean id="helloImpl4_0" class="com.spring.chapter2.helloworld.HelloImpl4">
<constructor-arg index="0" value="Hello world"/>
<constructor-arg index="1" value="helloImpl4_0"/>
<constructor-arg index="2" value="0"/>
</bean>
<!-- 通过构造器参数类型方式依赖注入-->
<bean id="helloImpl4_1" class="com.spring.chapter2.helloworld.HelloImpl4">
<constructor-arg type="java.lang.String" value="Hello world"/>
<constructor-arg type="java.lang.String" value="helloImpl4_1"/>
<constructor-arg type="int" value="1"/>
</bean>
<!-- 通过构造器参数名称方式依赖注入-->
<bean id="helloImpl4_2" class="com.spring.chapter2.helloworld.HelloImpl4">
<constructor-arg name="message" value="Hello world"/>
<constructor-arg name="name" value="helloImpl4_2"/>
<constructor-arg name="record" value="2"/>
</bean>
@Test
public void testConstructorDI(){
ApplicationContext context=
new ClassPathXmlApplicationContext("chapter2/constructorDI.xml");
HelloApi helloImpl4_0=context.getBean("helloImpl4_0", HelloImpl4.class);
HelloApi helloImpl4_1=context.getBean("helloImpl4_1", HelloImpl4.class);
HelloApi helloImpl4_2=context.getBean("helloImpl4_2", HelloImpl4.class);
helloImpl4_0.sayHello();
helloImpl4_1.sayHello();
helloImpl4_2.sayHello();
}

最终断点得到的结果是：第一个通过索引，即便有两个构造器，也是调用的第二个，其他的都是调用的第一个，为什么？
48 楼 渺渺兮予怀 2015-06-16  
“动态替换Bean对象，程序更加灵活”，但是后续是基于注解来指定依赖注入，不可能还是XML配置的方式，那么这样子还是要更改源码，至少要更改依赖的对象啊，只不过即便要更改，还是很便捷的。我这个理解对吗 ？
47 楼 飞天奔月 2015-04-10  
org.springframework.beans.PropertyEditorRegistrySupport.createDefaultEditors()
org.springframework.beans.propertyeditors.CustomBooleanEditor

这里与大家分享, 就是楼主所说的

"Spring类型转换系统对于boolean类型进行了容错处理，除了可以使用“true/false”标准的Java值进行注入，还能使用“yes/no”、“on/off”、“1/0”来代表“真/假”，"
46 楼 sorriest-siben 2013-10-30  
----容器启动时就会实例化bean啊  你可以配置延迟 所以三个都实例化------

我试了下，前提是我getBean写的是张三那个name

如果把张三和王五设置lazy-init="true"，就会先后输出李四，张三
只把王五那个bean设置lazy-init="true"，就会先后输出张三，李四

我在网上查了下，这个好像涉及到bean的作用域
当我把王五设置成scope="prototype"，还是get张三那个bean,就不会输出王五

哈哈 好有意思
45 楼 jinnianshilongnian 2013-10-30  
sorriest-siben 写道
开涛，文章里提到的构造器注入，
实现类里面有个有参构造器，
public HelloImpl(int age, String name) {
   System.out.println("--这是有参构造器, 第一个参数是：" + age +"   ，第二个参数是：" + name);
}
配置文件是，
<!-- 通过构造器参数索引方式依赖注入 --> 
<bean id="byIndex" class="cn.just4u.spring3.hw.HelloImpl">   
    <constructor-arg index="0" value="20"/> 
    <constructor-arg index="1" value="张三"/>
</bean> 

<!-- 通过构造器参数类型方式依赖注入 --> 
<bean id="byType" class="cn.just4u.spring3.hw.HelloImpl">    
   <constructor-arg type="int" value="30"/> 
   <constructor-arg type="java.lang.String" value="李四"/> 
</bean> 

<!-- 通过构造器参数名称方式依赖注入 --> 
<bean id="byName" class="cn.just4u.spring3.hw.HelloImpl">    
   <constructor-arg name="age" value="40"/> 
   <constructor-arg name="name" value="王五"/> 
</bean>
但是测试类里面只是ctx.getBean("byIndex"); 我想应该只输出张三  20这个信息，可是实际运行结果是把张三李四王五都输出来了，

这是什么原因呢，谢谢

容器启动时就会实例化bean啊  你可以配置延迟 所以三个都实例化
44 楼 sorriest-siben 2013-10-30  
开涛，文章里提到的构造器注入，
实现类里面有个有参构造器，
public HelloImpl(int age, String name) {
   System.out.println("--这是有参构造器, 第一个参数是：" + age +"   ，第二个参数是：" + name);
}
配置文件是，
<!-- 通过构造器参数索引方式依赖注入 --> 
<bean id="byIndex" class="cn.just4u.spring3.hw.HelloImpl">   
    <constructor-arg index="0" value="20"/> 
    <constructor-arg index="1" value="张三"/>
</bean> 

<!-- 通过构造器参数类型方式依赖注入 --> 
<bean id="byType" class="cn.just4u.spring3.hw.HelloImpl">    
   <constructor-arg type="int" value="30"/> 
   <constructor-arg type="java.lang.String" value="李四"/> 
</bean> 

<!-- 通过构造器参数名称方式依赖注入 --> 
<bean id="byName" class="cn.just4u.spring3.hw.HelloImpl">    
   <constructor-arg name="age" value="40"/> 
   <constructor-arg name="name" value="王五"/> 
</bean>
但是测试类里面只是ctx.getBean("byIndex"); 我想应该只输出张三  20这个信息，可是实际运行结果是把张三李四王五都输出来了，

这是什么原因呢，谢谢
43 楼 jinnianshilongnian 2013-10-16  
SiuLo 写道
NavigationB类中需订正：
private List<NavigationC> list = new ArrayList<NavigationC>();  //这里list属性必须先行实例化，否则会错误

2.x需要的 3.x现在不需要了 记得是默认自动new
42 楼 SiuLo 2013-10-16  
NavigationB类中需订正：
private List<NavigationC> list = new ArrayList<NavigationC>();  //这里list属性必须先行实例化，否则会错误
41 楼 jinnianshilongnian 2013-07-17  
liangzhu 写道
你后台的解释是正确的：
<idref local="……"/>将在XML解析时校验注入的ID对于的Bean在当前配置文件中是否存在，如果不存在将抛出异常，它不同于<idref bean="……"/>是校验发生在XML解析式而非容器初始化时，且只检查当前配置文件中是否存在相应的Bean。

而你在前面说：
而第二种方式只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第一种方式。

显然是冲突的。


已改
40 楼 jinnianshilongnian 2013-07-17  
liangzhu 写道
你后台的解释是正确的：
<idref local="……"/>将在XML解析时校验注入的ID对于的Bean在当前配置文件中是否存在，如果不存在将抛出异常，它不同于<idref bean="……"/>是校验发生在XML解析式而非容器初始化时，且只检查当前配置文件中是否存在相应的Bean。

而你在前面说：
而第二种方式只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第一种方式。

显然是冲突的。

是错了 
39 楼 liangzhu 2013-07-17  
你后台的解释是正确的：
<idref local="……"/>将在XML解析时校验注入的ID对于的Bean在当前配置文件中是否存在，如果不存在将抛出异常，它不同于<idref bean="……"/>是校验发生在XML解析式而非容器初始化时，且只检查当前配置文件中是否存在相应的Bean。

而你在前面说：
而第二种方式只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第一种方式。

显然是冲突的。
38 楼 jinnianshilongnian 2013-07-16  
liangzhu 写道
Sorry, 好像是误解了。

建议修改一下这段：
第一种（改为前两种）方式可以在容器初始化时校验被引用的Bean是否存在，如果不存在将抛出异常，而第二（改为三）种方式只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第一种（改为前两种）方式。

此处就两种方式啊，你说的第三种是一种等价于前两种（对不，但不相等）
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    跟开涛学Spring

    1.4 【第三章】 DI 之 3.1 DI的配置使用 ——跟我学spring3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 1.5 【第三章】 DI 之 3.2 循环依赖 ——跟我学spring3 . . . . . . . . . . ...

    spring3.1相关配置文件

    在这个压缩包中，我们很可能会找到与Spring 3.1配置相关的各种文件，如XML配置文件、Java配置类以及相关文档。 1. **Spring核心**：Spring的核心特性包括依赖注入（Dependency Injection，DI）和面向切面编程...

    跟我学spring

    标题“跟我学spring”和描述“spring 的使用，每个知识点和项目中的运用，20章的介绍。”暗示这是一份详细介绍Spring框架使用方法的教程或手册，覆盖了Spring的各个方面，并以实例为导向，深入探讨了每个知识点在...

    跟我学spring3

    在《跟我学Spring3》中，你将逐步学习到如何配置Spring环境，创建Bean，理解AOP原理，使用Spring MVC构建Web应用，以及如何整合其他技术如JPA、Hibernate等。压缩包中的"gen-wo-xue-spring.pdf"可能是教程的概述或...

    跟我学spring3pdf，高清

    《跟我学Spring3》是一本深入浅出的Spring框架学习指南，主要针对Spring 3.x版本进行讲解。这本书旨在帮助初学者和有一定经验的开发者更好地理解和应用Spring框架，提升其在实际开发中的技能。PDF文档提供了清晰的...

    spring 3.1的 源码

    1. **依赖注入（Dependency Injection, DI）**：Spring的核心特性之一，允许开发者在运行时通过配置文件或注解来控制对象间的依赖关系，而不是在代码中硬编码。在Spring 3.1中，依赖注入进一步优化，支持更多的注解...

    Spring 3.1 jar包

    首先，Spring 3.1 引入了Groovy配置支持，这使得开发者可以使用Groovy语言编写bean的配置，提供了更简洁和动态的配置方式。Groovy配置文件具有更强的表达力，能够减少XML配置的繁琐，提高开发效率。 其次，Spring ...

    跟我学spring3（总共13章）8

    《跟我学Spring3》系列教程是为初学者和有经验的开发者提供的一份全面而深入的Spring框架学习资源。Spring3作为Java企业级应用开发的重要框架，它的核心特性包括依赖注入、AOP（面向切面编程）、数据访问、Web开发等...

    Spring5 实战 第三章3.1代码

    在本节"Spring5 实战 第三章3.1代码"中，我们将深入探讨Spring框架的核心概念和在实际开发中的应用。Spring是一个广泛使用的Java企业级应用开发框架，以其依赖注入（Dependency Injection, DI）和面向切面编程...

    开涛 跟我学spring3 pdf+源码

    这本书分为两部分PDF文档："开涛 跟我学spring3(1-7).pdf" 和 "开涛 跟我学spring3(8-13).pdf"，分别覆盖了Spring框架的核心概念和技术，旨在帮助读者全面理解并掌握Spring框架的应用。 在第一部分（1-7章）中，...

    跟我学spring3 .pdf

    《跟我学Spring3》这本书是针对Spring框架进行深入解析的一本教程，涵盖了Spring的核心特性，包括IoC（Inversion of Control，控制反转）、DI（Dependency Injection，依赖注入）、AOP（Aspect-Oriented Programming...

    spring3.1 jar全集

    Spring 3.1还引入了对Java配置的支持，这使得开发者可以用纯Java类来替代XML配置，进一步增强了代码的可读性和可维护性。另外，Spring 3.1对JSR-330依赖注入规范的全面支持，使得与Google Guice等其他依赖注入框架的...

    spring3.1开发宝典

    Spring框架的核心特性之一是依赖注入（DI），这是一种设计模式，允许将对象间的依赖关系由外部进行配置和管理，而不是在代码中硬编码。通过这种方式，对象可以专注于自己的职责，而依赖关系的管理则交给了Spring容器...

    跟我学spring3(1-13)

    《跟我学Spring3》是一本深入浅出介绍Spring框架的电子书，分为两部分，分别是“跟我学Spring3(8-13).pdf”和“跟我学Spring3(1-7).pdf”，全面覆盖了Spring框架的核心概念和技术。Spring作为Java开发中的主流框架，...

    跟我学Spring,Spring3学习资料

    - **DI的配置使用：** 详细介绍了如何在Spring中通过配置来实现DI，例如通过构造器注入、setter方法注入等方式。 - **循环依赖：** 指的是两个或多个类相互依赖对方，形成闭环。Spring通过三级缓存机制解决循环依赖...

    struct2.3+spring3.1+mybits3.1 核心Jar包和配置文件

    "struct2.3+spring3.1+mybits3.1 核心Jar包和配置文件"的组合正是这样一个经典的应用架构，它将Struts2、Spring3.1和MyBatis3.1这三个流行框架整合在一起，为开发者提供了强大的MVC（Model-View-Controller）架构...

    spring3.1需要的jar包

    标题中的“spring3.1需要的jar包”指的是在使用Spring框架版本3.1时所需的外部依赖库。Spring是一个开源的Java平台，它为构建企业级应用提供了全面的框架支持，包括依赖注入（DI），面向切面编程（AOP），以及用于...

Magicbox
Global site tag (gtag.js) - Google Analytics