Spring装配Bean教程之XML安装配置bean详解

前言

众所周知在Spring刚出现的时候,XML是描述配置的主要方式,在Spring的名义下,我们创建了无数行XML代码。在一定程度上,Spring成为了XML的同义词。

现在随着强大的自动化配置和Java代码的配置出现,XML不再是唯一选择,也不应该是首选,学习XML配置,更多用于维护已有的XML的配置。下面话不多说了,来一起看看详细的介绍吧。

创建XML配置规范

在使用XML配置前,需要创建一个新的配置规范,就像JavaConfig需要我们创建带有 @Configuration注解的类,而在XML配置中,需要创建一个新的XML配置文件,并且要以<beans>元素为根。

<?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:context="http://www.springframework.org/schema/context";
 xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context">

</beans>

可以看出基本的XML配置就已经比JavaConfig复杂很多。用来装配bean的最基本的XML元素包含在spring-beans模式中,在上面这个XML文件中,它被定义为根命名空间。<beans>是该模式中过的一个元素,它是所有Spring配置文件的根元素。

声明一个简单的<bean>

使用spring-beans模式中的另外一个元素:<bean>,该元素类似于JavaConfig中的 @Bean注解。

<bean class="soundsystem.SgtPeppers"/>

因为没有明确的给定ID,所以这个bean会根据全限定类名来进行命名。在本例中bean的ID将会是“soundsystem.SgtPeppers#0”。其中,“#0”是一个计数的形式,用来区别相同类型的其它bean。如果再有一个就是“#1”。

尽管自动话的bean命名方式方便,但是稍引用就会认为自动产生的名字就没有多大的用处了。因此最好的办法还是用id属性,为每个bean设置一个自己的选择的名字:

<bean id="compactDisc" class="soundsystem.SgtPeppers"/>

可以看出XML中不再需要直接负责创建SgtPeppers的实例,在基于JavaConfig的配置中,我们需要自己实例化。当Spring发现这个<bean>元素时,默认调用SgtPeppers默认的构造器来创建bean。

借助构造器注入初始化bean

在Spring XML配置中,只有一种声明bean的方式:使用元素并指定Class属性。在XML中声明ID是,会有多种配置方案,具体到构造器的注入,分为两个基本的配置方案:

  • <constructor-arg>元素
  • 使用spring 3.0所引入的c-命名空间

构造器注入bean引用,现在我们已经声明了compactDisc bean,并且SgtPeppers类实现了compactDisc接口,所以实际上我们已经有了一个可以注入到CDPlayer bean中的bean。我们所需要做的就是在XML中声明CDPlayer并通过ID引用compactDisc:

<bean id="cdPlayer" class="CDPlayer">
 <constructor-arg ref="compactDisc"/>
</bean>

作为替代的方案,也可以使用Spring的c-命名空间。c-命名空间是在Spring 3.0中引入的,它是在XML中更为简洁的描述构造器参数的方式。要使用它的话,需要在XML的顶部声明其模式:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans”;
 xmlns:c=“http://www.springframework.org/shcema/c"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance";";
 xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

在这之后我们就可以它来声明构造器的参数了,如下:

<bean id="cdPlayer" class="CDPlayer">
 <c:cd-ref="compactDisc"/>
</bean>

很显然c-命名空间的方式简练很多。具体看下写法,“c:“表示c-命名空间的前缀,“cd”表示构造器参数名(忘记的可以看下:Spring装配Bean之组件扫描和自动装配),“-ref“表示注入bean引用。

这里的cd直接引用了构造器参数的名称,可以利用参数在整个参数列表中的位置信息作为替代方案实现。

<bean id="cdPlayer" class="CDPlayer">
 <c:_0-ref="compactDisc"/>
</bean>

这个c-命名空间表示方法看起来比上面的更加怪异,我们将参数名用“0”表示,也就是参数的索引。因为XML中不允许数字作为第一个字符,所以用下划线作为前缀。使用索引来标识构造器参数感觉比使用名字更好一些,只要保存相同的顺序,就可以随意重命名参数名,如果有多个构造参数,这个方式更有用处。因为现在就一个参数,甚至可以不用标识。

<bean id="cdPlayer" class="CDPlayer">
 <c:_-ref="compactDisc"/>
</bean>

这将是最怪异的表示方法。

将字面量注入到构造器中

