装配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的介绍，下一篇会举一个实例进行测试，因为代码较多，考虑到文章太长让人看着容易疲劳，我决定单独写一篇来记录。