装配SpringBean(二)--XML方式介绍

装配SpringBean，我理解的意思就在容器中定义一个bean，然后让容器通过某种方式找到它。因为在Spring中一切皆资源，资源就是所谓的bean，我们怎么才能从容器中获取这些资源呢？那就是控制反转Ioc（Inversion of Control）虽然我们不需要知道容器是怎么帮我们创建这些bean的，但最起码我们要告诉容器我们需要的是一个什么样的bean吧，所以告诉的过程就是我们装配的过程。spring中有两种装配方式：

• XML方式
• 注解方式

这篇文章主要介绍XML的装配方式

一般我们都是装配自定义的bean，也就是把我们自定义的类装配到ioc容器中，但是类的成员变量有很多种，比如基本类型、引用类型、集合类型及集合元素的不同类型等，下面根据不同的情况举例说明。

一、成员变量是基本类型的装配

第一步：创建一个类

 public class CoderCard {

     private String id;

     private String cardNotes;

     private String coderId;

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id == null ? null : id.trim();
     }

     public String getCardNotes() {
         return cardNotes;
     }

     public void setCardNotes(String cardNotes) {
         this.cardNotes = cardNotes == null ? null : cardNotes.trim();
     }

     public String getCoderId() {
         return coderId;
     }

     public void setCoderId(String coderId) {
         this.coderId = coderId == null ? null : coderId.trim();
     }
 }

第二步：在XML总配置这个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"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd">
         <--该bean的属性都是基本类型，并可以定义属性值-->
     <bean id="coderCard" class="com.hyc.pojo.CoderCard">
         <property name="id" value="1"></property>
         <property name="cardNotes" value="张三的工牌"></property>
         <property name="coderId" value="1"></property>
     </bean>
 </beans>

通过上面两步就完成了基本类型的装配。

二、成员变量是引用类型的装配

假设有一个程序员Coder类，它除了一些基本类型的成员变量之外，还有有一个引用类型成员变量是工牌CoderCard， 所以我需要定义两个类并在配置文件中装配。

第一步：创建Coder.java

 public class Coder {

     private String id;

     private String coderName;

     private Integer coderAge;

     private Integer coderSalary;

     private CoderCard coderCard;

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id == null ? null : id.trim();
     }

     public String getCoderName() {
         return coderName;
     }

     public void setCoderName(String coderName) {
         this.coderName = coderName == null ? null : coderName.trim();
     }

     public Integer getCoderAge() {
         return coderAge;
     }

     public void setCoderAge(Integer coderAge) {
         this.coderAge = coderAge;
     }

     public Integer getCoderSalary() {
         return coderSalary;
     }

     public void setCoderSalary(Integer coderSalary) {
         this.coderSalary = coderSalary;
     }

     public CoderCard getCoderCard() {
         return coderCard;
     }
 }

第二步：创建CoderCard.java(上面已经定义过了)

 public class CoderCard {

     private String id;

     private String cardNotes;

     private String coderId;

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id == null ? null : id.trim();
     }

     public String getCardNotes() {
         return cardNotes;
     }

     public void setCardNotes(String cardNotes) {
         this.cardNotes = cardNotes == null ? null : cardNotes.trim();
     }

     public String getCoderId() {
         return coderId;
     }

     public void setCoderId(String coderId) {
         this.coderId = coderId == null ? null : coderId.trim();
     }
 } 

第三步：在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.xsd">

     <bean id="coder" class="com.hyc.pojo.Coder">
         <!-- 装配简易值 -->
         <property name="id" value="1"></property>
         <property name="coderName" value="张三"></property>
         <property name="coderAge" value="26"></property>
         <property name="coderSalary" value="10000"></property>
         <!--装配对象 -->
         <property name="coderCard" ref="coderCard"></property>
     </bean>

     <!-- 对象作为成员变量 -->
     <bean id="coderCard" class="com.hyc.pojo.CoderCard">
         <property name="id" value="1"></property>
         <property name="cardNotes" value="张三的工牌"></property>
         <property name="coderId" value="1"></property>
     </bean>
 </beans>

装配引用类型的变量时，有两个关键点：

1⃣️引用变量通过属性ref指向一个bean

2⃣️定义ref所指的bean，其中ref的值就是bean的id

三、成员变量是集合类型的装配

成员变量是集合的时候，还要区分该集合中的元素类型，也分为基本数据类型和引用类型两种。

1⃣️集合元素是基本数据类型