前面我们所做的DI通常指的是类型的装配,也就是将对象的引用装配到依赖于它的其它对象中,而有时需要引入的只是一个字面量的配置对象。现在需要创建一个新的CompactDisc实现:

package soundsystem;

public class BlankDisc implements CompactDisc {

 private String title;
 private String artist;

 public BlankDisc(String title, String artist) {
 this.title = title;
 this.artist = artist;
 }

 public void play() {
 System.out.println("Playing " + title + " by " + artist);
 }

}

在SgtPeppers中,参数都是硬编码的,但是这个CompactDisc实现不同,所以XML配置也会不同:

<bean id="compactDisc" class="soundsystem.BlankDisc">
 <constructor-arg value="Sgt. Pepper's Lonely Hearts Club Band"/>
 <constructor-arg value="The Beatles"/>
</bean>

我们再次用<constructor-arg>元素进行构造器参数的注入。但是这次我们没有使用“ref”属性,而是使用了value属性,通过该属性表明给定的要以字面量的形式注入到构造器中。

下面用c-命名空间的方式实现:

<bean id="compactDisc" class="soundsystem.BlankDisc">
 <c:_title="Sgt. Pepper's Lonely Hearts Club Band"/>
 <c:_artist="The Beatles"/>
</bean>

可以看出,装配字面量与装配引用的区别在于属性名中去掉了“-ref“的后缀。与之类似,用参数索引实现方式:

<bean id="compactDisc" class="soundsystem.BlankDisc">
 <c:_0="Sgt. Pepper's Lonely Hearts Club Band"/>
 <c:_1="The Beatles"/>
</bean>

在装配bean引用和字面量值方面,两种实现方式的功能是相同的。但是有一种情况是<constructor-arg>能够实现,c-命名空间却无法做到。

装配集合

假设BlankDisc构造函数中新增一个List类型的参数,如下:

package soundsystem;

import java.util.List;

import soundsystem.CompactDisc;

public class BlankDisc implements CompactDisc {

 private String title;
 private String artist;
 private List<String> tracks;

 public BlankDisc(String title, String artist, List<String> tracks) {
 this.title = title;
 this.artist = artist;
 this.tracks = tracks;
 }

 public void play() {
 System.out.println("Playing " + title + " by " + artist);
 for (String track : tracks) {
 System.out.println("-Track: " + track);
 }
 }

}

在声明bean的时候,我们必须要提前准备一个列表,最简单的方式就是直接设置为null。

<bean id="compactDisc" class="soundsystem.BlankDisc">
 <constructor-arg value="Sgt. Pepper's Lonely Hearts Club Band"/>
 <constructor-arg value="The Beatles”/>
 <constructor-arg><null/><constructor-arg>
</bean>

<null/>元素所做的事情,就是将null作为参数传递到构造器,但这并不是解决问题的办法,虽然在注入器能够正常执行,但是调用play()方法的时候,就会出现异常。

合理的处理方案,我们可以利用元素将其声明为一个列表:

<bean id="compactDisc" class="soundsystem.BlankDisc">
 <constructor-arg value="Sgt. Pepper's Lonely Hearts Club Band" />
 <constructor-arg value="The Beatles" />
 <constructor-arg>
 <list>
 <value>Sgt. Pepper's Lonely Hearts Club Band</value>
 <value>With a Little Help from My Friends</value>
 <value>Lucy in the Sky with Diamonds</value>
 <value>Getting Better</value>
 <value>Fixing a Hole</value>
 </list>
 </constructor-arg>
</bean>

其中,<list>元素是<constructor-arg>的子元素,这表明一个包含值的列表将会传递到构造器中。其中,<value>表示每个元素。与之类似,我们可以用代替<value>,实现bean引用列表的装配。

在装配集合方面,<constructor-arg>比c-命名空间的属性更具优势,目前使用c-命名空间的方式不能实现装配集合的功能。

设置属性

前面所有类完全是通过构造器注入的,没有使用属性的Setter方法,下面我们看下使用Spring XML实现属性注入。假设属性注入CDPlayer如下:

package soundsystem;
import org.springframework.beans.factory.annotation.Autowired;

import soundsystem.CompactDisc;
import soundsystem.MediaPlayer;

public class CDPlayer implements MediaPlayer {
 private CompactDisc compactDisc;

 @Autowired
 public void setCompactDisc(CompactDisc compactDisc) {
 this.compactDisc = compactDisc;
 }

 public void play() {
 compactDisc.play();
 }

}

