《Spring实战》读书笔记1

一、Spring的核心

1、什么是POJO?

       POJO，是“Plain Old Java Object”的缩写，意思是普普通通的Java对象，这个概念是为了与javebean区别，POJO这个名字用来强调它是一个普通的java对象，而不是一个特殊的对象，其主要用来指定那些没有遵从特定的java对象模型、约定或框架（如EJB）的Java对象，理想地讲，一个POJO是一个不受任何限制的Java对象（除了java语言规范）。

       相对应地，Jave Bean 则比POJO复杂很多，JavaBean是可复用的组件，理论上讲，任何一个Java类都可以是一个Bean。但是通常情况下，由于Jave Bean是被容器所创建（如Tomcat）的,所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性，等等。

       正如POJO名词的发明者Martin Fowler个人网站的一句话：

       “We wondered why people were so against using regular objects in their systems and concluded that it was becasue simple objects lacked a fancy name. So we gave them one, and it's caught on very nicely.” -- Matrin Fowler

       我们疑惑为什么人们不喜欢在他们的系统中使用普通的对象，我们得到的结论是——普通的对象缺少一个响亮的名字，因此我们给它们起了一个，并且取得了很好的效果。 --Martin Fowler

2、什么是依赖注入（Dependency Injection, DI）?

     首先要搞清楚DIP、IoC、DI的概念。

     依赖倒置（DIP）。依赖倒置原则是面向对象软件设计的原则之一，它的含义是抽象不应该依赖于细节，细节应该依赖于抽象。例如现实中的ATM机与银行卡，ATM机不依赖于具体的某种银行卡。它只需定义好银行卡的规则参数（接口），所有实现了这种规格参数的银行卡都能在ATM上使用。也就是说抽象不应该依赖于实现，实现应该依赖于抽象。

     控制反转（IoC）。是一种反转流、依赖和接口的方式（DIP的具体实现方式），是一种软件设计的模式。它告诉我们应该如何做，来解除相互依赖模块的耦合。控制反转（IoC）,它为相互依赖的组件提供抽象，将依赖（底层模块）对象的获得交给第三方（系统）来控制，即依赖对象不在被依赖模块的类中直接通过new来获取。 例如，ATM系统，ATM是上层模块，银行卡是底层模块，ATM将具体插入哪种银行卡的工作交给了操作人来控制。

     依赖注入（DI）。是IoC的一种实现方式，用来反转依赖（IoC的具体实现方式）。就是将依赖对象的创建和绑定转移到被依赖对象类的外部来实现。具体实现依赖注入的方式有：构造函数注入、属性注入、接口注入。

     DIP、IoC、DI的意图都是实现软件组件的松耦合。

参看：《深入理解DIP、IoC、Di以及IoC容器》http://www.cnblogs.com/liuhaorain/p/3747470.html

参看：《控制反转(IoC)与依赖注入(DI)》http://zhangjunhd.blog.51cto.com/113473/126530/

3、什么是面向切面编程（aspect-oriented programming, AOP）?

     AOP（Aspect-OrientedProgrammng,面向切面编程），可以说是OOP（Object-Oriented Programing,面向对象编程）的补充和完善。OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系，例如日志功能。日志代码往往水平地散步在所有对象层次中，而与它所散步到的对象的核心功能毫无关系。这种散布在各处的代码被称为横切（crosscutting）代码。

     AOP技术，利用一种称为“横切”的技术，解剖开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为“Aspect”,即方面。使用“横切”技术，AOP把软件系统分为两个部分：和兴关注点和横切关注点。实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态植入的方式，引入特定的语法创建“切面”，从而使得编译器可以在编译期间植入有关“切面”的代码。

      AOP的使用场景：Authentication(权限)、Caching(缓存)、Context passing(内容传递)、Error handing(错误处理)、Lazy loading(懒加载)、Debugging(调试)、logging，tracing,profiling and monitoring (记录跟踪 优化 校准)、Performance optimization (性能优化)、Persistence (持久化)、Resource pooling(资源池)、Synchronization (同步)、Transactions(事务)。

参看：http://blog.csdn.net/moreevan/article/details/11977115/

二、Spring 容器

     Spring容器（container）负责创建对象，装配它们，配置它们并管理它们的整个生命周期。

     Spring容器可以归为两种不同的类型，bean工厂是最简单的容器，提供基本的DI支持；另一种是应用上下文是基于BeanFactory创建，并提供应用框架级别的服务。

     Spring自带了多种类型的应用上下文。最常遇到的有：

