Spring实战(3)：装配Bean——自动化、JavaConfig、XML

最新推荐文章于 2022-10-24 19:20:18 发布

SillyDuckkk

最新推荐文章于 2022-10-24 19:20:18 发布

阅读量1k

点赞数

分类专栏： Spring

本文链接：https://blog.csdn.net/hxllhhy/article/details/79922416

版权

Spring 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

装配是什么？

创建应用对象之间协作关系的行为通常称为装配（wiring），这也是DI的本质。
我们必须要告诉Spring要创建哪些bean并且如何将其装配在一起。

Spring提供了三种主要的装配机制：

在XML中进行显式配置
在Java中进行显式配置
隐式的bean发现机制和自动装配

Spring的配置风格是可以互相搭配的，但应尽可能地使用自动配置的机制，因其使用起来要方便的多，显式配置越少越好。显式配置越少，代码就越容易维护。而基于Java和XML相比，JavaConfig的安全性比XML要好，并且功能更强大。

所以我们先来看Spring的自动化配置。

自动化装配Bean——便利

Spring从两个角度来实现自动化装配：

组件扫描（component scanning）：Spring会自动发现应用上下文中所创建的Bean。
自动装配（autowiring）：Spring自动满足Bean之间的依赖。

组件扫描和自动装配组合在一起就能使我们的显式配置降低到最少。

为了阐述组件扫描和装配，我们来看这个CD和CD播放器的例子～

1）组件扫描 : 创建可被发现的Bean

首先建立CD的概念，我们先定义CD的一个接口，它定义了CD播放器对一盘CD所能进行的操作。它将CD播放器的任意实现与CD本身的耦合降低到了最低。

2.1 : CD接口

package soundsystem;

public interface CompactDisc {
    void play();
}

现在，我们创建一个CD的实现，一盘霉霉的《TaylorSwift》CD。

2.2：实现一个《TaylorSwift》的CD

@Component
public class TaylorSwift implements CompactDisc {
    private String title = "TaylorSwift";
    private String artist = "MeiMei";

    public void play() {
        System.out.print("正在播放" + artist + "的" + title);
    }
}

这个TaylorSwift使用了@Component注解，这个注解表明该类会作为组件类，并告知Spring要为这个TaylorSwift类创建Bean。
我们不必显式配置Bean，因为该类使用了@Component注解，Spring会将事情处理妥当。

但是组件扫描默认是不开启的，想要让Spring命令去寻找带有@Component注解的类，必须先对Spring进行显式配置。
同样的，显式配置有两种方式，XML和基于Java。

2.3：在Java代码中定义Spring的装配规则启用组件扫描

@Configuration
@ComponentScan
public class CDPlayerConfig {
}

@ComponentScan注解能够在Spring中启用组件扫描，并且，@ComponentScan默认会扫描与配置类相同的包。因为CDPlayerConfig类位于soundsystem包，因此Spring将会扫描这个包以及这个包下的所有子包，查找带有@Component注解的类。这样就实现了组件扫描，就能发现TaylorSwift类，并且会在Spring中自动为其创建一个Bean。

2.4：使用XML配置启用组件扫描

<?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
       http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="soundsystem" />

</beans>

在XML中，< context: component-scan>元素会有与@ComponentScan注解相对应的属性和子元素。

可是，真的扫描成功了吗？Bean到底创建成功了吗？接下来测试一下～
为了测试组件扫描的功能，创建一个简单的JUnit测试，它会创建Spring上下文，并判断TaylorSwift Bean是不是真的创建出来了。

2.5：测试组件扫描能够发现TaylorSwift

@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath*:CDPlayer.xml") //使用XML启用组件扫描
@ContextConfiguration(classes = CDPlayerConfig.class) //使用基于Java配置启用组件扫描
public class CDPlayerTest {
    @Autowired
    private CompactDisc cd;

    @Test
    public void cdShouldNotBeNull() {
        //若程序运行没有出现异常, 说明断言正确
        assertNotNull(cd);
    }
}

