spring-framework-中文文档三:依赖注入DI

5.4依赖性

典型的企业应用程序不包含单个对象（或Spring的说法中的bean）。即使最简单的应用程序也有几个对象一起工作来展示最终用户将其视为一个连贯的应用程序。下一节将介绍如何从定义许多独立的bean定义到完全实现的应用程序，在这些应用程序中对象协作实现目标。

5.4.1依赖注入

依赖注入（DI）是一个过程，通过这种过程，对象可以通过构造函数参数，工厂方法参数或者在构造或返回对象实例后设置的属性来定义它们的依赖关系，也就是说，它们使用的其他对象从工厂方法。容器 在创建bean时会注入这些依赖关系。这个过程从根本上说是相反的，因此名为 控制反转（IoC），它本身通过使用类的直接构造或服务定位器模式来控制它自己的依赖关系的实例化或位置。

代码与DI原理相比更加清晰，并且在对象提供依赖关系时解耦更有效。该对象不查找其依赖项，并且不知道依赖项的位置或类。因此，您的类变得更容易测试，特别是当依赖关系位于接口或抽象基类上时，它们允许在单元测试中使用存根或模拟实现。

DI存在两种主要的变体，基于构造器的依赖注入和基于Setter的依赖注入。

基于构造函数的依赖注入

基于构造器的 DI通过容器调用具有多个参数的构造函数完成，每个参数表示一个依赖项。调用static具有特定参数的工厂方法来构造bean几乎是等价的，本讨论static类似地将参数视为构造函数和工厂方法。以下示例显示了只能通过构造函数注入进行依赖注入的类。请注意，这个类没有什么 特别之处，它是一个POJO，它不依赖于容器特定的接口，基类或注释。

public class SimpleMovieLister {

  // the SimpleMovieLister has a dependency on a MovieFinder
  private MovieFinder movieFinder;

  // a constructor so that the Spring container can 'inject' a MovieFinder
  public SimpleMovieLister(MovieFinder movieFinder) {
      this.movieFinder = movieFinder;
  }

  // business logic that actually 'uses' the injected MovieFinder is omitted...
}

构造函数参数解析

使用参数的类型发生构造函数参数解析匹配。如果bean定义的构造函数参数中没有可能存在的歧义，那么在bean定义中定义构造函数参数的顺序是当实例化bean时将这些参数提供给相应构造函数的顺序。考虑以下课程：

package x.y;

public class Foo {

  public Foo(Bar bar, Baz baz) {
      // ...
  }
}

没有潜在的歧义存在，假设 Bar和Baz类不通过继承相关。因此，以下配置可以正常工作，并且不需要在<constructor-arg/>元素中明确指定构造函数参数索引和/或类型 。

<beans>
  <bean id="foo" class="x.y.Foo">
      <constructor-arg ref="bar"/>
      <constructor-arg ref="baz"/>
  </bean>

  <bean id="bar" class="x.y.Bar"/>
  <bean id="baz" class="x.y.Baz"/>

</beans>

当引用另一个bean时，类型是已知的，并且可以发生匹配（就像前面的例子那样）。当使用简单类型时，例如 <value>true<value>Spring无法确定值的类型，因此无法在没有帮助的情况下按类型进行匹配。考虑以下课程：

package examples;

public class ExampleBean {

  // No. of years to the calculate the Ultimate Answer
  private int years;

  // The Answer to Life, the Universe, and Everything
  private String ultimateAnswer;

  public ExampleBean(int years, String ultimateAnswer) {
      this.years = years;
      this.ultimateAnswer = ultimateAnswer;
  }
}

构造函数参数类型匹配

在前面的场景中，如果使用属性明确指定构造函数参数的类型，容器 可以使用简单类型的类型匹配 type。例如：

<bean  id = “exampleBean”  class = “examples.ExampleBean” > 
<constructor-arg  type = “int”  value = “7500000” /> 
<constructor-arg  type = “java.lang.String”  value = “42” / > 
</ bean>

构造函数参数索引

使用该index属性来明确指定构造函数参数的索引。例如：

<bean  id = “exampleBean”  class = “examples.ExampleBean” > 
<constructor-arg  index = “0”  value = “7500000” /> 
<constructor-arg  index = “1”  value = “42” /> 
</ bean >