【】AnnotationConfigApplicationContext : 从一个或多个基于Java的配置类中加载Spring应用上下文；

【】AnnotationConfigWebApplicationContext: 从一个或多个基于Java的配置类中加载Spring Web应用上下文；

【】ClassPathXmlApplicationContext:从类路径下的一个或多个XML配置文件中加载上下文定义。

【】FileSystemXmlApplicationContext:从文件系统下的一个或多个XML配置文件中加载上下文定义。

【】XmlWebApplicationContext:从Web应用下的一个或多个XML配置文件中加载上下文定义。

三、Spring风景线

    Spring本身包含6大模块：数据访问与集成、Web与远程调用、面向切面编程、Instrumentation、Spring核心容器、测试。

    除此之外，还有众多的项目是基于Spring建立的，如Spring Web Flow、Spring Web Service、Spring Security、Spring Integration、Spring Batch、Spring Data、Spring Social、Spring Mobile、Spring for Android、Spring Boot等。

三、装配Bean

      在Spring中，对象无需自己查找或创建与其所关联的其他对象。相反，容器负责把需要相互协作的对象引用赋予各个对象。创建应用对象之间协作关系的行为通常称为装配（wiring）,这也是依赖注入（DI）的本质。

1、Spring配置的可选方案

【】在XML中进行显式配置

【】在Java中进行显式配置

【】隐式的bean发现机制和自动装配

2、自动化装配bean

(1)、创建可被发现的bean

      在类上使用@Component注解，该类就会作为组件类，并告知Spring要为这个类创建bean。

组件扫描默认不是启用的额，需要显式配置Spring,从而命令Spring去寻找带有@Component注解的类，并为其创建bean。

其中一个方法是：创建一个配置类，该类加上@ComponentScan注解。如果没有其他配置的话，@ComponentScan默认会扫描与配置类相同的包以及这个包下的所有子包，查找带有@Component注解的类，然后Spring就会为这些类自动创建bean。

另外一种方法是：使用Spring context命名空间的<context:component-scan>元素，例如：

<?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">  <context:component-scan base-package="soundsystem"></beans>

(2)、为组件扫描的bean命名

     Spring应用上下文中所有的bean都会给定一个ID。如果你没有明确的设置bean ID,那么Spring会根据类名为其指定一个ID,具体就是将类名的第一个字母变为小写。如果要为bean设置不同的ID,需要将期望的ID作为值传递给@Component注解。例如：

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

     另一种方法，使用Java依赖注入规范(Java Dependency Injection)中所提供的@Named注解来为bean设置ID, 例如：

import javax.inject.Named;//@Component("lonelyHeartsClub")@Named("lonelyHeartsClub")public class SgtPeppers implements CompactDisc {...}

     注：一般推荐使用@Component注解

(3)、设置组件扫描的基础包

     没有为@ComponentScan设置任何属性，那么默认地，Spring会以配置类所在的包作为基础包（base package）来扫描组件。

     为了指定不同的基础包，可以采用以下方法：

方法一：可以在@ComponentScan的value属性中指明包的名称：例如：

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

方法二：通过@ComponentScan的basePackage属性，例如：

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

另外，可以设置多个基础包，例如：

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

方法三：通过@ComponentScan的basePackageClasses, 这样指定的类或接口所在的包就会作为组件扫描的基础包，例如：

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

另外，也可以设置多个类或接口，例如：

@Configuration//@ComponentScan(basePackages= {"soundsystem", "video"})@ComponentScan(basePackageClasses= {SgtPeppers.class, CompactDisc.class})public class CDPlayerConfig {}

注：可以在期望作为基础包的包中创建一个用来进行扫描的空标记接口（marker interface），将basePackageClasses指定为markerInterface.class，通过标记接口的方式，就能够保持对重构友好的接口引用。

public interface markerInterface {}

(4)、通过为bean添加注解实现自动装配 

      在自动装配过程中，Spring会在Spring应用上下文中寻找匹配某个bean需求的其他bean。为了声明要进行自动装配，我们可以借助Spring的@Autowired注解。