CDPlayerTest使用了Spring的SpringJUnit4ClassRunner，以便在测试开始的时候自动创建Spring的应用上下文。注解@ContextConfiguration会告诉它需要在CDPlayerConfig或CDPlayer.xml中加载配置文件。因为配置文件中都包含了ComponentScan，所以最终的应用上下文中都包含TaylorSwift Bean。

下面我们会更加深入地探讨@ComponentScan和@Component，看看它们还有哪些作用。

2）为组件扫描的Bean命名

Spring应用上下文中所有的Bean都会给定一个ID，Spring应用上下文自动创建的Bean的ID为将该类的名字的第一个字母小写，也就是说，TaylorSwift的Bean的ID为taylorSwift。

我们有两种方法为Bean设置不同的ID：

通过值传递给@Component注解
使用Java依赖注入规范中提供的@Named注解

@Component("lovetaylor") //第一种
//@Named("lovetaylor")   //第二种
public class TaylorSwift implements CompactDisc {
    ...
}

但是我们更倾向于使用@Component，@Component更能表明它是做什么的。

3）设置组件扫描的基础包

上面我们说过，@ComponentScan默认会扫描配置类所在的包，那如果我们想扫描不同的包，扫描多个包该怎么办呢？
我们可以在@ComponentScan的value属性中指明包的名称

一次指定一个包：

@Configuration
//@ComponentScan("soundsystem")
@ComponentScan(basePackages="soundsystem")
public class CDPlayerConfig{}

同时指定多个包：

@Configuration
@ComponentScan(basePackages={"soundsystem","video"})
public class CDPlayerConfig{}

除了将包设置为简单的String类型之外，@ComponentScan还提供了另一种方法，那就是将其指定为包中所包含的类或接口，这些类所在的包将会作为组件扫描的基础包：

@Configuration
@ComponentScan(basePackageClasses=CDPlayer.class,DVDPlayer.class})
public class CDPlayerConfig{}

在我们的应哟呵那个程序中，很多对象会依赖其他的对象才能完成任务，所以就需要一种方法能够将组件扫描的Bean和它们的依赖装配在一起。
下面我们就来看看自动化装配的另一方面内容——自动装配。

4）通过为Bean添加注解实现自动装配

自动装配就是让Spring自动满足Bean依赖的一种方法，在满足依赖的过程中，会在Spring应用上下文中寻找匹配某个Bean需求的其他Bean。
为了声明要进行自动装配，我们可以借助Spring的@Autowired注解。

通过程序来解释自动装配@Autowired是怎么回事。
现在有了CD，要将CD放入播放器里面播放啦～
同样的，先抽象出媒体播放器的接口，然后再实现CD播放器。

2.6：媒体播放器接口

public interface MediaPlayer {
    public void play();
}

2.7：实现CD播放器

@Component
public class CDPlayer implements MediaPlayer {
    private CompactDisc cd;

    @Autowired
    public CDPlayer(CompactDisc cd) {
        this.cd = cd;
    }

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

CDPlayer的构造方法处使用了@Autiwired注解，这表明Spring创建CDPlayer Bean的时候，会通过这个构造器来进行实例化并且会传入一个可设置给CompactDisc类型的Bean。

换种说法，就是Spring在初始化CDPlayer这个Bean的时候，发现其构造方法需要依赖CompactDisc Bean，所以Spring就会去满足这种依赖关系，也就是将CompactDisc这个Bean自动装配进来。

不管是构造器、set方法还是其他的方法，Spring都会尝试满足方法参数上所声明的依赖。
如果没有匹配的Bean，那么应用上下文创建的时候，Spring就会抛出一个异常。可以将@Autowired的required属性设置为false，但是需谨慎，因为这样如果没有匹配的Bean， Spring就会让当前Bean处于未装配的状态。
如果有多个Bean都能满足依赖关系的话，Spring将会抛出一个异常，表明没有明确指定要选择哪个Bean进行自动装配。

像@Component和@Named一样，@Inject（来源于Java依赖注入规范）也可以用来替换@Autowired（Spring特有）。

5）验证自动装配

现在，我们已经将自动化装配的两件事组件扫描和自动装配做好了，那接下来就来验证一下装配有没有成功。我们对之前的CDPlayerTest进行修改～

2.8：验证自动装配

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = CDPlayerConfig.class)
public class CDPlayerTest {

