装配Bean

最新推荐文章于 2024-09-25 07:30:00 发布

godmanHa

最新推荐文章于 2024-09-25 07:30:00 发布

阅读量625

点赞数 1

分类专栏：学习笔记 spring 文章标签： spring 装配bean

本文链接：https://blog.csdn.net/denghj618/article/details/81271384

版权

学习笔记同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

spring

7 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring中装配Bean的三种机制：自动化装配Bean（组件扫描和自动装配）、通过Java代码装配Bean以及通过XML配置Bean。重点讨论了如何使用@ComponentScan、@Autowired注解进行自动化装配，如何通过@Configuration和@Bean注解进行Java配置，以及如何在XML中声明和初始化Bean。文章还涵盖了导入和混合配置，展示了在JavaConfig中引用XML配置以及在XML配置中引用JavaConfig的方法。

摘要由CSDN通过智能技术生成

Spring装配Bean

Spring提供了3种装配bean的机制：

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

1 自动化装配Bean

我们首先来看一下自动化装配Bean。Spring从两个角度实现自动化装配：

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

组件扫描和自动装配组合在一起就能发挥出强大的威力，它们能够将你的显示配置降低到最少。

1.1 创建可被发现的bean

首先定义一个CD接口：

/**
 * 定义CD接口
 */
public interface CompactDisc {
    void play();
}

再实现CompactDisc接口，并使用@Component注解。@Component注解表明该类会作为组件类，并告知Spring要为这个类创建bean。

@Component
public class SgtPeppers implements CompactDisc {

    private String title = "吻别";
    private String artist = "张学友";

    @Override
    public void play() {
        System.out.println("播放" + artist + "的" + title);
    }
}

不过，扫描组件默认是不启用的，所以需要显示配置一下Spring，从而命令它去寻找带有@Component注解的类，并为其创建bean。

/**
 * 默认扫描配置类相同的包
 */
@Configuration
@ComponentScan
public class CDPlayerConfig {
}

@Configuration注解表明这是一个配置类。@ComponentScan启用组件扫描，默认会扫描配置类相同的包，如果没有其他的配置，Spring会扫描配置类所在包以及这个包下的所有子包，查找带有@Component注解的类，并为其创建一个bean。

下面来测试一下组件扫描的功能，看看会不会创建Spring上下文，并判断CompactDisc是不是真的创建出来了

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

    @Autowired
    private CompactDisc cd;

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

    @Test
    public void playCd(){
        cd.play();
    }
}

运行cdShouldNotBeNull()，结果如下：

说明CompactDisc被创建出来了，再运行playCd()，结果如下：

说明创建的是SgtPeppers的实例。

1.2 为组件扫描的bean命名

Spring应用上下文中所有的bean都会给定一个ID。，具体的命名规则是：将类名的第一个字母变为小写。如果想为这个bean设置不同的ID，需要将期望的ID作为值传递给@Component注解。

@Component("takeMeToYourHeart")
public class SgtPeppers implements CompactDisc {    
    ...
}

还有另外一种为bean命名的方式，这种方式不使用@Component注解，而是使用Java依赖注入规范中所提供的@Named注解来为bean设置ID：

@Named("takeMeToYourHeart")
public class SgtPeppers implements CompactDisc {
    ...
}

Spring支持将@Named作为@Component注解的替代方案。两者之间有一些细微的差异，但是在大多数场景中，它们是可以互换的。

1.3 设置组件扫描的基础包

目前为止，没有为@Component注解设置任何属性，这意味着按照默认规则，Spring会以配置类所在的包作为基础包(base package)来扫描组件。
如果需要扫描不同的包，只要在@ComponentScan的value属性中指定包的名称即可：

@Configuration
@ComponentScan(value = "com.godman.soundsystem")
public class CDPlayerConfig {
}

如果想更加清晰的表明你所设置的是基础包，可以通过basePackages属性进行配置：

@Configuration
@ComponentScan(basePackages = "com.godman.soundsystem")
public class CDPlayerConfig {
}

如果需要指明多个基础包，只需要将basePackages属性设置为要扫描包的一个数组即可：

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

以上的例子中，所设置的基础包是以String类型表示的，但这种方法是类型不安全的。如果重构代码，那么所指定的基础包就可能出错。@ComponentScan提供了另外一种方法，那就是将其指定为包中所包含的类或接口：

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