除了解决多个简单值的歧义之外，指定索引还解决了构造函数具有两个相同类型参数的含糊问题。请注意，该索引是基于0的。

构造函数参数名称

从Spring 3.0开始，您还可以使用构造函数参数名称进行值消歧：

<bean  id = “exampleBean”  class = “examples.ExampleBean” > 
<constructor-arg  name = “years”  value = “7500000” /> 
<constructor-arg  name = “ultimateanswer”  value = “42” /> 
</ bean >

请记住，要使这项工作脱离框架，您的代码必须在启用了调试标志的情况下编译，以便Spring可以从构造函数中查找参数名称。如果你不能用调试标志编译你的代码（或者不想），你可以使用 @ConstructorProperties JDK标注明确你的构造函数参数。示例类将不得不如下所示：

package examples;

public class ExampleBean {

  // Fields omitted

  @ConstructorProperties({"years", "ultimateAnswer"})
  public ExampleBean(int years, String ultimateAnswer) {
      this.years = years;
      this.ultimateAnswer = ultimateAnswer;
  }
}

基于Setter的依赖注入

在调用无参数构造函数或无参数static工厂方法来实例化bean之后，基于Setter的 DI通过调用bean上的容器调用setter方法来完成。

以下示例显示了一个只能使用纯setter注入进行依赖注入的类。这个类是传统的Java。这是一个POJO，它不依赖于容器特定的接口，基类或注释。

public class SimpleMovieLister {

  // SimpleMovieLister对MovieFinder有依赖性
  private MovieFinder movieFinder;

  //一个setter方法，以便Spring容器可以'注入'一个MovieFinder
  public void setMovieFinder(MovieFinder movieFinder) {
      this.movieFinder = movieFinder;
  }

  //实际“使用”注入的MovieFinder的业务逻辑被省略。
}

它ApplicationContext支持它所管理的bean的基于构造函数和基于setter的DI。它也支持基于setter的DI之后，通过构造函数方法已经注入了一些依赖项。你在的形式配置的依赖关系BeanDefinition，这与你使用的PropertyEditor情况下，将属性从一种格式转换为另一种。然而，大多数Spring用户不直接使用这些类（以编程方式），而是使用XML定义文件，然后将其内部转换为这些类的实例，并用于加载整个Spring IoC容器实例。

基于构造函数或基于setter的DI？

既然你可以混合使用基于构造函数和基于Setter的DI，那么使用强制依赖性的构造函数参数和可选依赖性的设置符是一个很好的经验法则。请注意，在 setter上使用@Required注释可以用来使setter需要依赖关系。

Spring团队通常主张setter注入，因为大量的构造函数参数可能会变得笨拙，特别是当属性是可选的时候。Setter方法也使该类的对象可以重新配置或稍后重新注入。通过JMX MBeans进行管理是一个引人注目的用例。

一些纯粹主义者喜欢基于构造函数的注入。提供所有对象依赖性意味着对象总是以完全初始化的状态返回给客户端（调用）代码。缺点是物体变得不适合重新配置和重新注入。

使用对某个班级最有意义的DI。有时，在处理您没有来源的第三方课程时，您可以选择。遗留类可能不会公开任何setter方法，因此构造函数注入是唯一可用的DI。

依赖性解决过程

该容器执行bean依赖性解析如下：

1. 使用ApplicationContext描述所有bean的配置元数据创建和初始化。配置元数据可以通过XML，Java代码或注释来指定。

2. 对于每个bean，如果使用该属性而不是普通构造函数，则它的依赖关系以属性，构造函数参数或静态工厂方法的参数的形式表示。当bean被实际创建时，这些依赖被提供给bean 。

3. 每个属性或构造函数参数都是要设置的值的实际定义，或者是对容器中另一个bean的引用。

4. 作为值的每个属性或构造函数参数都从其指定的格式转换为该属性或构造函数参数的实际类型。默认情况下，Spring能够转换成字符串格式提供给所有的内置类型，比如数值 int，long， String，boolean，等。

Spring容器在创建容器时验证每个bean的配置，包括验证bean引用属性是否引用有效的bean。但是，在实际创建 bean之前，bean属性本身不会被设置。Beans是单身作用域并且被设置为预先实例化的（默认的）是在创建容器时创建的。范围在第5.5节“Bean范围”中定义。否则，只有在请求时才创建bean。创建一个bean可能会导致创建一个bean图，因为bean的依赖关系及其依赖关系的依赖关系（等等）被创建和分配。