    @Rule
    public final StandardOutputStreamLog log = new StandardOutputStreamLog();

    @Autowired
    private MediaPlayer player;

    @Autowired
    private CompactDisc cd;

    @Test
    public void cdShouldNotBeNull() {
        assertNotNull(cd);
    }

    @Test
    public void play() {
        player.play();
        assertEquals("正在播放MeiMei的TaylorSwift", log.getLog());
    }
}

代码中使用了StandardOutputStreamLog（已过时），这是来源于System Rules库的一个JUnit规则，这个规则能够基于控制台的输出编写断言。在这里，我们断言TaylorSwift.play()方法的输出被发送到了控制台上。

现在我们已经了解了自动化装配，再来看看Spring中如何显式地装配Bean～

通过Java代码装配Bean

通过Java代码装配Bean，就是通过编写JavaConfig进行配置，更简单地来讲，就是在JavaConfig中声明Bean。具有强大、类型安全并且对重构友好的特点。

我们说JavaConfig就是带有@Configuration注解的Java代码，但是它和其他Java代码又有什么区别呢？
在概念上，JavaConfig与应用程序中的业务逻辑和领域代码是不同的，JavaConfig是配置代码，不包含任何业务逻辑，也不侵入到业务逻辑代码之中。所以通常将其放到单独的包中，使它与其他的应用程序逻辑分离开。

接下来我们看一下如何通过JavaConfig显式配置Spring～

1）创建配置类

前面的例子中我们已经认识了JavaConfig

2.9：在CD播放器例子中出现过的JavaConfig

@Configuration
@ComponentScan
public class CDPlayerConfig {
}

这个JavaConfig是启用组件扫描的一个配置文件。@ComponentScan注解就是在Spring中启用组件扫描。

那么问题来了，我们说自动化装配是隐式配置，JavaConfig和XML是显式配置，那为什么JavaConfig还可以用到自动化装配里呢？
其实，自动装配Bean机制是由组件扫描和自动装配两部分组成，组件扫描仍需要显式配置之后才能发挥它的作用。

现在理清了这些关系，那么我们来看一下通过Java代码来装配Bean的JavaConfig应该怎样写。

2.10：创建一个普通的JavaConfig

@Configuration
public class CDPlayerConfig {
}

创建好了，我们看一下如何使用JavaConfig装配CDPlayer和CompactDisc。

2）声明简单的Bean

要在JavaConfig中声明Bean，我们需要编写一个方法，这个方法会创建所需类型的实例，然后给这个方法添加@Bean注解。

2.11：声明一个TaylorSwift类的Bean

@Bean
public CompactDisc TaylorSwift() {
    return new TaylorSwift();
}

@Bean注解会告诉Spring，这个方法会返回一个对象，该对象要注册为Spring应用上下文中的Bean。
Bean就是包装后的Object，那也就是说，Spring最终会将new TaylorSwift()产生的实例包裹起来，形成Bean。
也可以通过Bean的name属性为Bean命名。

2.12：给Bean重命名

@Bean(name="lovetaylor")
public CompactDisc TaylorSwift() {
    return new TaylorSwift();
}

我们发现Bean的声明是很简单的，但是我们可能希望充分使用Java的功能来发挥其功能。
比如，我们希望随机选择一个CD来播放~

2.13：随机播放一盘CD

@Bean
public CompactDisc randomCD(){
    int choice = (int)Math.floor(Math.random() * 4);

    if(choice == 0){
        return new TaylorSwift();
    } else if(choice ==1) {
        return new bala1();
    } else if(choice ==2) {
        return new bala2();
    } else{
        return new bala();
    }
}