@Autowired注解可以用在构造器、Setter方法还有其他方法上，假如有且只有一个bean匹配依赖需求的话，那么这个bean将会被装配进来，如果没有匹配的bean,那么在应用上下文创建的时候，Spring会抛出一个异常。为了避免异常出现，可以将@Autowired的required属性设置为false。例如：

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

注：当required属性为false时，Spring会尝试执行自动装配，但是如果没有匹配的bean的话，Spring将会让这个bean处于未装配的状态，这时这个未装配的bean的属性有可能会出现NullPointer。

注：@Autowired是Spring特有的注解，可以使用来源于Java依赖注入规范的@Inject替代。

3、通过Java代码装配bean

       尽管组件扫描和自动装配实现Spring的自动化配置，是推荐的做法，但是如果你需要将第三方的组件装配到你的应用中，就必须明确的配置Spring,因为你不能在第三方库的类上添加注解。

      进行显式装配，有两种可选方案：Java和XML。

(1)、Java方案：JavaConfig

     在进行显式配置时，JavaConfig是更好的方案，因为它更为强大、类型安全并且对重构友好。注意：尽管JavaConfig是Java代码，但是与其他的Java代码是有区别的，JavaConfig是配置代码，不应该包含任何业务逻辑，也不应该入侵到业务逻辑代码中，通常将JavaConfig放置到单独的包中，使它与其他应用程序逻辑分离开来。

第一步：创建配置类

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

第二步：声明简单的bean

     在配置类中编写一个方法，这个方法创建所需类型的实例，然后给这个方法添加@Bean注解。例如：

@Beanpublic CompactDisc sgtPeppers() {return new SgtPeppers();}

     注：@Bean注解会告诉Spring这个方法将会返回一个对象，该对象要注册为Spring应用上下文的bean。

     注：默认情况下，bean的ID与带有@Bean注解的方法名是一样的。如上例中的bean的ID为sgtPepper,如果想要为bean指定一个不同的名字，可以通过@Bean的name属性指定一个不同的名字，例如：

@Bean(name="lonelyHeartsClubBand")public CompactDisc sgtPeppers() {return new SgtPeppers();}

这时bean的名字就是lonelyHeartsClubBand。

第三步：借助JavaConfig实现注入

      在JavaConfig中，Spring是如何将bean所依赖的对象注入到bean中的？

一种方式是：

@Beanpublic CDPlayer cdPlayer() {return new CDPlayer(sgtPeppers());}

     注意：看起来CDPlayer的依赖对象是通过sgtPeppers()方法获取的，但实际上并非如此，因为sgtPeppers()方法上添加了@Bean注解，Spring将会拦截所有对它的调用，并确保直接返回该方法所创建的bean,而不是每次都对其进行实际的调用。

另一种方式是：

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

在这里，cdPlayer()方法请求一个CompactDisc作为参数。当Spring调用cdPlayer()创建CDPlayer bean的时候，它会自动装配一个CompactDisc到配置方法之中。

另外，可以通过Setter方法注入CompactDisc,例如：

@Beanpublic CDPlayer cdPlayer(CompactDisc compactDisc) {CDPlayer cdPlayer = new CDPlayer(compactDisc);cdPlayer.setCompactDisc(compactDisc);return cdPlayer;}

4、通过XML装配bean

   XML曾经是Spring描述配置的主要方式，但是现在Spring有了强大的自动化配置和基于Java的配置，XML不应再作为第一选择。推荐使用自动化配置和基于Java的配置。

(1)、创建XML配置文件

     使用Spring Tool Suite可以很方便地创建XML配置文件，该xml文件顶部声明了多个XML模式（XSD）文件，这些文件定义了配置Spring的XML元素。

如果该XML是bean的配置文件，那么要以<beans>元素为根元素。

     注：用来装配bean的最基本的XML元素包含在spring-beans模式之中，<beans>是该模式中的一个元素，它是所有Spring配置文件的根元素。

下面是一个最简单的Spring 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"  xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context"><!-- configuration details go here --></beans>

(2)、声明一个简单的<bean>

    <bean>元素类似于JavaConfig中的@Bean注解，例如，可以如下方式声明一个CompactDisc bean：