第一步：定义一个包含各种集合类型的类，集合元素都为基本数据类型

 public class Coder {

     // 集合元素是基本类型
     private List<String> coderBugList;

     private Map<String, String> coderBugMap;

     private Set<String> coderBugSet;

     private String[] coderBugArray;

     public List<String> getCoderBugList() {
         return coderBugList;
     }

     public void setCoderBugList(List<String> coderBugList) {
         this.coderBugList = coderBugList;
     }

     public Map<String, String> getCoderBugMap() {
         return coderBugMap;
     }

     public void setCoderBugMap(Map<String, String> coderBugMap) {
         this.coderBugMap = coderBugMap;
     }

     public Set<String> getCoderBugSet() {
         return coderBugSet;
     }

     public void setCoderBugSet(Set<String> coderBugSet) {
         this.coderBugSet = coderBugSet;
     }
 ｝

在上面的类中定义了List、Map、Set和数组四种集合类型，并且它们的元素都是String，下面在XML中装配

第二步：在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.xsd">

     <bean id="coder" class="com.hyc.pojo.Coder">
         <!-- 装配集合，集合元素是基本类型 -->
         <!-- 基本类型－装配List -->
         <property name="coderBugList">
             <list>
                 <value>bug-list-1</value>
                 <value>bug-list-2</value>
                 <value>bug-list-3</value>
             </list>
         </property>

         <!-- 基本类型－装配Map -->
         <property name="coderBugMap">
             <map>
                 <entry key="bug1" value="bug-map-1" />
                 <entry key="bug2" value="bug-map-2" />
                 <entry key="bug3" value="bug-map-3" />
             </map>
         </property>

         <!-- 基本类型－装配Set -->
         <property name="coderBugSet">
             <set>
                 <value>bug-set-1</value>
                 <value>bug-set-2</value>
                 <value>bug-set-3</value>
             </set>
         </property>

         <!-- 基本类型－装配Array -->
         <property name="coderBugArray">
             <array>
                 <value>bug-array-1</value>
                 <value>bug-array-2</value>
                 <value>bug-array-3</value>
             </array>
         </property>
 </beans>

2⃣️集合元素是引用类型

当集合元素是引用类型是，首先要定义引用类。假设一个程序员类Coder.java中有多个集合，它们的元素类型是项目类CoderProject.java，其中集合map的key设置为上面的CoderCard.java，所以这里不再重定义，只要定义CoderProject.java即可。

第一步：定义引用类型

 public class CoderProject {
     private String id;

     private String projectName;

     private String projectVersion;

     private String projectDesc;

     public String getId() {
         return id;
     }

     public void setId(String id) {
         this.id = id == null ? null : id.trim();
     }

     public String getProjectName() {
         return projectName;
     }

     public void setProjectName(String projectName) {
         this.projectName = projectName == null ? null : projectName.trim();
     }

     public String getProjectVersion() {
         return projectVersion;
     }

     public void setProjectVersion(String projectVersion) {
         this.projectVersion = projectVersion == null ? null : projectVersion.trim();
     }

     public String getProjectDesc() {
         return projectDesc;
     }

     public void setProjectDesc(String projectDesc) {
         this.projectDesc = projectDesc == null ? null : projectDesc.trim();
     }
 } 

第二步：定义一个包含各种集合类型的类，集合元素都为引用类型

 public class Coder {

     // 集合元素是引用类型
     private List<CoderProject> coderProjectList;

     private Map<CoderCard, CoderProject> coderProjectMap;

     private Set<CoderProject> coderProjectSet;

     private CoderProject[] coderProjectArray;

     public List<CoderProject> getCoderProjectList() {
         return coderProjectList;
     }

     public void setCoderProjectList(List<CoderProject> coderProjectList) {
         this.coderProjectList = coderProjectList;
     }

     public Map<CoderCard, CoderProject> getCoderProjectMap() {
         return coderProjectMap;
     }

     public void setCoderProjectMap(Map<CoderCard, CoderProject> coderProjectMap) {
         this.coderProjectMap = coderProjectMap;
     }

     public Set<CoderProject> getCoderProjectSet() {
         return coderProjectSet;
     }

     public void setCoderProjectSet(Set<CoderProject> coderProjectSet) {
         this.coderProjectSet = coderProjectSet;
     }

     public CoderProject[] getCoderProjectArray() {
         return coderProjectArray;
     }

     public void setCoderProjectArray(CoderProject[] coderProjectArray) {
         this.coderProjectArray = coderProjectArray;
     }
 }

第三步：在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.xsd">

     <bean id="coder" class="com.hyc.pojo.Coder">

         <!-- 装配集合，集合元素是引用类型 -->
         <!-- 引用类型－装配List -->
         <property name="coderProjectList">
             <list>
                 <ref bean="coderProject1"/>
                 <ref bean="coderProject2"/>
             </list>
         </property>
         <!-- 引用类型－装配Map -->
         <property name="coderProjectMap">
             <map>
                 <entry key-ref="coderCard1" value-ref="coderProject1" />
                 <entry key-ref="coderCard2" value-ref="coderProject2" />
             </map>
         </property>
         <!-- 引用类型－装配Set -->
         <property name="coderProjectSet">
             <set>
                 <ref bean="coderProject1"/>
                 <ref bean="coderProject2"/>
             </set>
         </property>
         <!-- 引用类型－装配Array -->
         <property name="coderProjectArray">
             <array>
                 <ref bean="coderProject1"/>
                 <ref bean="coderProject2"/>
             </array>
         </property>
     </bean>

     <!-- 装配引用变量 -->
     <bean id="coderCard1" class="com.hyc.pojo.CoderCard">
         <property name="id" value="2"></property>
         <property name="cardNotes" value="李四的工牌"></property>
         <property name="coderId" value="2"></property>
     </bean>

     <bean id="coderCard2" class="com.hyc.pojo.CoderCard">
         <property name="id" value="3"></property>
         <property name="cardNotes" value="王麻子的工牌"></property>
         <property name="coderId" value="3"></property>
     </bean>

     <bean id="coderProject1" class="com.hyc.pojo.CoderProject">
         <property name="id" value="1"></property>
         <property name="projectName" value="管理系统"></property>
         <property name="projectVersion" value="V1.0"></property>
         <property name="projectDesc" value="管理配置"></property>
     </bean>
     <bean id="coderProject2" class="com.hyc.pojo.CoderProject">
         <property name="id" value="2"></property>
         <property name="projectName" value="存储系统"></property>
         <property name="projectVersion" value="V1.0"></property>
         <property name="projectDesc" value="存储配置"></property>
     </bean>
 </beans>

从上面两种配置方式中可以清晰看出集合装配时，因元素类型不同，装配方式略有区别。

四、成员变量是Properties的装配

第一步：创建含有Properties类型成员变量的类

 public class Coder {

     private Properties prop;

     public Properties getProp() {
         return prop;
     }

     public void setProp(Properties prop) {
         this.prop = prop;
     }
 ｝

第二步：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.xsd">

     <bean id="coder" class="com.hyc.pojo.Coder">

         <!-- 装配Properties -->
         <property name="prop">
             <props>
                 <prop key="bug-key-1">bug-prop-1</prop>
                 <prop key="bug-key-2">bug-prop-2</prop>
                 <prop key="bug-key-3">bug-prop-3</prop>
             </props>
         </property>
 </beans>

五、通过命名空间装配

除了上述配置之外，Spring还提供了对应命名空间的定义，只是在使用命名空间时要先引入对应的命名空间和XML模式文件XSD。

直接来看以下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:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util" 
    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/util
    http://www.springframework.org/schema/util/spring-util.xsd">

    <!-- 使用构造函数注入 ：c代表是构造函数（constructor）_i是构造函数中的参数下标，从0开始 -->
    <bean id="coderProject1" class="com.hyc.pojo.CoderProject" c:_0="1"
        c:_1="项目1" c:_2="1.0" c:_3="使用构造函数注入" />
    <!-- 使用setter方式注入： p是属性即成员变量（set）通过冒号：属性名的方式初始化成员变量的值 -->
    <bean id="coderProject2" class="com.hyc.pojo.CoderProject" p:id="1"
        p:projectName="项目1" c:projectVersion="1.0" c:projectDesc="使用setter注入" />

    <!--成员变量包含引用类型及集合的时候 -->
    <bean id="coder1" class="com.hyc.pojo.Coder" p:id="1" p:coderName="小张"
        p:coderAge="23" p:coderSalary="20000" p:coderCard-ref="coderCard"
        p:list-ref="list" p:map-ref="map" p:set-ref="set" />

    <!-- 定义引用变量coderCard -->
    <bean id="1" p:id="1" p:cardNotes="小张的工牌" p:coderId="1" />

    <!-- 定义集合变量list -->
    <util:list id="list">
        <ref bean="coderProject1" />
        <ref bean="coderProject2" />
    </util:list>

    <!-- 定义集合变量map -->
    <util:map id="map">
        <entry key="project1" value-ref="coderProject1" />
        <entry key="project2" value-ref="coderProject2" />
    </util:map>

    <!-- 定义集合变量set -->
    <util:set id="set">
        <ref bean="coderProject1" />
        <ref bean="coderProject2" />
    </util:set>
</beans>

上面的配置中，加粗的黑体部分是需要引入的命名空间和XML的模式文件XSD：

xmlns:c="http://www.springframework.org/schema/c通过构造函数注入所需

xmlns:p="http://www.springframework.org/schema/p通过setter方法注入所需

xmlns:util="http://www.springframework.org/schema/util为了注入集合类型所需

以上就是XML方式装配的例子，看代码就知道怎么回事了。完成了装配，我们怎么通过容器获取呢？Spring IoC容器的设计主要是基于BeanFactory和ApplicationContext两个接口，其中ApplicationContext是BeanFactory的子接口之一，它对BeanFactory进行了扩展，所以大多数情况下使用ApplicationContext作为Spring IoC容器，而通过XML方式装配的bean是通过ApplicationContext的一个类ClassPathXmlApplicationContext来实现的。

首先：实例化一个ClassPathXmlApplicationContext对象，参数为装配bean的spring配置文件

 String xmlPath = "classpath*:spring-bean.xml";
 ClassPathXmlApplicationContext     context = new ClassPathXmlApplicationContext(xmlPath);

然后：通过它的getBean方法来获取bean实例

 Coder coder = (Coder) context.getBean("coder");

getBean的方法有很多，可以传入bean名称、类型等不同的参数，可以看看BeanFactory和ApplicationContext接口查看，一般我们只用通过name获取的方法，其实这里的name就是我们在XML中配置的bean属性id。

以上就是对XML方式装配bean的介绍，下一篇会举一个实例进行测试，因为代码较多，考虑到文章太长让人看着容易疲劳，我决定单独写一篇来记录。