3）借助JavaConfig实现注入

在自动装配中，Spring帮我们来完成了Bean的注入，那么现在我们要通过Java代码来手动完成装配。
既然我们已经有了CD的Bean，现在要做的是播放CD，也就是要将CD注入到CDPlayer中。
最简单的方式就是引用创建Bean的方法：

2.14：创建CDPlayer Bean时直接调用CD Bean

@Bean
public CDPlayer cdPlayer() {
    return new CDPlayer(TaylorSwift());
}

这个cdPlayer()和TaylorSwift()方法一样，同样使用了@Bean注解，表明这个方法会创建一个Bean实例并将其注册到Spring应用上下文中。但是在cdPlayer()方法体里并没有使用默认的构造器构建实例，而是调用了需要传入CompactDisc对象的构造器来创建CDPlayer实例。
所以看起来就像是在创建CDPlayer Bean的时候会调用创建TaylorSwift Bean的方法，但实际上并非如此，cdPlayer()方法调用TaylorSwift()这个方法的时候，直接返回TaylorSwift Bean，而非每次调用都重新new一个TaylorSwift对象再交给Spring注册成一个Bean。
这也就是说，TaylorSwift Bean在Spring中只存在一份，如果在这个JavaConfig中还有其它Bean需要用到TaylorSwift Bean的时候，将与CDPlayer Bean共用一份TaylorSwift Bean实例，因为默认情况下，Spring中的Bean都是单例的。

可以看到，这种通过调用的方法来引用Bean的方式有点令人困惑。
那么还有一种理解起来更为简单的方式：

2.15：自动匹配所需的Bean进行装配

@Bean
public CDPlayer cdPlayer(CompactDisc compactDisc) {
    return new CDPlayer(compactDisc);
}

在这里，cdPlayer()方法请求一个CompactDisc作为参数。当Spring调用cdPlayer()创建CDPlayer Bean的时候，它会自动装配一个CompactDisc到配置方法之中。然后，方法体就可以按照合适的方式来使用它。这样，cdPlayer()方法也能将CompactDisc注入到CDPlayer的构造器中，而且不用明确引用CompactDisc的@Bean方法。

这就是关于使用Java代码来装配Bean的方式。

通过XML装配Bean

由于XML装配Bean并不作为我们的首选方案，所以这部分内容只是用来帮助我们维护已有的XML配置。

1）创建XML配置规范

在使用XML为Spring装配Bean之前，我们需要创建一个新的配置规范，即创建一个XML文件，并且以< beans>元素为根。
我们还要在XML文件顶部声明多个XML模式文件(.xsd)，这些文件定义了配置Spring的XML元素。

2.16：没有声明任何Bean的最简单的XML文件

<?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
       http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd">

</beans>

这就是一个合法的SpringXML配置。不过，它还没有声明任何Bean。现在，我们要给予它生命力，这次我们用XML配置重新创建CD。

2）声明一个简单的< bean>

我们要使用spring-beans模式中的另外一个元素：< bean>，它类似于JavaConfig中的@Bean注解。
我们可以这样声明CompactDisc Bean：

<bean class="soundsystemXML.TaylorSwift" />

这个Bean的类通过class属性来指定，并且要使用全限定的类名。因为没有明确的指出ID，所以该Bean的ID将会是”soundsystemXML.TaylorSwift#0”。这个#0表示计数，如果我们也声明了不指定ID的另外一个TaylorSwift，那么它的ID将会是”soungsystemXML.TaylorSwift#1”。

但通常我们都会为它们指定ID，因为我们在装配Bean的时候会用到这个具体的名字，否则自动产生的名字也没有多大用处。

<bean id="taylor" class="soundsystemXML.TaylorSwift" />

