zoukankan html css js c++ java

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

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

XML方式
注解方式

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

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

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

第一步：创建一个类

 1 public class CoderCard {
 2 
 3     private String id;
 4 
 5     private String cardNotes;
 6 
 7     private String coderId;
 8 
 9     public String getId() {
10         return id;
11     }
12 
13     public void setId(String id) {
14         this.id = id == null ? null : id.trim();
15     }
16 
17     public String getCardNotes() {
18         return cardNotes;
19     }
20 
21     public void setCardNotes(String cardNotes) {
22         this.cardNotes = cardNotes == null ? null : cardNotes.trim();
23     }
24 
25     public String getCoderId() {
26         return coderId;
27     }
28 
29     public void setCoderId(String coderId) {
30         this.coderId = coderId == null ? null : coderId.trim();
31     }
32 }

第二步：在XML总配置这个bean

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5         http://www.springframework.org/schema/beans/spring-beans.xsd">
 6         <--该bean的属性都是基本类型，并可以定义属性值-->
 7     <bean id="coderCard" class="com.hyc.pojo.CoderCard">
 8         <property name="id" value="1"></property>
 9         <property name="cardNotes" value="张三的工牌"></property>
10         <property name="coderId" value="1"></property>
11     </bean>
12 </beans>

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

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

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

第一步：创建Coder.java

 1 public class Coder {
 2     
 3     private String id;
 4 
 5     private String coderName;
 6 
 7     private Integer coderAge;
 8 
 9     private Integer coderSalary;
10 
11     private CoderCard coderCard;
12 
13 
14     public String getId() {
15         return id;
16     }
17 
18     public void setId(String id) {
19         this.id = id == null ? null : id.trim();
20     }
21 
22     public String getCoderName() {
23         return coderName;
24     }
25 
26     public void setCoderName(String coderName) {
27         this.coderName = coderName == null ? null : coderName.trim();
28     }
29 
30     public Integer getCoderAge() {
31         return coderAge;
32     }
33 
34     public void setCoderAge(Integer coderAge) {
35         this.coderAge = coderAge;
36     }
37 
38     public Integer getCoderSalary() {
39         return coderSalary;
40     }
41 
42     public void setCoderSalary(Integer coderSalary) {
43         this.coderSalary = coderSalary;
44     }
45 
46     public CoderCard getCoderCard() {
47         return coderCard;
48     }
49 }

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

 1 public class CoderCard {
 2     
 3     private String id;
 4 
 5     private String cardNotes;
 6 
 7     private String coderId;
 8 
 9     public String getId() {
10         return id;
11     }
12 
13     public void setId(String id) {
14         this.id = id == null ? null : id.trim();
15     }
16 
17     public String getCardNotes() {
18         return cardNotes;
19     }
20 
21     public void setCardNotes(String cardNotes) {
22         this.cardNotes = cardNotes == null ? null : cardNotes.trim();
23     }
24 
25     public String getCoderId() {
26         return coderId;
27     }
28 
29     public void setCoderId(String coderId) {
30         this.coderId = coderId == null ? null : coderId.trim();
31     }
32 }

第三步：在XML中配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5         http://www.springframework.org/schema/beans/spring-beans.xsd">
 6 
 7 
 8     <bean id="coder" class="com.hyc.pojo.Coder">
 9         <!-- 装配简易值 -->