可以看到，basePackages被替换成了basePackageClasses。同时不再使用String类型的名称来指定包，而是类，这些类所在的包将会作为组件扫描的基础包。

1.4 通过为bean添加注解实现自动装配

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

@Component
public class CDPlayer implements MediaPlayer {

    private CompactDisc cd;

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

    @Override
    public void player() {
        cd.play();
    }
}

在构造器上添加了@Autowired注解，这表明当Spring创建CDPlayer bean的时候，会通过这个构造器来进行实例化并且会传入一个可设置给CompactDisc类型的bean。
@Autowired注解不仅能够用在构造器上，还能用在属性的setter方法上，比如

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

实际上@Autowired可以用在类的任何方法上。不管是构造器、Setter方法还是其他方法，Spring都会尝试满足方法上参数所声明的依赖。假如有且仅有一个bean匹配依赖需求的话，那么这个bean将会被装配进来。
如果没有匹配的bean，那么在应用上下文创建的时候，Spring会抛出一个异常。为了避免异常的出现，可以将@Autowired的required属性设置为false：

@Autowired(required = false)
public void setNewCD(CompactDisc cd){
    this.cd = cd;
}

将required设置为false时，Spring会尝试执行自动装配，但是如果没有匹配的bean的话，Spring将会让这个bean处于未装配状态。但是，把required设置为false时，如果在代码中没有进行null检查的话，这个处于未装配状态的属性有可能会出现NullPointerException。

如果有多个bean都满足依赖关系的话，Spring将会抛出一个异常，表明没有明确指定要选择哪个bean进行自动装配。

@Autowired是Spring特有的注解，可以使用@Inject进行替换：

@Named
public class DVDPlayer {

    private CompactDisc compactDisc;

    @Inject
    public DVDPlayer(CompactDisc compactDisc) {
        this.compactDisc = compactDisc;
    }
}

1.5 验证自动装配

package test.com.godman.video; 