循环依赖

如果您主要使用构造函数注入，则可能会创建一个无法解析的循环依赖方案。

例如：类A需要通过构造函数注入的类B的实例，而类B需要通过构造函数注入的类A的实例。如果将类A和B的Bean配置为相互注入，则Spring IoC容器会在运行时检测到此循环引用，并引发一个 BeanCurrentlyInCreationException。

一种可能的解决方案是编辑某些类的源代码，以便由setter而不是构造器进行配置。或者，避免构造函数注入并仅使用setter注入。换句话说，虽然不推荐，但您可以使用setter注入来配置循环依赖关系。

与典型情况（没有循环依赖）不同，bean A和bean B之间的循环依赖关系迫使其中一个bean在被完全初始化之前注入另一个bean（经典的鸡/鸡蛋场景）。

通常你可以相信春天做正确的事情。它在容器加载时检测配置问题，比如引用不存在的bean和循环依赖关系。当bean实际创建时，Spring会尽可能晚地设置属性并解决依赖关系。这意味着，如果在创建该对象或其某个依赖关系时遇到问题，那么请求对象时，正确加载的Spring容器可能会稍后生成异常。例如，由于缺少或无效的属性，bean抛出异常。某些配置问题的可能延迟可见性是原因ApplicationContext 实现默认预先实例化单例bean。在实际需要这些bean之前，为了创建这些bean需要一定的时间和内存，您ApplicationContext会在创建时发现配置问题 ，而不是稍后。您仍然可以重写此默认行为，以便单例bean将会进行延迟初始化，而不是预先实例化。

如果不存在循环依赖关系，则当一个或多个协作bean被注入到一个依赖bean中时，每个协作bean都被注入到依赖bean 之前完全配置。这意味着如果bean A对bean B有依赖性，Spring IoC容器在调用bean A上的setter方法之前完全配置bean B.换句话说，bean被实例化（如果不是预先实例化的单例），它的将设置依赖关系，并调用相关的生命周期方法（例如配置的init方法或InitializingBean回调方法）。

依赖注入的例子

以下示例使用基于设置者的DI的基于XML的配置元数据。Spring XML配置文件的一小部分指定了一些bean定义：

<bean id="exampleBean" class="examples.ExampleBean">

<!-- setter injection using the nested <ref/> element -->
<property name="beanOne"><ref bean="anotherExampleBean"/></property>

<!-- setter injection using the neater 'ref' attribute -->
<property name="beanTwo" ref="yetAnotherBean"/>
<property name="integerProperty" value="1"/>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>
<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>

public class ExampleBean {

  private AnotherBean beanOne;
  private YetAnotherBean beanTwo;
  private int i;

  public void setBeanOne(AnotherBean beanOne) {
      this.beanOne = beanOne;
  }

  public void setBeanTwo(YetAnotherBean beanTwo) {
      this.beanTwo = beanTwo;
  }

  public void setIntegerProperty(int i) {
      this.i = i;
  }
}

在前面的例子中，setters被声明为与XML文件中指定的属性相匹配。以下示例使用基于构造函数的DI：

<bean id="exampleBean" class="examples.ExampleBean">

<!-- constructor injection using the nested <ref/> element -->
<constructor-arg>
  <ref bean="anotherExampleBean"/>
</constructor-arg>

<!-- constructor injection using the neater 'ref' attribute -->
<constructor-arg ref="yetAnotherBean"/>

<constructor-arg type="int" value="1"/>
</bean>

<bean id="anotherExampleBean" class="examples.AnotherBean"/>
<bean id="yetAnotherBean" class="examples.YetAnotherBean"/>

public class ExampleBean {

  private AnotherBean beanOne;
  private YetAnotherBean beanTwo;
  private int i;

