装配SpringBean(三)--XML方式实例

前一篇文章中已经介绍了XML方式装配bean的方式，本文将综合这些方式举一个实例并进行测试，我会把所有类型的参数都放在同一个类中进行测试，下面是我的类结构：

上图是我画的一个基本结构，可以看出该类中有基本类型变量、引用变量、属性变量、集合变量且集合元素有基本类型和引用类型，我的引用类型中所有变量使用基本类型，所以先来创建两个引用类型CoderCard和CoderProject。

一、装配bean

1⃣️创建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();
     }
 }

2⃣️创建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();
     }
 }

3⃣️创建Coder.java

 public class Coder {
     private String id;
     private String coderName;
     private Integer coderAge;
     private Integer coderSalary;
         private CoderCard coderCard;
         private Properties prop;

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

     private Map<String, String> coderBugMap;

     private Set<String> coderBugSet;

     private String[] coderBugArray;

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

     private Map<CoderCard, CoderProject> coderProjectMap;

     private Set<CoderProject> coderProjectSet;

     private CoderProject[] coderProjectArray;

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

     public void setCoderCard(CoderCard coderCard) {
         this.coderCard = coderCard;
     }

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

     public Properties getProp() {
         return prop;
     }

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

     public String[] getCoderBugArray() {
         return coderBugArray;
     }

     public void setCoderBugArray(String[] coderBugArray) {
         this.coderBugArray = coderBugArray;
     }

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

 }

4⃣️XML中进行装配：spring-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"
     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>
         <!-- 装配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>
         <!-- 装配集合，集合元素是基本类型 -->
         <!-- 基本类型－装配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>

         <!-- 装配集合，集合元素是引用类型 -->
         <!-- 引用类型－装配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="coderCard" class="com.hyc.pojo.CoderCard">
         <property name="id" value="1"></property>
         <property name="cardNotes" value="张三的工牌"></property>
         <property name="coderId" value="1"></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>

二、测试装配结果

1⃣️编写测试方法

因为我测试使用的是junit单元测试，所以先来编写一个单元测试积基类，完成ClassPathXmlApplicationContext类的实例化等操作；

第一步：创建单元测试基类

 package com.test.xml;

 import org.junit.After;
 import org.junit.Before;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 /**
  * Unit test for simple App.
  */
 public class BaseTest {

     public String xmlPath;
     public ClassPathXmlApplicationContext context;

     public BaseTest(String xmlPath) {
         this.xmlPath = xmlPath;
     }

     @Before
     public void before() {
         if (xmlPath.isEmpty()) {
             xmlPath = "classpath*:spring-*.xml";
         }
         context = new ClassPathXmlApplicationContext(xmlPath.split("[,\\s]"));
         context.start();
     }

     @SuppressWarnings("deprecation")
     @After
     public void after() {
         context.destroy();
     }

 }

第二步：创建bean装配的测试类，编写测试方法

 package com.test.xml;

 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;

 import org.junit.Test;

 import com.hyc.controller.CoderController;
 import com.hyc.pojo.Coder;
 import com.hyc.pojo.CoderCard;
 import com.hyc.pojo.CoderProject;

 /*
  * 各种数据类型装载测试（XML方式）
  */
 public class SpringBeanTest extends BaseTest {
     public SpringBeanTest() {
         super("classpath*:spring-bean.xml");
     }

     /**
      * 基本数据类型装配测试
      */
     @Test
     public void testBaseBean() {
         Coder coder = (Coder) super.context.getBean("coder");
         String name = coder.getCoderName();
         System.out.println("name:" + name);
         int age = coder.getCoderAge();
         System.out.println("age:" + age);
         int salary = coder.getCoderSalary();
         System.out.println("salary:" + salary);
         String cardNotes = coder.getCoderCard().getCardNotes();
         System.out.println("cardNotes:" + cardNotes);
         Properties props = coder.getProp();
         System.out.println("props:" + props.getProperty("bug-key-1"));
     }

     /**
      * 装配集合类型，集合元素是基本数据类型
      */
     @Test
     public void testBaseCollection() {
         Coder coder = (Coder) super.context.getBean("coder");
         List<String> bugList = coder.getCoderBugList();
         System.out.println("bugList:" + bugList.size());
         Map<String, String> bugMap = coder.getCoderBugMap();
         System.out.println("bugMap:" + bugMap.size());
         String[] bugArray = coder.getCoderBugArray();
         System.out.println("bugArray:" + bugArray.length);
         Set<String> bugSet = coder.getCoderBugSet();
         System.out.println("bugSet:" + bugSet.size());
     }

     /**
      * 装配集合类型，集合元素是引用类型
      */
     @Test
     public void testRefCollection() {
         Coder coder = (Coder) super.context.getBean("coder");
         List<CoderProject> projectList = coder.getCoderProjectList();
         System.out.println("projectList:" + projectList.size());
         Map<CoderCard, CoderProject> projectMap = coder.getCoderProjectMap();
         System.out.println("projectMap:" + projectMap.size());
         CoderProject[] projectArray = coder.getCoderProjectArray();
         System.out.println("projectArray:" + projectArray.length);
         Set<CoderProject> projectSet = coder.getCoderProjectSet();
         System.out.println("projectSet:" + projectSet.size());
     }

 }

以上就是测试代码：

第一个方法是测试基本类型、引用类型和Properties类型；

第二个方法是测试集合类型，集合元素是基本类型；

第三个方法是测试集合类型，集合元素是引用类型；

测试时只要选中方法名，右击－Run As-Junit Test即可，如果要同时测试所有的方法，直接在该类中右击－Run As-Junit Test就行。测试集合的时候我只是输出了集合的size

2⃣️查看测试结果

以上就是通过XML装配bean的完整实例，其实这种方式是比较简单的，缺点是需要配置很多内容，为了解决这一缺陷，spring又提供了另外一种注解的方式，下一篇文章我将进行总结。