<bean class="soundsystem.SgtPeppers" />

    注：创建这个bean的类通过class属性来指定，并且要使用全限定的类名。

    注：如果没有明确给定ID,bean将根据全限定类名来进行命名，本例中为：“soundsystem.SgtPeppers#0”,其中，“#0”是一个计数的形式，用来区分其他相同类型的其他bean。

    注：尽管自动化的bean命名方式非常方便，但是如果引用起来就不太方便，通常来讲更好的方式是借助id属性，为每一个bean设置一个自己选择的名字，例如：

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

    注：为了减少XML中繁琐的配置，只对那些需要按名字引用的bean(比如，需要将对它的引用注入到另外一个bean中)进行明确的命名。

(3)、借助构造器注入初始化bean

    在XML中声明DI时，会有多种可选的配置方案和风格，有两种基本的配置方案可供选择：

【】<constructor-arg>元素

【】使用Spring3.0所引入的c-命名空间

例如使用<constructor-arg>:

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

    当Spring遇到这个<bean>元素时，它会创建一个CDPlayer实例，<constructor-arg>元素会告诉Spring要将一个ID为compactDisc的bean引用传递到CDPlayer的构造器中。

另一个方案，使用Spring的c-命名空间：

<?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">  ...  <bean id="cdPlayer" class="soundsystem.CDPlayer"c:cd-ref="compactDisc" />  </beans>

注意：如上述代码，需要先在XML的顶部声明c-命名空间的模式声明，然后就可以声明bean。其中属性中：c:表示命名空间的前缀，cd表示构造器参数名，-ref表示正在装配一个bean的引用，这个bean的名字是compactDisc，而不是字面量“compactDisc”。

       由于直接使用构造器参数名（这里为cd）是不太好的，因为如果代码重构，构造器的参数名改变了，那么配置文件也要相应改动，一种替代方案是使用参数在整个参数表中的位置信息。例如：

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

注意：上述的0就表示参数在构造器参数列表中的位置索引。

(4)、将字面量注入到构造器中

例如：

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

注意，这里使用了value属性，通过该属性表明给定的值要以字面量的形式注入到构造器中。

如果使用c-命名空间的话，可以如下：

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

或者：

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

(5)、装配集合

     有时候，需要为bean的构造器传递列表参数，例如List<String> tracks。尽管可以传递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>

     通常情况下，需要传入真实的列表，可以使用<list>元素将其声明成一个列表，例如：

<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>A</value>    <value>B</value>    <value>C</value>    <value>D</value>    <value>E</value>    </list>    </constructor-arg></bean>

其中，<list>元素为<constructor-arg>的子元素，其中<value>元素用来指定列表中的每个元素。

    类似地，可以使用<ref>元素替代<value>，实现bean引用列表的装配，例如：

假定有Discography类，它的构造器如下：public Discography(String artist, List<CompactDisc> cds) {...}，则

<bean id="beatlesDiscography"class="soundsystem.Discography"><constructor-arg value="The Beatles" /><constructor-arg><list><ref bean="sgtPeppers" /><ref bean="whiteAlbum" /><ref bean="hardDaysNight" /><ref bean="revolver" />...</list></constructor-arg></bean>

    同样地，当构造器参数为java.util.List时，我们使用<list>元素,也可以使用<set>元素，此时重复的值会被忽略，存放顺序也不会得到保证。

    注：c-命名空间无法实现装配集合的功能

(6)、设置属性

     我们可以将bean的依赖通过构造器注入，当然也可以通过属性的Setter方法注入。对于是该选择构造器注入还是属性注入呢？作为一个通用的规则：对强依赖使用构造器注入，而对于可选性的依赖使用属性注入。

     属性注入的示例如下：

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

其中，<property>元素为属性的Setter方法所提供的功能于<constructor-arg>元素为构造器所提供的功能是一样的。在本例中，它引用了ID为compactDisc的bean(通过ref属性)，并将其注入到compactDisc属性中（通过setCompactDisc()方法）。

      注意：Spring中<constructor-arg>元素提供了c-命名空间作为替代方案，同样的，更加简洁的p-命名空间，可作为<property>元素的替代方案。p-命名空间中属性所遵循的命名约定与c-命名空间中的属性类似。例如：

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"  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">  ...  <bean id="cdPlayer" class="soundsystem.CDPlayer"p:compactDisc-ref="compactDisc" />  </beans>

(7)、将字面量注入到属性中

      借助<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>

    使用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></list></property></bean>

    注意，和c-命名空间一样，p-命名空间不能用来装配集合。但是可以使用Spring util- 命名空间中的一些功能来简化集合的使用。例如：