  public ExampleBean(
      AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {
      this.beanOne = anotherBean;
      this.beanTwo = yetAnotherBean;
      this.i = i;
  }
}

在bean定义中指定的构造函数参数将用作参数的构造函数 ExampleBean。

现在考虑一下这个例子的一个变体，在这里不是使用构造函数，而是告诉Spring调用一个static工厂方法来返回对象的一个​​实例：

<bean  id = “exampleBean”  class = “examples.ExampleBean” 
    factory-method = “createInstance” > 
<constructor-arg  ref = “anotherExampleBean” /> 
<constructor-arg  ref = “yetAnotherBean” /> 
<constructor-arg  value = “1” /> 
</ bean> 

<bean  id = “anotherExampleBean”  class = “examples.AnotherBean” /> 
<bean  id = “yetAnotherBean” class = “examples.YetAnotherBean”/>

public class ExampleBean {

  // a private constructor
  private ExampleBean(...) {
    ...
  }
  
  // a static factory method; the arguments to this method can be
  // considered the dependencies of the bean that is returned,
  // regardless of how those arguments are actually used.
  public static ExampleBean createInstance (
          AnotherBean anotherBean, YetAnotherBean yetAnotherBean, int i) {

      ExampleBean eb = new ExampleBean (...);
      // some other operations...
      return eb;
  }
}

 

static工厂方法的参数是通过<constructor-arg/>元素提供的，就像实际使用构造函数一样。工厂方法返回的类的类型不必与包含static 工厂方法的类属于同一类型，尽管在本例中是这样。实例（非静态）工厂方法将以基本相同的方式使用（除了使用factory-bean属性而不是class属性），因此在此不讨论细节。

5.4.2详细的依赖和配置

如前一节所述，您可以将bean属性和构造函数参数定义为对其他托管bean（协作者）的引用，或者将它们定义为内联定义的值。Spring的基于XML的配置元数据为此支持其元素<property/>和 <constructor-arg/>元素中的子元素类型 。

直线值（基元，Strings等等）

在value所述的属性 <property/>元素指定属性或构造器参数的人类可读的字符串表示。如前所述，JavaBeans PropertyEditors用于将这些字符串值从a转换String为属性或参数的实际类型。

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<!-- results in a setDriverClassName(String) call -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
<property name="username" value="root"/>
<property name="password" value="masterkaoli"/>
</bean>

以下示例使用p-namespace进行更简洁的XML配置。

<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.xsd">

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"
      destroy-method="close"
      p:driverClassName="com.mysql.jdbc.Driver"
      p:url="jdbc:mysql://localhost:3306/mydb"
      p:username="root"
      p:password="masterkaoli"/>

</beans>

前面的XML更简洁;然而，错字是在运行时而不是设计时发现的，除非您在创建bean定义时使用支持自动属性完成的IDE（例如IntelliJ IDEA或SpringSource Tool Suite（STS））。强烈建议这种IDE帮助。 您还可以将java.util.Properties实例配置为：

<bean id="mappings"
    class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