那么当Spring发现这个< bean>元素时，它将会调用TaylorSwift的默认构造器来创建Bean。
与JavaConfig的方式比较，我们不再需要直接创建TaylorSwift实例，这样也显得更加被动，但是它也没有JavaConfig强大，不能通过任何我们可以想象到的方法来创建Bean实例，而且，如果突然改变了类名，那又将造成很多麻烦。

3）注入Bean（装配Bean）

我们可以回想一下，在JavaConfig中有两种注入Bean方式。那么在XML配置文件中也有两种注入Bean的方式：

通过构造器注入Bean
通过setter设置属性注入Bean

3.1）通过构造器注入Bean

什么叫通过构造器注入Bean呢? 前面讲过了，在XML中声明Bean时，使用全限定的类名来指定一个类，然后Spring调用这个类的默认构造方法new出一个对象，然后将其包裹成Bean。那么，如果这个类我们给其自定义了构造方法，我们就可以在XML中对其进行注入，完成Bean的初始化工作。
前面2.7的CD播放器的程序中，CDPlayer类的构造方法需要一个CompactDisc对象，如果我们要初始化这个Bean，就要完成CompactDisc Bean的注入。

在XML中，通过构造器注入Bean有两种配置方案：

< constructor-arg>元素
使用Spring的c-命名空间

3.1.1）< constructor-arg>元素配置方式

2.17： < constructor-arg>元素配置方式注入初始化CDPlayer Bean

<bean id="cdPlayer" class="com.soundsystemXML.CDPlayer">
    <constructor-arg ref="taylor" />
</bean>

< constructor-arg>元素会告知Spring要将一个ID为taylor的Bean引用传递到CDPlayer的构造器中。
同样的，还有c-命名空间配置注入Bean。

3.1.2）c-命名空间配置方式

2.18： c-命名配置方式注入Bean

<bean id="cdPlayer1" class="com.soundsystemXML.CDPlayer"
        c:cd-ref="taylor" />

c-命名空间这种配置方式看起来有点怪异，我们来分析一下：

c:是c-命名空间的前缀
cd是构造器的参数名，也就是CDPlyer构造方法的参数列表里面的参数名
-ref是注入Bean引用，“taylor”是要注入的Bean的ID

关于c-命名空间，还有一些别的使用规则。比如，当构造器中需要多个Bean的时候，我们可以使用参数索引来表示参数列表里所需要的多个Bean。比如这样：

<bean id="cdPlayer2" class="com.soundsystemXML.CDPlayer"
          c:_0-ref="taylor" />

3.2）通过构造器注入常量

上面介绍的是通过构造器注入Bean，但是有的时候，构造器的参数并不是一个类变量，而是一个常量。那么就来看一下如何通过构造器注入常量～

假设现在有一个Taylor的CD如下：

2.19：TaylorDisc CD

public class TaylorDisc implements CompactDisc {

    private String title;
    private String artist;

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

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

就这个类的构造器而言，它的两个参数都是常量，所以要通过XML将常量注入。和前面一样，将常量注入到构造器中，也有两种方式：

< constructor-arg>元素
使用Spring的c-命名空间

3.2.1）< constructor-arg>元素配置方式

2.20：将常量注入到构造器中

<bean id="taylorDisc1" class="com.soundsystemXML.TaylorDisc" >
    <constructor-arg value="TSCD" />
    <constructor-arg value="MeiMei" />
</bean>

每种注入方式都是有多种书写格式的, 比如还可以像下面这样:

<bean id="taylorDisc1" class="com.soundsystemXML.TaylorDisc" >
    <constructor-arg index="0" value="TSCD" />
    <constructor-arg index="1" value="MeiMei" />
</bean>

3.2.2）c-命名空间配置方式

2.21：使用c-命名空间注入常量

<bean id="taylorDisc2" class="com.soundsystemXML.TaylorDisc"
          c:title="TSCD" c:artist="MeiMei" />

这种注入方式是通过构造器的参数列表的参数名称来指定，也可以像前面注入Bean那样，使用索引来指定要注入的常量。比如下面这样：

<bean id="bean id="taylorDisc2" class="com.soundsystemXML.TaylorDisc"
          c:_0="TSCD" c:_1="MeiMei" />

3.2.3）装配Bean时注入列表/集合/数组

需要特别说明的是，在装配Bean的时候，如果我们要注入的是一个数组/列表/集合呢？那么我们就需要用到< list>元素。

假设现在有一个五月天的新专辑类，我们要对这个CD进行一些更细致的处理，比如显示出播放这个CD里面的每一首歌：

2.22：五月天的新专辑

public class MayDayDisc implements CompactDisc {
    private String title;
    private String artist;
    private List<String> tracks;
//  private Set<String> tracks;
//  一般来说, List和Set的区别不是很大, 但是当Spring要装配的是集合的时候, 使用Set集合可以保证集合中的元素不会重复.