<?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:p="http://www.springframework.org/schema/p"  xmlns:util="http://www.springframework.org/schema/util"  xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util.xsd">  <util:list id="trackList"><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>  </util:list>    <bean id="compactDisc" class="soundsystem.BlankDisc"p:title="Sgt. Pepper's Lonely Hearts Club Band"p:artist="The Beatles"p:tracks-ref="trackList" />  </beans>

    首先，在XML中声明util-命名空间及其模式。然后使用<util:list>元素将列表内容转移到bean声明之外，再将单独的列表bean “trackList”注入到BlankDisc bean的tracks属性中。

     注：util-命名空间中有多个类似于<util:list>的元素，比如<util:constant>、<util:list>、<util:map>、<util:properties>、<util:property-path>、<util:set>等。

5、导入和混合配置

     在典型的Spring应用中，我们可能会同时使用自动化和显示配置。在Spring中，这些配置方案都不是互斥的，可以混合使用。

(1)、在JavaConfig中引入XML配置

     假设我们将不同的bean，通过JavaConfig配置在不同的config类中，比如BlankDisc配置在CDConfig类中，CDPlayer配置在CDPlayerConfig类中，它们都存在于soundsystem包下面，那么将这两个配置类组合到一起的方法有：

    方法一：在其中一个config类中，使用@Import注解,导入另一个config类，例如：

@Configuration@Import(CDConfig.class)public class CDPlayerConfig {@Beanpublic CDPlayer cdPlayer(CompactDisc compactDisc) {return new CDPlayer(compactDisc);}}

    注，上述代码，将CDConfig类通过@Import注解导入到了CDPlayerConfig类中。

    方法二：创建一个更高层的(根据包名创建的配置类)配置类，在这个类中使用@Import将其他配置类组合在一起，例如：

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

     注：上述代码，根据CDConfig类、CDPlayerConfig类所在的包名soundsystem，创建了高层次的配置类SoundSystemConfig类，并将CDPlayerConfig类和CDConfig类，通过@Import导入到SoundSystemConfig类中。

     假设将BlankDisc配置不放在CDConfig类中，而是将其配置在xml文件cd-config.xml中，那么如何将xml中的bean配置和Java Config类中的bean配置组合到一起，让Spring能同时加载它们呢？

      方法是使用@ImportResource注解,例如：假设cd-config.xml文件位于根类路径下，那么可以修改SoundSystemConfig，让它使用@ImportResource注解：

@Configuration@Import(CDPlayerConfig.class)@ImportResource("classpath:cd-config.xml")public class SoundSystemConfig {}

    注：上述代码中，一个bean通过JavaConfig配置，另一个bean通过xml配置，采用这种方式，就都会被加载到Spring容器中。

(2)、在XML配置中引入JavaConfig

     类似于JavaConfig中使用@Import来拆分JavaConfig类，在XML中可以使用<import>元素来拆分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:c="http://www.springframework.org/schema/c"  xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans.xsd">  <import resource="cd-config.xml"/>  <bean id="cdPlayer" class="soundsystem.CDPlayer"c:cd-ref="compactDisc" />  </beans>

    注：上述代码中，通过<import>元素导入了其他XML配置文件。
    现在假设，需要将JavaConfig中的bean配置导入到xml配置中，这时我们应该想到JavaConfig也是java 类，因此可以作为bean配置在XML中，所以讲JavaConfig类导入到XML配置中的方法就是创建JavaConfig类的bean,例如：

<?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:c="http://www.springframework.org/schema/c"  xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean class="soundsystem.CDConfig" />  <bean id="cdPlayer" class="soundsystem.CDPlayer"c:cd-ref="compactDisc" />  </beans>

   注：上述代码在xml配置中，创建了JavaConfig类soundsystem.CDConfig类的bean。

注意：一般在进行装配时，我们通常会创建一个根配置（root configuration），这个配置会将两个或更多的装配类或XML文件组合起来。再在根配置中启动组件扫描（通过<context:component-scan>或@ComponentScan）。

例如，根配置可以像下面这样，将不同的配置组合起来：

<?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:c="http://www.springframework.org/schema/c"  xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean class="soundsystem.CDConfig" />  <import resource="cdplayer-config.xml" />  </beans>