 <!-- typed as a java.util.Properties -->
 <property name="properties">
    <value>
       jdbc.driver.className=com.mysql.jdbc.Driver
       jdbc.url=jdbc:mysql://localhost:3306/mydb
    </value>
 </property>
</bean>

Spring容器通过使用JavaBeans 机制将<value/>元素内部的文本 转换为 java.util.Properties实例PropertyEditor。这是一个很好的捷径，它是Spring团队赞成<value/>在value属性样式上使用嵌套元素的少数几个地方之一。

该idref元素

该idref元素只是一种防错的方式，将容器中另一个bean 的id（字符串值 - 不是引用）传递给 <constructor-arg/>or <property/>元素。

<bean  id = “theTargetBean”  class = “...” />

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

上面的bean定义片段 与下面的片段完全等价（在运行时）：

<bean  id = “theTargetBean”  class = “...” />

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

 

第一种形式比第二种形式更可取，因为使用 idref标签允许容器在部署时验证 所引用的命名bean实际存在。在第二种变体中，不会对传递给bean targetName属性 的值执行验证 client。当clientbean实际实例化时，只会发现错误（最有可能致命的结果）。如果这个clientbean是一个 原型 bean，那么这个错字和产生的异常可能只会在容器被部署后很长时间才被发现。

此外，如果被引用的bean位于同一个XML单元中，并且bean名称是bean id，则可以使用该 local属性，该属性允许XML解析器本身在XML文档分析时更早地验证bean id。

<property  name = “targetName” > 
 <！ - 一个ID为'theTargetBean'的bean必须存在; 否则会抛出异常 - >
  <idref  local = “theTargetBean” /> 
</ property>

其中<IDREF />元素带来值A共同的地方（至少在早期比Spring 2.0版本）是在配置AOP拦截在 ProxyFactoryBeanbean定义。指定拦截器名称时使用<idref />元素可以防止拼写错误拦截器ID。

参考其他豆类（协作者）

该ref元素是一个<constructor-arg/>或 <property/>定义元素中的最后一个 元素。在这里，您将bean的指定属性的值设置为对由容器管理的另一个bean（协作者）的引用。被引用的bean是其属性将被设置的bean的依赖项，并且在属性设置之前根据需要初始化它。（如果协作者是单身bean，它可能已被容器初始化。）所有引用最终都是对另一个对象的引用。划定范围和有效性取决于是否通过指定其他对象的ID /名称 bean，local,或 parent属性。

通过标记bean 属性指定目标bean <ref/>是最通用的形式，并且允许创建对同一个容器或父容器中的任何bean的引用，而不管它是否位于同一个XML文件中。该bean属性的值可能id与目标bean 的属性相同，或者与目标bean属性中的值之一相同name。

<ref  bean = “someBean” />

通过local 属性指定目标bean 利用XML解析器验证同一文件中的XML id引用的能力。local属性的值 必须id与目标bean 的属性相同 。如果在同一文件中找不到匹配的元素，则XML解析器会发出错误。因此，如果目标bean位于同一个XML文件中，则使用本地变体是最佳选择（以便尽可能早地了解错误）。

<ref  local = “someBean” />

通过parent 属性指定目标Bean 将创建对当前容器的父容器中的bean的引用。该parent 属性的值可能id与目标bean 的属性或目标bean 的属性中的一个值相同name，并且目标bean必须位于当前bean的父容器中。您主要在具有容器层次结构时使用此bean参考变体，并且想要使用与父bean名称相同的代理将父容器中的现有bean包装在父容器中。

<！ - 在父上下文中 - >
 <bean  id = “accountService”  class = “com.foo.SimpleAccountService” > 
  <！ - 根据需要插入依赖关系 - >
 </ bean>



<！ - 在子（后代）上下文中 - >
 <bean  id = “accountService”   < -  bean名称与父bean相同 - >
    类= “的org.springframework.aop.framework.ProxyFactoryBean”>
    <property  name = “target” > 
        <ref  parent = “accountService” />   <！ - 注意我们如何引用父bean  - >
     </ property> 
  <！ - 根据需要插入其他配置和依赖关系 - >
 </ bean>

内置bean

甲<bean/>内部的元件 <property/>或 <constructor-arg/>元件定义了一个所谓的 内部bean。

<bean  id = “outer”  class = “...” > 
<！ - 而不是使用对目标bean的引用，只需定义目标bean inline  - >
 <property  name = “target” > 
  <bean  class = “com.example.Person” >  <！ - 这是内部bean  - >
     <property  name = “name”  value = “Fiona Apple” /> 
    <property  name = “age”  value = “25” /> 
  < / bean> 
</ property> 
</ bean>

内部bean定义不需要定义的id或名称; 该容器忽略这些值。它也忽略了 scope国旗。内部bean 始终是匿名的，并且它们 始终使用外部bean创建。这是 不是可以内部bean注入到协作不是进入封闭豆等豆类。

集合

在<list/>， <set/>，<map/>，和 <props/>元素，你将Java的性能和参数Collection类型 List，Set， Map，和 Properties分别。

<bean  id = “moreComplexObject”  class = “example.ComplexObject” > 
<！ - 导致setAdminEmails（java.util.Properties）调用 - >
 <property  name = “adminEmails” > 
  <props> 
      <prop  key = “管理员“ > [e-mail] </ prop> 
      <prop  key = ”support“ > [e-mail] </ prop> 
      <prop  key = ”development“ > [e-mail] </ prop>
  </ props> 
</ property>
<！ - 产生一个setSomeList（java.util.List）调用 - >
 <property  name = “someList” > 
  <list> 
      <value>一个列表元素，后跟一个引用 </ value> 
      <ref  bean = “myDataSource “ /> 
  </ list> 
</ property> 
<！ - 导致setSomeMap（java.util.Map）调用 - >
 <property  name = ”someMap“ > 
  <map> 
      <entry  key = ”entry“  value = “只是一些字符串” /> 
      <entry  key = “a ref”  value-ref = “myDataSource”/> 
  </ map> 
</ property> 
<！ - 导致setSomeSet（java.util.Set）调用 - >
 <property  name = “someSet” > 
  <set> 
      <value>只是一些字符串</ value> 
      <ref  bean = “myDataSource” /> 
  </ set> 
</ property> 
</ bean>

映射键或值或设置值的值也可以是以下任何元素：

bean | ref | idref | 列表| set | 地图| 道具| 值| 空值

集合合并

从Spring 2.0开始，容器支持 合并集合。应用程序开发人员可以定义一个父风格<list/>， <map/>，<set/>或 <props/>元素，并有孩子式的 <list/>，<map/>，<set/>或<props/> 元素继承和父集合覆盖值。也就是说，子集合的值是合并父集合和子集合元素的结果，子集合元素覆盖父集合中指定的值。

这部分关于合并讨论了父子bean机制。不熟悉父代和子代bean定义的读者可能希望在继续之前阅读相关章节。

以下示例演示了集合合并：

<beans>
<bean id="parent" abstract="true" class="example.ComplexObject">
  <property name="adminEmails">
      <props>
          <prop key="administrator">[e-mail]</prop>
          <prop key="support">[e-mail]</prop>
      </props>
  </property>
</bean>
<bean id="child" parent="parent">
  <property name="adminEmails">
      <!-- the merge is specified on the *child* collection definition -->
      <props merge="true">
          <prop key="sales">[e-mail]</prop>
          <prop key="support">[e-mail]</prop>
      </props>
  </property>
</bean>
<beans>

注意在bean定义的merge=true属性的<props/>元素上使用 adminEmails属性 child。当 childbean被容器解析并实例化时，生成的实例具有一个adminEmailsProperties 集合，该 集合包含合并子集合 adminEmails与父 adminEmails集合的结果。

administrator=[e-mail] 
sales=[e-mail] 
support = [e-mail]

孩子Properties集合的值设置继承父所有属性元素 <props/>，和孩子的为值 support值将覆盖父集合的价值。

这一合并行为同样适用于 <list/>，<map/>和 <set/>集合类型。在<list/>元素的特定情况下，与List集合类型相关联的语义（即ordered值集合的概念）被保留; 父项的值在所有子项列表的值之前。在的情况下Map， Set和 Properties集合类型，没有顺序存在。因此，没有排序的语义在背后的关联的集合类型的效果 Map，Set以及 Properties该容器内部使用实现类型。

收集合并的限制

您不能合并不同的集合类型（如a Map和a List），并且如果您确实尝试这样做，Exception则会引发适当的集合类型 。该 merge属性必须在较低的继承的子定义上指定; merge 在父集合定义上指定属性是多余的，并且不会导致所需的合并。合并功能仅在Spring 2.0及更高版本中可用。

强类型集合（仅限Java 5+）

在Java 5及更高版本中，您可以使用强类型集合（使用泛型类型）。也就是说，可以声明一个 Collection只能包含String元素的类型（例如）。如果您使用Spring将强类型依赖注入 Collection到bean中，则可以利用Spring的类型转换支持，以便强类型Collection 实例的元素在添加到类型之前转换为适当的类型Collection。

 

public class Foo {