    public MayDayDisc(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);
        }
    }
}

那么这个时候，XML文件里应该这样配置：

 <bean id="mayDay1" class="com.soundsystemXML.MayDayDisc">
        <constructor-arg value="五月天的新专辑" />
        <constructor-arg value="五月天" />
        <constructor-arg>
            <list>
                <value>歌曲1</value>
                <value>歌曲2</value>
                <value>歌曲3</value>
                <!--等等...-->
            </list>
        </constructor-arg>
    </bean>

在上面的代码中提到了，在类里除了使用List，也可以使用Set，不过就是将相对应的XML配置文件中的< list>元素改为< set>就可以了。

同理，如果现在有一个电台，要播放若干CD，我们也可以将若干CD类使用< list>元素，注入到电台类中。

2.23：电台

public class Discography {
    private String artist;
    private List<CompactDisc> cds;

    public Discography(String artist, List<CompactDisc> cds){
        this.artist = artist;
        this.cds = cds;
    }
}

而其相对应的XML应该是这样:

 <bean id="discpgraphy" class="com.soundsystemXML.Discography">
        <constructor-arg index="0" value="今日流行"/>
        <constructor-arg index="1">
            <list>
                <ref bean="jay" />
                <ref bean="jayZhou" />
                <ref bean="mayDay" />
            </list>
        </constructor-arg>
    </bean>

以上就是关于通过构造器装配(注入)Bean的内容，下面我们来看一下怎样通过设置属性来装配(注入)Bean～

3.3）通过setter设置属性注入Bean

在Java中，除了通过构造方法给数据成员赋值以外，我们还可以通过setter方法给数据成员赋值。

与通过构造器注入Bean一样，通过设置属性注入Bean也有两种装配方式：

通过< property>元素装配
通过p-命名空间装配

3.3.1）通过< property>元素装配

我们现在对CDPlyer类进行修改，去掉它的自定义构造方法，加上所有数据成员的setter方法：

2.24：CDPlayer

public class CDPlayer implements MediaPlayer {
    private CompactDisc cd;

    @Autowired
    public void setCd(CompactDisc cd){
        this.cd = cd;
    }

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

如果现在要在XML中重新声明这个类，我们可能会这样声明：