10         <property name="id" value="1"></property>
11         <property name="coderName" value="张三"></property>
12         <property name="coderAge" value="26"></property>
13         <property name="coderSalary" value="10000"></property>
14         <!--装配对象 -->
15         <property name="coderCard" ref="coderCard"></property>
16     </bean>
17 
18     <!-- 对象作为成员变量 -->
19     <bean id="coderCard" class="com.hyc.pojo.CoderCard">
20         <property name="id" value="1"></property>
21         <property name="cardNotes" value="张三的工牌"></property>
22         <property name="coderId" value="1"></property>
23     </bean>
24 </beans>

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

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

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

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

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

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

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

 1 public class Coder {
 2 
 3     // 集合元素是基本类型
 4     private List<String> coderBugList;
 5 
 6     private Map<String, String> coderBugMap;
 7 
 8     private Set<String> coderBugSet;
 9 
10     private String[] coderBugArray;
11 
12     public List<String> getCoderBugList() {
13         return coderBugList;
14     }
15 
16     public void setCoderBugList(List<String> coderBugList) {
17         this.coderBugList = coderBugList;
18     }
19 
20     public Map<String, String> getCoderBugMap() {
21         return coderBugMap;
22     }
23 
24     public void setCoderBugMap(Map<String, String> coderBugMap) {
25         this.coderBugMap = coderBugMap;
26     }
27 
28     public Set<String> getCoderBugSet() {
29         return coderBugSet;
30     }
31 
32     public void setCoderBugSet(Set<String> coderBugSet) {
33         this.coderBugSet = coderBugSet;
34     }
35 ｝

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

第二步：在XML中配置

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5         http://www.springframework.org/schema/beans/spring-beans.xsd">
 6 
 7 
 8     <bean id="coder" class="com.hyc.pojo.Coder">
 9         <!-- 装配集合，集合元素是基本类型 -->
10         <!-- 基本类型－装配List -->
11         <property name="coderBugList">
12             <list>
13                 <value>bug-list-1</value>
14                 <value>bug-list-2</value>
15                 <value>bug-list-3</value>
16             </list>
17         </property>
18 
19         <!-- 基本类型－装配Map -->
20         <property name="coderBugMap">
21             <map>
22                 <entry key="bug1" value="bug-map-1" />
23                 <entry key="bug2" value="bug-map-2" />
24                 <entry key="bug3" value="bug-map-3" />
25             </map>
26         </property>
27 
28         <!-- 基本类型－装配Set -->
29         <property name="coderBugSet">
30             <set>
31                 <value>bug-set-1</value>
32                 <value>bug-set-2</value>
33                 <value>bug-set-3</value>
34             </set>
35         </property>
36 
37         <!-- 基本类型－装配Array -->
38         <property name="coderBugArray">
39             <array>
40                 <value>bug-array-1</value>
41                 <value>bug-array-2</value>
42                 <value>bug-array-3</value>
43             </array>
44         </property>
45 </beans>

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

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

第一步：定义引用类型

 1 public class CoderProject {
 2     private String id;
 3 
 4     private String projectName;
 5 
 6     private String projectVersion;
 7 
 8     private String projectDesc;
 9 
10     public String getId() {
11         return id;
12     }
13 
14     public void setId(String id) {
15         this.id = id == null ? null : id.trim();
16     }
17 
18     public String getProjectName() {
19         return projectName;
20     }
21 
22     public void setProjectName(String projectName) {
23         this.projectName = projectName == null ? null : projectName.trim();
24     }
25 
26     public String getProjectVersion() {
27         return projectVersion;
28     }
29 
30     public void setProjectVersion(String projectVersion) {
31         this.projectVersion = projectVersion == null ? null : projectVersion.trim();
32     }
33 
34     public String getProjectDesc() {
35         return projectDesc;
36     }
37 
38     public void setProjectDesc(String projectDesc) {
39         this.projectDesc = projectDesc == null ? null : projectDesc.trim();
40     }
41 }

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

 1 public class Coder {
 2 
 3     // 集合元素是引用类型
 4     private List<CoderProject> coderProjectList;
 5 
 6     private Map<CoderCard, CoderProject> coderProjectMap;
 7 
 8     private Set<CoderProject> coderProjectSet;
 9 
10     private CoderProject[] coderProjectArray;
11 
12     public List<CoderProject> getCoderProjectList() {
13         return coderProjectList;
14     }
15 
16     public void setCoderProjectList(List<CoderProject> coderProjectList) {
17         this.coderProjectList = coderProjectList;
18     }
19 
20     public Map<CoderCard, CoderProject> getCoderProjectMap() {
21         return coderProjectMap;
22     }
23 
24     public void setCoderProjectMap(Map<CoderCard, CoderProject> coderProjectMap) {
25         this.coderProjectMap = coderProjectMap;
26     }
27 
28     public Set<CoderProject> getCoderProjectSet() {
29         return coderProjectSet;
30     }
31 
32     public void setCoderProjectSet(Set<CoderProject> coderProjectSet) {
33         this.coderProjectSet = coderProjectSet;
34     }
35 
36     public CoderProject[] getCoderProjectArray() {
37         return coderProjectArray;
38     }
39 
40     public void setCoderProjectArray(CoderProject[] coderProjectArray) {
41         this.coderProjectArray = coderProjectArray;
42     }
43 }

第三步：在XML中装配

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5         http://www.springframework.org/schema/beans/spring-beans.xsd">
 6 
 7 
 8     <bean id="coder" class="com.hyc.pojo.Coder">
 9 
10         <!-- 装配集合，集合元素是引用类型 -->
11         <!-- 引用类型－装配List -->
12         <property name="coderProjectList">
13             <list>
14                 <ref bean="coderProject1"/>
15                 <ref bean="coderProject2"/>
16             </list>
17         </property>
18         <!-- 引用类型－装配Map -->
19         <property name="coderProjectMap">
20             <map>
21                 <entry key-ref="coderCard1" value-ref="coderProject1" />
22                 <entry key-ref="coderCard2" value-ref="coderProject2" />
23             </map>
24         </property>
25         <!-- 引用类型－装配Set -->
26         <property name="coderProjectSet">
27             <set>
28                 <ref bean="coderProject1"/>
29                 <ref bean="coderProject2"/>
30             </set>
31         </property>
32         <!-- 引用类型－装配Array -->
33         <property name="coderProjectArray">
34             <array>
35                 <ref bean="coderProject1"/>
36                 <ref bean="coderProject2"/>
37             </array>
38         </property>
39     </bean>
40 
41     <!-- 装配引用变量 -->
42     <bean id="coderCard1" class="com.hyc.pojo.CoderCard">
43         <property name="id" value="2"></property>
44         <property name="cardNotes" value="李四的工牌"></property>
45         <property name="coderId" value="2"></property>
46     </bean>
47     
48     <bean id="coderCard2" class="com.hyc.pojo.CoderCard">
49         <property name="id" value="3"></property>
50         <property name="cardNotes" value="王麻子的工牌"></property>
51         <property name="coderId" value="3"></property>
52     </bean>
53     
54     <bean id="coderProject1" class="com.hyc.pojo.CoderProject">
55         <property name="id" value="1"></property>
56         <property name="projectName" value="管理系统"></property>
57         <property name="projectVersion" value="V1.0"></property>
58         <property name="projectDesc" value="管理配置"></property>
59     </bean>
60     <bean id="coderProject2" class="com.hyc.pojo.CoderProject">
61         <property name="id" value="2"></property>
62         <property name="projectName" value="存储系统"></property>
63         <property name="projectVersion" value="V1.0"></property>
64         <property name="projectDesc" value="存储配置"></property>
65     </bean>
66 </beans>

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

四、成员变量是Properties的装配

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

 1 public class Coder {
 2 
 3     private Properties prop;
 4 
 5 
 6     public Properties getProp() {
 7         return prop;
 8     }
 9 
10     public void setProp(Properties prop) {
11         this.prop = prop;
12     }
13 ｝

第二步：XML中装配

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4     xsi:schemaLocation="http://www.springframework.org/schema/beans
 5         http://www.springframework.org/schema/beans/spring-beans.xsd">
 6 
 7 
 8     <bean id="coder" class="com.hyc.pojo.Coder">
 9         
10         <!-- 装配Properties -->
11         <property name="prop">
12             <props>
13                 <prop key="bug-key-1">bug-prop-1</prop>
14                 <prop key="bug-key-2">bug-prop-2</prop>
15                 <prop key="bug-key-3">bug-prop-3</prop>
16             </props>
17         </property>
18 </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配置文件

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

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

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

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

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

查看全文

相关阅读:
143、Java内部类之访问方法中定义的参数或变量
 142、Java内部类之在普通方法里面定义内部类
 141、Java内部类之实例化外部类对象
 140、Java内部类之实例化内部类对象
 139、Java内部类之使用this访问外部类属性
 138、Java内部类之访问内部类的私有属性
 137、Java内部类之把内部类放到外部
 136、Java的内部类
 135、Java中的静态块，构造方法和构造块
 134、Java中的构造方法和构造块

原文地址：https://www.cnblogs.com/hellowhy/p/9711670.html