这里有个需要考虑的问题,到底是构造器注入还是属性注入呢?作为一个通用的规则,对强依赖使用构造依赖,而可选的依赖使用属性注入。之前的BlankDisc属于强依赖,因此构造器注入是正确的方案。不过对于CDPlayer来说,对CompactDisc的依赖不能是强依赖的,因为即便没有把CompactDisc装入进去,CDPlayer依然具有某些功能。

因此这样是可行的:

<bean id="cdPlayer" class="soundsysten.CDPlayer" />

在创建bean的时候不会出现任何的问题,但是CDPlayer开始工作的时候就会出现异常。此时,我们可以注入CDPlayer的compactDisc属性。

<bean id="cdPlayer" class="soundsystem.CDPlayer">
 <property name="compactDisc" ref="compactDisc" />
</bean>

<property>元素为属性的Setter方法所提供的功能,和<constructor-arg>元素为构造器所提供的功能是一样的。在本例中,它引入了ID为compactDisc的bean(通过ref属性),并将其注入到compactDisc属性中。
同样的Spring为<property>提供了简介的p-命名空间的替代方案。引入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”>

</beans>

使用p-命名空间,装配compactDisc属性:

<bean id="cdPlayer"
 class="soundsystem.CDPlayer"
 p:compactDisc-ref="compactDisc" />

命名空间中属性所遵循的命名约定与c-命名空间中的属性类似。

将字面量注入到属性中

属性也可以注入字面量,这与构造器参数非常类似。我们将BlankDisc bean,通过属性注入的方式进行配置,而不是构造器的方式:

package soundsystem;

import java.util.List;

import soundsystem.CompactDisc;

public class BlankDisc implements CompactDisc {

 private String title;
 private String artist;
 private List<String> tracks;

 public void setTitle(String title) {
 this.title = title;
 }

 public void setArtist(String artist) {
 this.artist = artist;
 }

 public void setTracks(List<String> tracks) {
 this.tracks = tracks;
 }

 public void play() {
 System.out.println("Playing " + title + " by " + artist);
 for (String track : tracks) {
 System.out.println("-Track: " + track);
 }
 }

}

现在它不在是强制要求我们装配任何属性。

<bean id="reallyBlankDisc" class="soundsystem.BlankDisc"/>

当然在装配的时候不设置这些属性,CD播放的时候不能正常播放,所以还是通过<property>元素的value属性实现属性注入。

<bean id="compactDisc"
 class="soundsystem.BlankDisc">
 <property name="title" value="Sgt. Pepper's Lonely Hearts Club Band" />
 <property name="artist" value="The Beatles" />
 <property name="tracks">
 <list>
 <value>Sgt. Pepper's Lonely Hearts Club Band</value>
 <value>With a Little Help from My Friends</value>
 <value>Lucy in the Sky with Diamonds</value>
 <value>Getting Better</value>
 <value>Fixing a Hole</value>
 </list>
 </property>
 </bean>

可以看出与之前<constructor-arg>元素装配tracks是完全一样的。另一种可选方案是p-命名空间的属性来实现:

<bean id="compactDisc"
 class="soundsystem.BlankDisc"
 p:title="Sgt. Pepper's Lonely Hearts Club Band"
 p:artist="The Beatles">
 <property name="tracks">
 <list>
 <value>Sgt. Pepper's Lonely Hearts Club Band</value>
 <value>With a Little Help from My Friends</value>
 <value>Lucy in the Sky with Diamonds</value>
 <value>Getting Better</value>
 <value>Fixing a Hole</value>
 <value>She's Leaving Home</value>
 <value>Being for the Benefit of Mr. Kite!</value>
 <value>Within You Without You</value>
 <value>When I'm Sixty-Four</value>
 <value>Lovely Rita</value>
 <value>Good Morning Good Morning</value>
 <value>Sgt. Pepper's Lonely Hearts Club Band (Reprise)</value>
 <value>A Day in the Life</value>
 </list>
 </property>
 </bean>

与c-命名空间一样,装配bean引用与装配字面量的唯一区别在于是否带有“-ref”后缀,同样的p-命名空间也没有实现装配集合的功能。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对我们的支持。

(0)