 <bean id="cdPlayer" class = "com.soundsystemXML.CDPlayer" />

这样看起来是没有问题的，毕竟现在这个类没有自定义的构造方法了嘛，默认的构造方法也是不含参数的。可是这样真的对吗? 如果我们测试这个类，会发现它会抛出NullPoiterException异常，因为我们没有注入任何CompactDisc Bean，所以运行play()方法当然就出错了。

要通过设置属性注入Bean，这时候我们就要用到< property>元素了。元素为设置属性的setter方法所提供的功能和< constructor-arg>元素为构造器提供的功能是一样的。比如现在可以在XML中这样写：

<bean id="cdPlayer3" class = "com.soundsystemXML.CDPlayer">
    <!--这里的property的name属性要与setXXX()方法里面的XXX保持一致(XXX首字母应该小写)-->
    <property name="cd" ref="taylor"/>
</bean>

3.3.2）通过p-命名空间装配

2.25：通过p-命名空间来装配Bean

<bean id="cdPlayer4" class="com.soundsystemXML.CDPlayer"
      p:cd-ref="taylor">
</bean>

同样的，p-命名空间的参数也比较难理解。现在我们也来分析一下p:cd-ref=”taylor”里的各项参数：

p:是p-命名空间的前缀
cd是属性名(即类中的数据成员名)
-ref是注入Bean引用，告知Spring这是注入一个Bean而不是常量
“taylor”是所注入的Bean的ID

3.4）通过设置属性注入常量

有了前面通过构造器注入常量的例子，这里的通过设置属性注入常量应该也不难理解。
与前面一样，通过设置属性注入常量也有两种装配方式：

通过< property>元素装配
通过p-命名空间装配

3.4.1）通过< property>元素装配

我们先对五月天的新专辑类进行一些修改，去掉它的构造方法，加上所有数据成员的setter方法。

2.26：五月天的新专辑类

public class MayDayDisc 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);
        }
    }
}

在XML中应该这样配置:

    <bean id="mayDay3" class="com.soundsystemXML.MayDayDisc">
        <property name="title" value="五月天的新专辑" />
        <property name="artist" value="五月天" />
        <property name="tracks">
            <list>
                <value>歌曲1</value>
                <value>歌曲2</value>
                <value>歌曲3</value>
                <value>歌曲4</value>
                <!--等等...-->
            </list>
        </property>
    </bean>

3.4.2）通过p-命名空间装配

使用p-命名空间装配的时候还有一丢丢小麻烦，不过我们先把装配的代码贴出来，再对它进行解释：

<bean id="mayDay4" class="com.soundsystemXML.MayDayDisc"
          p:title="五月天的新专辑"
          p:artist="五月天">
        <property name="tracks">
            <list>
                <value>歌曲1</value>
                <value>歌曲2</value>
                <value>歌曲3</value>
                <value>歌曲4</value>
                <!--等等...-->
            </list>
        </property>
    </bean>

可以看出，再注入列表常量的时候，没有使用p-命名空间，而是使用了< property>元素。事实上，p-命名空间是不能装配集合的。
但是，我们仍然有简化书写的办法，就是使用util-命名空间。

我们可以使用util-命名空间的< util:list>元素来创建一个Bean，然后再通过p-命名空间的ref来引用这个Bean。具体代码如下：

<util:list id="trackList">
        <value>歌曲1</value>
        <value>歌曲2</value>
        <value>歌曲3</value>
        <value>歌曲4</value>
        <!--等等...-->
    </util:list>

    <bean id="mayDay5" class="com.soundsystemXML.MayDayDisc"
          p:title="五月天的新专辑"
          p:artist="五月天"
          p:tracks-ref="trackList">
    </bean>

< util:list>元素只是util-命名空间所提供的功能之一，它还有许多其它的元素，比如：

<util:constant> : 引用某个类型的public static域, 并将其暴露为Bean;
<util:list> : 创建一个java.util.List类型的Bean, 其中包含值或引用;
<util:map> : 创建一个java.util.Map类型的Bean, 其中包含值或引用;
<util:properties> : 创建一个java.util.Properties类型的Bean;
<util:property-path> : 引用一个Bean的属性(或内嵌属性), 并将其暴露为Bean;
<util:set> : 创建一个java.util.Set类型的Bean, 其中包含值或引用.

SillyDuckkk

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
Spring实战(3)：装配Bean——自动化、JavaConfig、XML

装配是什么？创建应用对象之间协作关系的行为通常称为装配（wiring），这也是DI的本质。我们必须要告诉Spring要创建哪些bean并且如何将其装配在一起。Spring提供了三种主要的装配机制：在XML中进行显式配置在Java中进行显式配置隐式的bean发现机制和自动装配Spring的配置风格是可以互相搭配的，但应尽可能地使用自动配置的机制，因其使用起来要方便的多，显...
复制链接

扫一扫

专栏目录