import com.godman.video.CompactDisc;
import com.godman.video.MediaPlayer;
import com.godman.video.DVDPlayerConfig;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/** 
 * DVDPlayer Tester. 
 * 
 * @author <Authors name> 
 * @since <pre>七月 21, 2018</pre> 
 * @version 1.0 
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes=DVDPlayerConfig.class)
public class DVDPlayerTest { 

    @Autowired
    private MediaPlayer mediaPlayer;

    @Autowired
    private CompactDisc compactDisc;

    @Test
    public void cdNotBeNull(){
        Assert.assertNotNull(compactDisc);
    }

    @Test
    public void play(){
        mediaPlayer.player();
    }
}

2 通过Java代码装配bean

在进行显示配置时的时候有两种方案可选：Java和XML。
JavaConfig是更好的方案，因为它更为强大、类型安全并且对重构友好。因为它就是Java代码，就像程序中的其他Java代码一样。但是，JavaConfig是配置代码，这意味着它不应该包含任何业务逻辑，JavaConfig也不应该侵入到业务逻辑代码之中。

2.1 创建配置类

创建JavaConfig类的关键在于为其添加@Configuration注解，@Configuration注解表明这个类是一个配置类，该类应该包含在Spring应用上下文中如何创建bean的细节。

package com.godman.javaConfig;

import org.springframework.context.annotation.Configuration;

@Configuration
public class CDPlayerConfig {
}

2.2 声明简单的bean

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

@Bean
public CompactDisc sgtPeppers(){
    return new SgtPeppers();
}

@Bean注解会告诉Spring这个方法将会返回一个对象，该对象要注册为Spring应用上下文中的bean。方法体中包含了最终产生bean实例的逻辑。
默认情况下，bean的ID与带有@Bean注解的方法名保持一致。如果想为其设置一个不同的名字，可以重命名此方法，也可以通过name属性指定一个不同的名字

@Bean("JayCD")
public CompactDisc sgtPeppers(){
    return new SgtPeppers();
}

2.3 借助JavaConfig实现注入

在JavaConfig中装配bean的最简单方式就是引用创建bean的方法。如：

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

看起来CompactDisc是通过调用sgtPeppers()得到的，但情况并非完全如此。因为sgtPeppers()方法上添加了@Bean注解，Spring将会拦截所有对它的调用，并确保直接返回该方法所创建的bean，而不是每次都对其进行实际的调用。

通过调用方法来引入bean的方式有点令人困惑。还有一种更为简单的理解方式：

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

在这里anotherCDPlayer()方法请求一个CompactDisc作为参数。当Spring调用anotherCDPlayer()创建MediaPlayer的bean的时候，它会自动装配一个CompactDisc到配置方法之中。通过这种方式引用其他的bean通常是最佳选择，他不会要求将CompactDisc声明到同一个配置类之中。甚至没有要求CompactDisc一定要在JavaConfig中声明，它实际上可以通过组件扫描功能自动发现或者通过XML来进行配置。完全可以将配置分散到多个配置类、XML文件以及自动扫描和装配的bean之中，只要功能完整健全即可。

2.4 验证java代码装配bean

package test.com.godman.javaConfig; 

import com.godman.javaConfig.CDPlayerConfig;
import com.godman.javaConfig.CompactDisc;
import com.godman.javaConfig.MediaPlayer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/** 
 * CDPlayer Tester. 
 * 
 * @author <Authors name> 
 * @since <pre>七月 21, 2018</pre> 
 * @version 1.0 
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = CDPlayerConfig.class)
public class CDPlayerTest { 

    @Autowired
    private CompactDisc compactDisc;

    @Autowired
    private MediaPlayer mediaPlayer;

    @Test
    public void cdNotBeNull(){
        Assert.assertNotNull(compactDisc);
    }

    @Test
    public void paly(){
        mediaPlayer.player();
    }
}

3 通过XML配置bean

3.1 创建XML配置规范

在使用XML为Spring装配bean之前，需要创建一个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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- configuration details go here -->
</beans>

3.2 声明一个简单的

要在基于XML的Spring配置中声明一个bean，需要使用spring-beans模式中的另外一个元素：<bean>。<bean>元素类似于JavaConfig中的@Bean注解。如下：

<bean id="compactDisc" class="com.godman.xml.SgtPeppers" />

如果没有明确给定ID，这个bean将会根据全限定类名来进行命名。在本例中，bean的ID将会是”com.godman.xml.SgtPeppers#0”。其中0是一个技术的形式，用来区分相同类型的其他bean。

3.3 借助构造器进行初始化bean

在Spring XML 配置中，只有一种声明bean的方式：使用<bean>元素并指定class属性。Spring会从这里获取必要的信息来创建bean。
但是，在XML中声明DI时，会有多种可选的配置方案和风格。具体到构造器注入，有两种基本的配置方案可选：

元素
使用Spring3.0所引入的c-命名空间

3.3.1 构造器注入bean引用

现在CDPlayer bean 有一个接受CompactDisc类型的构造器。现在已经声明了SgtPeppers bean，并且SgtPeppers类实现了CompactDisc接口，所以我们可以直接将SgtPeppers bean 注入到CDPlayer bean。

<bean id="cdPlayer" class="com.godman.xml.CDPlayer">
    <constructor-arg ref="compactDisc" />
</bean>

当Spring遇到这个<bean>元素时，它会创建一个CDPlayer实例。<constructor-arg>元素会告诉Spring要将一个ID为compactDisc的bean引用传递到CDPlayer的构造器中。
作为替代方案，可以使用Spring的c-命名空间。c-命名空间是在Spring3.0中引入的，它是在XML中更为简洁地描述构造器参数的方式。要使用它的话，必须要在XML的顶部声明其模式，如：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/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
       http://www.springframework.org/schema/c ">
    <!-- configuration details go here -->
   ...
</beans>

在c-命名空间和模式声明之后，就可以使用它来声明构造器参数了，如下：

<bean id="cdPlayer" class="com.godman.xml.CDPlayer" c:compactDisc-ref="compactDisc"/>

属性名以”c:”开头，也就是命名空间前缀。”compactDisc”是构造器参数名(如果使用idea，会自动提示这个属性名)，在此之后是”-ref”这是一个命名的约定，它会告诉Spring，正在装配的是一个bean的引用，这个bean的名字是compactDisc，而不是字面量”compactDisc”。
我们也可以使用参数在参数列表中的位置来声明构造器参数：

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

这里将参数的名称替换成了”0”，也就是参数的索引。因为在XML中不允许数字作为属性的第一个字符，因此必须添加一个下划线作为前缀。

3.3.2 将字面量注入到构造器中

迄今为止，我们所做的DI通常值得都是类型的装配–也就是将对象的引用装配到依赖于它们的其他对象之中–而有些时候，需要做的只是用一个字面量值来配置对象。为此，新创建一个CompactDisc的实现类，如下：

package com.godman.xml;

public class BlankDisc implements CompactDisc {

    private String title;
    private String artist;

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

    @Override
    public void play() {
        System.out.println("播放 " + artist + " 的 " + title);
    }
}

其配置信息如下所示：

<bean id="blankDisc" class="com.godman.xml.BlankDisc">
    <constructor-arg value="背包" />
    <constructor-arg value="陈奕迅" />
</bean>

再次使用<constructor-arg>元素进行构造器参数的注入时，没有使用”ref”属性来引用其他的bean，而是使用了value属性，通过该属性表明给定的值要以字面量的形式注入到构造器中。
如果要使用c-命名空间的话，如下：

<bean id="blankDisc" class="com.godman.xml.BlankDisc" c:title="背包" c:artist="陈奕迅"/>

或者：

    <bean id="blankDisc" class="com.godman.xml.BlankDisc" c:_0="背包" c:_1="陈奕迅"/>

明显看到，装备字面量与装配引用的区别在于属性名中去掉了”-ref”。

3.3.3 装配集合

如果一个bean的构造函数包含集合，该如何进行DI？

package com.godman.xml;

import java.util.List;

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

    @Override
    public void play() {
        System.out.println("播放 " + artist + " 的 " + title);
        for (String track : tracks){
            System.out.println("-Track: " + track);
        }
    }
}

最简单的方式就是将列表设置为null，如下：

<bean class="com.godman.xml.BlankDisc">
    <constructor-arg value="男人三十"></constructor-arg>
    <constructor-arg value="李宗盛"></constructor-arg>
    <constructor-arg><null/></constructor-arg>
</bean>

<null/>元素会将null传递给构造器，但这并不是解决问题的好办法，但是在注入期它能正常执行。但是当调用play()方法时，会抛出NullPointerException异常。
最好的方式使用<list>元素声明一个列表：

<bean id="blankDisc" class="com.godman.xml.BlankDisc">
    <constructor-arg value="男人三十"></constructor-arg>
    <constructor-arg value="李宗盛"></constructor-arg>
    <constructor-arg>
        <list>
            <value>山丘</value>
            <value>漂洋过海来看你</value>
            <value>给自己的歌</value>
            <value>爱情有什么道理</value>
        </list>
    </constructor-arg>
</bean>

其中，<list>元素是<constructor-arg>的子元素，这表明一个包含值的列表将会传递到构造器中。其中，<value>元素用来指定列表中的每个字面量元素。
当然如果<list>是bean引用列表，则可以将<value>替换成<ref bean=”xxx”>
构造器参数的类型是java.util.List时，也可以按照同样的方式使用<set>元素，在此不做示例。

3.3.4 验证xml装配bean

package test.com.godman.xml;

import com.godman.xml.CompactDisc;
import com.godman.xml.MediaPlayer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * CDPlayer Tester.
 * 
 * @author <Authors name> 
 * @since <pre>七月 22, 2018</pre> 
 * @version 1.0 
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="/applicationContext.xml")
public class CDPlayerTest {

    @Autowired
    private CompactDisc compactDisc;

    @Autowired
    private MediaPlayer mediaPlayer;

    @Test
    public void cdSholdNotNull(){
        Assert.assertNotNull(compactDisc);
    }

    @Test
    public void player(){
        mediaPlayer.player();
    }
}

3.4 设置属性

3.4.1 将bean注入到属性中

到目前为止CDPlayer和BlankDisc类完全是通过构造器注入的，没有使用属性的Setter方法。接下来，看一下如何使用Spring XML 实现属性注入。属性注入的CDPlayer如下：

package com.godman.xml;

public class CDPlayer implements MediaPlayer {

    private CompactDisc compactDisc;

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

    @Override
    public void player() {
        compactDisc.play();
    }
}

该选择构造器注入还是属性注入呢？作为一个通用的规则，对于强依赖使用构造器注入，而对于可选性的依赖使用属性注入。CDPlayer在XML中的配置如下：

<bean id="cdPlayer" class="com.godman.xml.CDPlayer">
    <property name="compactDisc" ref="blankDisc"/>
</bean>

<property>元素为属性的Setter方法所提供的功能与<constructor-arg>元素为构造器所提供的功能是一样。同样的，使用”ref”属性引用另一个bean，使用”value”引用字面量。Spring为<constructor-arg>元素提供了c-命名空间作为替代方案，与之类似，Spring提供了更加简洁的p-命名空间作为<property>元素的替代方案。为了启用p-命名空间，必须在XML文件中与其他的命名空间一起对其进行声明：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:p="http://www.springframework.org/schema/p"
       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
       http://www.springframework.org/schema/c
       http://www.springframework.org/schema/p ">
    <!-- configuration details go here -->
    ...
</beans>

使用p-命名空间，装配

<bean id="cdPlayer" class="com.godman.xml.CDPlayer" p:compactDisc-ref="blankDisc"/>

p-命名空间中属性所遵循放入命名约定与c-命名空间中的属性类似：p-命名空间前缀，compactDisc代表属性名，-ref代表注入bean引用。

3.4.2 将字面量注入到属性中

属性也可以注入字面量，这与构造器参数非常相似。如下使用属性注入的BlankDisc：

package com.godman.xml;

import java.util.List;

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 setTitle(String title) {
        this.title = title;
    }

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

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

    @Override
    public void play() {
        System.out.println("播放 " + artist + " 的 " + title);
        for (String track : tracks){
            System.out.println("-Track: " + track);
        }
    }
}

现在可以创建一个不装配任何属性的BlankDisc Bean，如下：

<bean id="blankDisc" class="com.godman.xml.BlankDisc"/>

在装配bean的时候不设置这些属性，当运行play()方法会抛出NullPointerException异常。所以可以借助<property>元素的<value>属性实现装配：

<bean id="blankDisc" class="com.godman.xml.BlankDisc">
    <property name="artist" value="罗大佑"/>
    <property name="title" value="之乎者也"/>
    <property name="tracks">
        <list>
            <value>恋曲1980</value>
            <value>光阴的故事</value>
            <value>鹿港小镇</value>
            <value>童年</value>
        </list>
    </property>
</bean>

当然也可以借助p-命名空间的属性来完成：

<bean id="blankDisc" class="com.godman.xml.BlankDisc" p:artist="罗大佑" p:title="之乎者也">
    <property name="tracks">
    <list>
    <value>恋曲1980</value>
    <value>光阴的故事</value>
    <value>鹿港小镇</value>
    <value>童年</value>
    </list>
    </property>
</bean>

与c-命名空间一样，装备bean引用与装配字面量放入唯一区别在于是否带有”ref”后缀。如果没有”ref”后缀的话，所装配的就是字面量。
需要注意的是，不能使用p-命名空间来装配集合。但是可以使用Spring提供的util-命名空间来简化，首先在XML中声明util-命名空间：

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

util-命名空间提供的功能之一就是<util-list>元素，它会创建一个列表的bean：

<util:list id="trackList">
    <value>恋曲1980</value>
    <value>光阴的故事</value>
    <value>鹿港小镇</value>
    <value>童年</value>
</util:list>

然后将列表bean注入到tracks属性当中：

<bean id="blankDisc" class="com.godman.xml.BlankDisc" p:artist="罗大佑" p:title="之乎者也" p:tracks-ref="trackList"/>

<util-list>元素只是util-命名空间提供的功能之一，以下是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，其中包含值或引用

4 导入和混合配置

在Spring应用中，可以同时使用自动化和显示配置，就是可以混合配置。需要了解的就是在自动装配的时，他并不在意要装配的bean来自哪里。自动装配的时候会考虑到Spring容器中所有的bean，不管它是在JavaConfig或XML中声明还是通过组件扫描获取到的。

4.1 在JavaConfig中引用XML配置

现在假设，需要将BlankDisc从CDPlayerConfig中拆分出来，定义到自己的CDConfig中：

package com.godman.xmlAndjavaconfig;

import org.springframework.context.annotation.Bean;

import java.util.ArrayList;
import java.util.List;

public class CDConfig {

    @Bean
    public CompactDisc compactDisc(){
        BlankDisc blankDisc = new BlankDisc();
        blankDisc.setTitle("断点");
        blankDisc.setArtist("张敬轩");
        List<String> trackList = new ArrayList<>();
        trackList.add("断点");
        trackList.add("过云雨");
        trackList.add("吻得太逼真");
        trackList.add("听说爱情回来过");
        blankDisc.setTracks(trackList);
        return blankDisc;
    }
}

现在compactDisc()方法已经从CDPlayerConfig中移除了，需要一种方法将这两个类组合在一起。一种方法就是在CDPlayerConfig中使用@Import注解导入CDConfig：

package com.godman.xmlAndjavaconfig;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import(CDConfig.class)
public class CDPlayerConfig {

    @Bean
    public MediaPlayer mediaPlayer(CompactDisc compactDisc){
        CDPlayer cdPlayer = new CDPlayer();
        cdPlayer.setCompactDisc(compactDisc);
        return cdPlayer;
    }
}

或者采用一种更好的方式，不在CDPlayerConfig中使用@Import，而是创建一个更高级别的SoundConfig，在这个类中使用@Import将两个配置类组合在一起：

package com.godman.xmlAndjavaconfig;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@Import({CDConfig.class, CDPlayerConfig.class})
public class SoundConfig {
}

在假如通过XML来配置BlankDisc：

<util:list id="trackList">
    <value>恋曲1980</value>
    <value>光阴的故事</value>
    <value>鹿港小镇</value>
    <value>童年</value>
</util:list>

<bean id="blankDisc" class="com.godman.xmlAndjavaconfig.BlankDisc" p:artist="罗大佑" p:title="之乎者也" p:tracks-ref="trackList"/>

现在BlankDisc配置在了XML之中，通过@ImportResource引入xml配置文件：

package com.godman.xmlAndjavaconfig;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;

@Configuration
@Import(CDPlayerConfig.class)
@ImportResource("classpath: applicationContext.xml")
public class SoundConfig {
}

两个bean–配置在JavaConfig中的CDPlayer以及配置在XML中的BlankDisc都会被加载到Spring容器中。因为CDPlayer中带有@Bean注解的方法接受一个CompactDisc作为参数，因此BlankDisc会被装配进来，此时与他是通过XML配置的没有关系。

4.2 在XML配置中引用JavaConfig

在JavaConfig配置中，可以通过@Import和@ImportResource来拆分JavaConfig配置。在XML中，可以使用<import>元素来拆分XML配置。
现在将BlankDisc bean 拆分到cd-config.xml配置文件中：

<util:list id="trackList">
    <value>恋曲1980</value>
    <value>光阴的故事</value>
    <value>鹿港小镇</value>
    <value>童年</value>
</util:list>

<bean id="blankDisc" class="com.godman.xmlAndjavaconfig.BlankDisc" p:artist="罗大佑" p:title="之乎者也" p:tracks-ref="trackList"/>

现在可以在XML配置文件中使用<import>元素来引用该文件：

<import resource="cd-config.xml"/>    
<bean id="cdPlayer" class="com.godman.xmlAndjavaconfig.CDPlayer" p:compactDisc-ref="blankDisc"/>

或者将BlankDisc配置在JavaConfig中：

package com.godman.xmlAndjavaconfig;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class CDConfig {

    @Bean
    public CompactDisc compactDisc(){
        BlankDisc blankDisc = new BlankDisc();
        blankDisc.setTitle("断点");
        blankDisc.setArtist("张敬轩");
        List<String> trackList = new ArrayList<>();
        trackList.add("断点");
        trackList.add("过云雨");
        trackList.add("吻得太逼真");
        trackList.add("听说爱情回来过");
        blankDisc.setTracks(trackList);
        return blankDisc;
    }
}

在XML配置文件中通过<bean>元素导入Java配置：

<bean class="com.godman.xmlAndjavaconfig.CDConfig"/>
<bean id="cdPlayer" class="com.godman.xmlAndjavaconfig.CDPlayer" p:compactDisc-ref="blankDisc"/>

又或者创建一个更高层级的XML配置文件，通过<import>和<bean>元素分别将xml配置和Java配置导入：

<import resource="cd-config.xml"></import>
<bean class="com.godman.xmlAndjavaconfig.CDPlayerConfig"></bean>

测试代码如下：

package test.com.godman.xmlAndjavaconfig;

import com.godman.xmlAndjavaconfig.CompactDisc;
import com.godman.xmlAndjavaconfig.MediaPlayer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * CDPlayer Tester. 
 * 
 * @author <Authors name> 
 * @since <pre>七月 22, 2018</pre> 
 * @version 1.0 
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="/applicationContext.xml")
public class CDPlayerTest { 

    @Autowired
    private CompactDisc compactDisc;

    @Autowired
    private MediaPlayer mediaPlayer;

    @Test
    public void cdShouldNotNull(){
        Assert.assertNotNull(compactDisc);
    }

    @Test
    public void play(){
        mediaPlayer.player();
    }
}