相关推荐

  • Java中Spring获取bean方法小结

    Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架,如何在程序中获取Spring配置的bean呢? Bean工厂(com.springframework.beans.factory.BeanFactory)是Spring框架最核心的接口,它提供了高级IoC的配置机制.BeanFactory使管理不同类型的Java对象成为可能,应用上下文(com.springframework.context.ApplicationContext)建立在BeanFactory基础之上,提供

  • 详解Java的Spring框架下bean的自动装载方式

    Spring容器可以自动装配相互协作bean之间的关系,这有助于减少对XML配置,而无需编写一个大的基于Spring应用程序的较多的<constructor-arg>和<property>元素. 自动装配模式: 有下列自动装配模式,可用于指示Spring容器使用自动装配依赖注入.使用<bean/>元素的autowire属性为一个bean定义中指定自动装配模式. byName模式 这种模式规定由自动装配属性名称.Spring容器在外观上自动线属性设置为byName的XML

  • Java类获取Spring中bean的5种方式

    获取Spring中的bean有很多种方式,再次总结一下: 第一种:在初始化时保存ApplicationContext对象 ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml"); ac.getBean("beanId"); 说明:这种方式适用于采用Spring框架的独立应用程序,需要程序通过配置文件手工初始化Spring. 第二种:通过Spring提供

  • Spring装配Bean之用Java代码安装配置bean详解

    前言 本文主要给大家介绍了关于Spring之利用Java代码安装配置bean的相关内容,尽管通过组件扫描和自动装配实现Spring的自动化配置很方便也推荐,但是有时候自动配置的方式实现不了,就需要明确显示的配置Spring.比如说,想要将第三方库中的组件装配到自己的应用中,这样的情况下,是没办法在它的类上添加 @Compnent和 @Autowired注解的. 在这种情况下,需要使用显示装配的方式,可以分别通过Java和XML实现,推荐使用Java的方式,因为更加强大,类型安全并且重构友好,因为

  • 详解Java的Spring框架中bean的定义以及生命周期

    bean的定义 形成应用程序的骨干是由Spring IoC容器所管理的对象称为bean.bean被实例化,组装,并通过Spring IoC容器所管理的对象.这些bean由容器提供,例如,在XML的<bean/>定义,已经看到了前几章的形式配置元数据创建. bean定义包含所需要的容器要知道以下称为配置元数据的信息: 如何创建一个bean Bean 生命周期的详细信息 Bean 依赖关系 上述所有配置元数据转换成一组的下列属性构成每个bean的定义. Spring配置元数据 Spring IoC

  • Spring中多配置文件及引用其他bean的方式

    Spring多配置文件有什么好处? 按照目的.功能去拆分配置文件,可以提高配置文件的可读性与维护性,如将配置事务管理.数据源等少改动的配置与配置bean单独分开. Spring读取配置文件的几种方式: 1.使用Spring自身提供的ApplicationContext方式读取 在Java程序中可以使用ApplicationContext两个实现类ClassPathXmlApplicationContext以及FileSystemXmlApplicationContext来读取多个配置文件,他们的

  • 详解Java的Spring框架中bean的注入集合

    使用value属性和使用<property>标签的ref属性在你的bean配置文件中的对象引用,这两种情况下可以处理单值到一个bean,如果你想通过多元值,如Java Collection类型List, Set, Map 及 Properties.要处理这种情况,Spring提供了四种类型的如下集合的配置元素: 可以使用<list> 或<set> 来连接任何实现java.util.Collection或数组. 会遇到两种情况(a)将收集的直接的值及(b)传递一个bean

  • spring动态bean注册示例分享

    1.在一些特殊的场景中需要动态向spring注册bean2.spring版本2.5.6 复制代码 代码如下: public class ServiceServiceImpl implements ServiceService, ApplicationContextAware { @Override public void setApplicationContext(org.springframework.context.ApplicationContext applicationContext)

  • 解析Java中如何获取Spring中配置的bean

    一.什么是Spring?Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架 二.如何在程序中获取Spring配置的bean呢?方法一:在初始化时保存ApplicationContext对象代码: 复制代码 代码如下: ApplicationContext ac = new FileSystemXmlApplicationContex("applicationContext.xml");    ac.getBean("beanId"); 说明:

  • Spring的自动装配Bean的三种方式

    spring的自动装配功能的定义:无须在Spring配置文件中描述javaBean之间的依赖关系(如配置<property>.<constructor-arg>).IOC容器会自动建立javabean之间的关联关系. 如果没有采用自动装配的话,手动装配我们通常在配置文件中进行实现:一下代码就是手动装配: <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="ht

随机推荐