  private Map<String, Float> accounts;

  public void setAccounts(Map<String, Float> accounts) {
      this.accounts = accounts;
  }
}

<beans>
  <bean id="foo" class="x.y.Foo">
      <property name="accounts">
          <map>
              <entry key="one" value="9.99"/>
              <entry key="two" value="2.75"/>
              <entry key="six" value="3.99"/>
          </map>
      </property>
  </bean>
</beans>

当bean 的accounts属性 foo准备注入时，有关强类型的元素类型的泛型信息 Map<String, Float>可通过反射获得。因此，Spring的类型转换基础结构将各种值元素识别为类型 Float和字符串值9.99, 2.75，并将3.99其转换为实际Float类型。

空和空字符串值

春天将属性等的空论据视为空白 Strings。以下基于XML的配置元数据片段将email属性设置为空 String值（“”）

<bean  class = “ExampleBean” > 
<property  name = “email”  value = “” /> 
</ bean>

前面的示例等同于以下Java代码： exampleBean.setEmail("")。该 <null/>元素处理null 值。例如

<bean  class = “ExampleBean” > 
<property  name = “email” > <null /> </ property> 
</ bean>

以上配置相当于以下Java代码： exampleBean.setEmail(null)。

带有p命名空间的XML快捷方式

p-名称空间使您可以使用bean 元素的属性（而不是嵌套 <property/>元素）来描述属性值和/或合作bean。

Spring 2.0和更高版本支持带有命名空间的可扩展配置格式，这些命名空间基于XML模式定义。beans本章讨论的配置格式在XML Schema文档中定义。但是，p-namespace并未在XSD文件中定义，而只存在于Spring的核心中。

以下示例显示了解析为相同结果的两个XML片段：第一个使用标准XML格式，第二个使用p命名空间。

<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.xsd“ > 

  <bean  name = “classic”  class = “com.example.ExampleBean” > 
      <property  name = “email”  value = “ [e-mail] ”/> 
  </ bean> 

  <bean name = “p-namespace”  class = “com.example.ExampleBean” 
        p：email = “ [e-mail] ” /> 
</ beans>

该示例在bean定义中显示了名为email的p名称空间中的一个属性。这告诉Spring包含一个属性声明。如前所述，p-名称空间没有模式定义，因此您可以将该属性的名称设置为属性名称。

下一个示例包含两个更多的bean定义，这两个定义都可以引用另一个bean：

<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.xsd">

  <bean name="john-classic" class="com.example.Person">
      <property name="name" value="John Doe"/>
      <property name="spouse" ref="jane"/>
  </bean>

  <bean name="john-modern"
      class="com.example.Person"
      p:name="John Doe"
      p:spouse-ref="jane"/>

  <bean name="jane" class="com.example.Person">
      <property name="name" value="Jane Doe"/>
  </bean>
</beans>

 

正如你所看到的，这个例子不仅包含使用p-命名空间的属性值，还使用特殊格式来声明属性引用。第一个bean定义用于 <property name="spouse" ref="jane"/>创建从bean john到bean 的引用jane，而第二个bean定义 p:spouse-ref="jane"用作属性来完成同样的事情。在这种情况下spouse是属性名称，而该-ref部分表明这不是一个正值，而是对另一个bean的引用。

p-名称空间不如标准XML格式那么灵活。例如，声明属性引用的格式与结尾的属性发生冲突Ref，而标准的XML格式则不会。我们建议您谨慎选择您的方法，并将其传达给您的团队成员，以避免生成同时使用所有三种方法的XML文档。

带有c-namespace的XML快捷方式

类似于“带有p-namespace的XML快捷方式”一节，Spring 3.1中新引入的c-namespace允许使用内联属性来配置构造函数参数，而不是嵌套constructor-arg 元素。

让我们回顾一下从例子中称为“基于构造函数的依赖注入”一节与c命名空间：

 

<beans xmlns = “http://www.springframework.org/schema/beans” 
  xmlns：xsi = “http://www.w3.org/2001/XMLSchema-instance” 
  xmlns：c = “http：// www .springframework.org /模式/ C” 
  的xsi：的schemaLocation = “http://www.springframework.org/schema/beans
       HTTP：//www.springframework.org/schema/beans/spring-beans.xsd”>
 
  <bean id = “bar”  class = “xyBar” /> 
  <bean id = “baz”  class = “xyBaz” /> 

  < - 'traditional'declaration - > 
  <bean id = “foo” class = “xyFoo” >
      <constructor-arg ref = “bar” /> 
      <constructor-arg ref = “baz” /> 
      <constructor-arg value = “ [e-mail] ” /> 
  </ bean> 

  < - 'c-namespace'声明- > 
  <bean id = “foo”  class = “xyFoo” c：bar-ref = “bar” c：baz-ref = “baz” c：email = “ [e-mail] ” > 

</ beans>

该c:命名空间使用相同的约定作为p:一个（后-ref为bean引用），供他们的名字设置构造函数的参数。同样，即使它没有在XSD模式中定义（但它存在于Spring内核中），也需要声明它。

对于构造函数参数名称不可用的罕见情况（通常如果字节码是在没有调试信息的情况下编译的），可以使用回退参数索引：

< - 'c-namespace'索引声明 - > 
<bean id = “foo”  class = “xyFoo” c：_ 0 -ref = “bar” c：_ 1 -ref = “baz” >

由于XML语法，索引表示法要求存在前导_，因为XML属性名称不能以数字开头（即使某些IDE允许）。

实际上，构造器解析机制在匹配参数方面非常有效，所以除非真的需要，否则我们建议在整个配置中使用名称符号。

复合属性名称

在设置bean属性时，只要最终属性名称以外的路径的所有组件都不是，就可以使用复合或嵌套属性名称null。考虑下面的bean定义。

<bean  id = “foo”  class = “foo.Bar” > 
<property  name = “fred.bob.sammy”  value = “123” /> 
</ bean>

该foobean有一个fred 属性，该属性具有一

赞 (0)

打赏 微信扫一扫

相关文章:

• 

  Puppet使用方法总结

  puppet是一个开源的软件自动化配置和部署工具，它使用简单且功能强大，正得到了越来越多地关注，现在很多大型IT公司均在使用puppet对集群中的软件进行管理和... [阅读全文]
• 

  让Mac OS X系统启动时执行脚本的方法

  这篇文章主要介绍了让Mac OS X系统启动时执行脚本的方法,需要的朋友可以参考下... 15-10-10 [阅读全文]
• 

  攻克python3（第一篇）

  python是一门什么样的语言？ 经过几天的敲代码，发现它语言的不同，C语言是全部编译一遍，然后同一报错，但python不同，python是边运行边... [阅读全文]
• 

  OS X El Capitan 下怎么修复磁盘权限？

  OS X El Capitan 下怎么修复磁盘权限？苹果为Mac 最新的OS X El Capitan 10.11系统中，新增了很多功能，OS X El Cap... [阅读全文]
• 

  Java File IO学习笔记

  声明：以下转载自：Java中的File文件类详解 文件操作在Java的io操作中占有十分重要的地位，本文从以下几个方面来接受Java中对文件的操作。... [阅读全文]

版权声明：本文内容由互联网用户贡献，该文观点仅代表作者本人。本站仅提供信息存储服务，不拥有所有权，不承担相关法律责任。 如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 [e-mail] 举报，一经查实将立刻删除。

发表评论

验证码：

最近更新的文章

• 苹果OS X El Captain升级需注意哪些？OS X El Captain 10.11安装前准备工作
• spring-framework-中文文档二:Bean概述
• wordpress | WP Mail SMTP使用QQ邮箱发布失败的解决办法
• spring-framework-中文文档三:依赖注入DI
• 错误和异常处理（7）
• os x el capitan怎么安装 os x el capitan详细安装图文教程
• linux系统中怎么结束boa进程?
• 苹果mac系统中Safari浏览器F12不能调试该怎么办？
• 网络IO超时的几种实现
• 使用freemarker生成自定义代码

推荐阅读

'); (window.slotbydup = window.slotbydup || []).push({ id: "u5885079", container: s }); })();

大家感兴趣的文章

• 1 创建Gradle工程出现Could not install Gradle distribution from 'https://services.gradle.org/distributions/gradleXX'.问题解决
• 2 Tomcat访问项目出现HTTP状态404-未找到，类型 状态报告 描述 源服务器未能找到目标资源的表示或者是不愿公开一个已经存在的资源表示。Apache Tomcat/9.0.40
• 3 SpringMVC入门案例访问页面报错404源服务器未能找到目标资源的表示或者是不愿公开一个已经存在的资源表示，Tomcat9.0.41.
• 4 SpringBoot 2.0 报错: Failed to configure a DataSource: 'url' attribute is not specified and no embe
• 5 SpringBoot与Angular2的集成示例
• 6 最新IntelliJ IDEA 2020.2永久激活码(亲测有效)
• 7 idea启动不了Tomcat，报错war exploded: Artifact is being deployed, please wait...
• 8 java导入excel操作多sheet页上传
• 9 spring boot 错误：Check your ViewResolver setup
• 10 mybatis-plus使用@EnumValue处理枚举类型的示例代码

'); (window.slotbydup = window.slotbydup || []).push({ id: "u5885079", container: s }); })();