Spring学习（五）bean装配详解之 【XML方式配置】

本文借鉴：Spring学习（特此感谢！）

一、配置Bean的方式及选择

配置方式

  • 在 XML 文件中显式配置
  • 在 Java 的接口和类中实现配置
  • 隐式 Bean 的发现机制和自动装配原则

方式选择的原则

最优先：通过隐式 Bean 的发现机制和自动装配的原则。

基于约定优于配置的原则，这种方式应该是最优先的

  • 好处：减少程序开发者的决定权，简单又不失灵活。

其次：Java 接口和类中配置实现配置

在没有办法使用自动装配原则的情况下应该优先考虑此类方法

  • 好处：避免 XML 配置的泛滥，也更为容易。
  • 典型场景：一个父类有多个子类，比如学生类有两个子类，一个男学生类和女学生类，通过 IoC 容器初始化一个学生类，容器将无法知道使用哪个子类去初始化，这个时候可以使用 Java 的注解配置去指定。

最后：XML 方式配置

在上述方法都无法使用的情况下，那么也只能选择 XML 配置的方式。

好处：简单易懂（当然，特别是对于初学者）

典型场景：当使用第三方类的时候，有些类并不是我们开发的，我们无法修改里面的代码，这个时候就通过 XML 的方式配置使用了。

二、通过 XML 配置装配 Bean

1、XML配置前言

使用 XML 装配 Bean 需要定义对应的 XML，这里需要引入对应的 XML 模式（XSD）文件，这些文件会定义配置 Spring Bean 的一些元素，当我们在 IDEA 中创建 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">

</beans>

这就只是一个格式文件，引入了一个 beans 的定义，引入了 xsd 文件，它是一个根元素，这样它所定义的元素将可以定义对应的 Spring Bean。

2、装配简易值

先来一个最简单的装配：

<bean id="c" class="pojo.Category">
    <property name="name" value="测试" />
</bean>

简单解释一下：

　　•id 属性是 Spring 能找到当前 Bean 的一个依赖的编号，遵守 XML 语法的 ID 唯一性约束。必须以字母开头，可以使用字母、数字、连字符、下划线、句号、冒号，不能以  开头。不过 id 属性不是一个必需的属性，name 属性也可以定义 bean 元素的名称，能以逗号或空格隔开起多个别名，并且可以使用很多的特殊字符，比如在 Spring 和 Spring MVC 的整合中，就得使用 name 属性来定义 bean 的名称，并且使用 /开头。

PS： 从 Spring 3.1 开始，id 属性也可以是 String 类型了，也就是说 id 属性也可以使用 / 开头，而 bean 元素的 id 的唯一性由容器负责检查。

　　如果 id 和 name 属性都没有声明的话，那么 Spring 将会采用 “全限定名#{number}” 的格式生成编号。 例如这里，如果没有声明 “id="c"” 的话，那么 Spring 为其生成的编号就是是“pojo.Category#0”，当它第二次声明没有 id 属性的 Bean 时，编号就是 “pojo.Category#1”，以此类推。

　　•class 属性显然就是一个类的全限定名

　　•property 元素是定义类的属性，其中的 name 属性定义的是属性的名称，而 value 是它的值。

　　这样的定义很简单，但是有时候需要注入一些自定义的类，比如之前饮品店的例子，JuickMaker 需要用户提供原料信息才能完成 juice 的制作：

<!-- 配置 srouce 原料 -->
<bean name="source" class="pojo.Source">
    <property name="fruit" value="橙子"/>
    <property name="sugar" value="多糖"/>
    <property name="size" value="超大杯"/>
</bean>

<bean name="juickMaker" class="pojo.JuiceMaker">
    <!-- 注入上面配置的id为srouce的Srouce对象 -->
    <property name="source" ref="source"/>
</bean>

　　这里先定义了一个 name 为 source 的 Bean，然后再制造器中通过 ref 属性去引用对应的 Bean，而 source 正是之前定义的 Bean 的 name ，这样就可以相互引用了。

　　•ref 注入对象

3、装配集合

　　有些时候我们需要装配一些复杂的东西，比如 Set、Map、List、Array 和 Properties 等，为此我们在 Packge【pojo】下新建一个 ComplexAssembly 类：

package pojo;

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

public class ComplexAssembly {

    private Long id;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;
    private Set<String> set;
    private String[] array;

    /* setter and getter */
}

　　这个 Bean 没有任何的实际意义，只是为了介绍如何装配这些常用的集合类：

<bean id="complexAssembly" class="pojo.ComplexAssembly">
    <!-- 装配Long类型的id -->
    <property name="id" value="1"/>

    <!-- 装配List类型的list -->
    <property name="list">
        <list>
            <value>value-list-1</value>
            <value>value-list-2</value>
            <value>value-list-3</value>
        </list>
    </property>

    <!-- 装配Map类型的map -->
    <property name="map">
        <map>
            <entry key="key1" value="value-key-1"/>
            <entry key="key2" value="value-key-2"/>
            <entry key="key3" value="value-key-2"/>
        </map>
    </property>

    <!-- 装配Properties类型的properties -->
    <property name="properties">
        <props>
            <prop key="prop1">value-prop-1</prop>
            <prop key="prop2">value-prop-2</prop>
            <prop key="prop3">value-prop-3</prop>
        </props>
    </property>

    <!-- 装配Set类型的set -->
    <property name="set">
        <set>
            <value>value-set-1</value>
            <value>value-set-2</value>
            <value>value-set-3</value>
        </set>
    </property>

    <!-- 装配String[]类型的array -->
    <property name="array">
        <array>
            <value>value-array-1</value>
            <value>value-array-2</value>
            <value>value-array-3</value>
        </array>
    </property>
</bean>

总结：

  • List 属性为对应的 <list> 元素进行装配，然后通过多个 <value> 元素设值
  • Map 属性为对应的 <map> 元素进行装配，然后通过多个 <entry> 元素设值，只是 entry 包含一个键值对(key-value)的设置
  • Properties 属性为对应的 <properties> 元素进行装配，通过多个 <property> 元素设值，只是 properties 元素有一个必填属性 key ，然后可以设置值
  • Set 属性为对应的 <set> 元素进行装配，然后通过多个 <value> 元素设值
  • 对于数组而言，可以使用 <array> 设置值，然后通过多个 <value> 元素设值。

　　上面看到了对简单 String 类型的各个集合的装载，但是有些时候可能需要更为复杂的装载，比如一个 List 可以是一个系列类的对象，为此需要定义注入的相关信息，其实跟上面的配置没什么两样，只不过加入了 ref 这一个属性而已。

集合注入总结：

  • List 属性使用 <list> 元素定义注入，使用多个 <ref> 元素的 Bean 属性去引用之前定义好的 Bean
<property name="list">
    <list>
        <ref bean="bean1"/>
        <ref bean="bean2"/>
    </list>
</property>
  • Map 属性使用 <map> 元素定义注入，使用多个 <entry> 元素的 key-ref 属性去引用之前定义好的 Bean 作为键，而用 value-ref 属性引用之前定义好的 Bean 作为值
<property name="map">
    <map>
        <entry key-ref="keyBean" value-ref="valueBean"/>
    </map>
</property>
  • Set 属性使用 <set> 元素定义注入，使用多个 <ref> 元素的 bean 去引用之前定义好的 Bean
<property name="set">
    <set>
        <ref bean="bean"/>
    </set>
</property>

4、命名空间装配

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

c-命名空间

　　c-命名空间是在 Spring 3.0 中引入的，它是在 XML 中更为简洁地描述构造器参数的方式，要使用它的话，必须要在 XML 的顶部声明其模式：

PS：是通过构造器参数的方式

　　现在假设我们现在有这么一个类：

package pojo;

public class Student {

    int id;
    String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    // setter and getter
}

　　在 c-命名空间和模式声明之后，我们就可以使用它来声明构造器参数了：

<!-- 引入 c-命名空间之前 -->
<bean name="student1" class="pojo.Student">
    <constructor-arg name="id" value="1" />
    <constructor-arg name="name" value="学生1"/>
</bean>

<!-- 引入 c-命名空间之后 -->
<bean name="student2" class="pojo.Student"
      c:id="2" c:name="学生2"/>

　　c-命名空间属性名以 “c:” 开头，也就是命名空间的前缀。接下来就是要装配的构造器参数名，在此之后如果需要注入对象的话则要跟上 -ref（如c:card-ref="idCard1"，则对 card 这个构造器参数注入之前配置的名为 idCard1 的 bean）

　　很显然，使用 c-命名空间属性要比使用 <constructor-arg> 元素精简，并且会直接引用构造器之中参数的名称，这有利于我们使用的安全性。

　　我们有另外一种替代方式：

<bean name="student2" class="pojo.Student" c:_0="3" c:_1="学生3"/>

　　我们将参数的名称替换成了 “0” 和 “1” ，也就是参数的索引。因为在 XML 中不允许数字作为属性的第一个字符，因此必须要添加一个下划线来作为前缀。

p-命名空间

　　c-命名空间通过构造器注入的方式来配置 bean，p-命名空间则是用setter的注入方式来配置 bean ，同样的，我们需要引入声明：

　　然后我们就可以通过 p-命名空间来设置属性：

<!-- 引入p-命名空间之前 -->
<bean name="student1" class="pojo.Student">
    <property name="id" value="1" />
    <property name="name" value="学生1"/>
</bean>

<!-- 引入p-命名空间之后 -->
<bean name="student2" class="pojo.Student"
      p:id="2" p:name="学生2"/>

　　我们需要先删掉 Student 类中的构造函数，不然 XML 约束会提示我们配置 <constructor-arg> 元素。

　　同样的，如果属性需要注入其他 Bean 的话也可以在后面跟上 -ref：

<bean name="student2" class="pojo.Student" p:id="2" p:name="学生2" p:cdCard-ref="cdCard1"/>

util-命名空间

　　工具类的命名空间，可以简化集合类元素的配置，同样的我们需要引入其声明（无需担心怎么声明的问题，IDEA会有很友好的提示）：

　　我们来看看引入前后的变化：

<!-- 引入util-命名空间之前 -->
<property name="list">
    <list>
        <ref bean="bean1"/>
        <ref bean="bean2"/>
    </list>
</property>

<!-- 引入util-命名空间之后 -->
<util:list id="list">
    <ref bean="bean1"/>
    <ref bean="bean2"/>
</util:list>

　　下表提供了 util-命名空间提供的所有元素:

5、引入其他配置文件

在实际开发中，随着应用程序规模的增加，系统中 <bean> 元素配置的数量也会大大增加，导致 applicationContext.xml 配置文件变得非常臃肿难以维护。

解决方案

让 applicationContext.xml 文件包含其他配置文件即可 使用 <import> 元素引入其他配置文件

【1】在【src】文件下新建一个 bean.xml 文件，写好基础的约束，把 applicationContext.xml 文件中配置的 <bean> 元素复制进去

【2】在 applicationContext.xml 文件中写入

<import resource="bean.xml" />

【3】运行测试代码，仍然能正确获取到 bean

原文地址：https://www.cnblogs.com/riches/p/11520090.html

时间： 2024-11-10 13:15:41

Spring学习（五）bean装配详解之 【XML方式配置】的相关文章

spring中的bean装配详解

本文主要介绍了spring配置文件的配置:set方法,constructor构造函数注入各种类型的属性值,bean的继承,自动装配autowire以及通过spring提供的特殊bean进行了分散配置. 首先,配置文件beans.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"

Spring Bean装配详解（五）

装配 Bean 的概述 前面已经介绍了 Spring IoC 的理念和设计,这一篇文章将介绍的是如何将自己开发的 Bean 装配到 Spring IoC 容器中. 大部分场景下,我们都会使用 ApplicationContext 的具体实现类,因为对应的 Spring IoC 容器功能相对强大. 而在 Spring 中提供了 3 种方法进行配置: 在 XML 文件中显式配置 在 Java 的接口和类中实现配置 隐式 Bean 的发现机制和自动装配原则 方式选择的原则 在现实的工作中,这 3 种方

Spring学习（六）bean装配详解之 【通过注解装配 Bean】【基础配置方式】

通过注解装配 Bean 1.前言 优势 1.可以减少 XML 的配置,当配置项多的时候,XML配置过多会导致项目臃肿难以维护 2.功能更加强大,既能实现 XML 的功能,也提供了自动装配的功能,采用了自动装配后,程序猿所需要做的决断就少了,更加有利于对程序的开发,这就是“约定优于配置”的开发原则 IOC发现Bean的两种方式 组件扫描:通过定义资源的方式,让 Spring IoC 容器扫描对应的包,从而把 bean 装配进来. 自动装配:通过注解定义,使得一些依赖关系可以通过注解完成. 2.使用

（转）spring学习之@ModelAttribute运用详解

@ModelAttribute使用详解 1 @ModelAttribute注释方法 例子(1),(2),(3)类似,被@ModelAttribute注释的方法会在此controller每个方法执行前被执行,因此对于一个controller映射多个URL的用法来说,要谨慎使用. (1)@ModelAttribute注释void返回值的方法 @Controller public class HelloWorldController { @ModelAttribute public void popu

spring学习（九）--详解spring启动配置（经典文章）

摘自:https://www.jianshu.com/p/280c7e720d0c spring的启动是建筑在servlet容器之上的,所有web工程的初始位置就是web.xml,它配置了servlet的上下文(context)和监听器(Listener),下面就来看看web.xml里面的配置: <!--上下文监听器,用于监听servlet的启动过程--> <listener> <description>ServletContextListener</descri

spring学习之@ModelAttribute运用详解

情景1 @ModelAttribute注释一个方法的参数 (1)从model中获取 1 @Controller 2 public class HelloWorldController { 3 4 @ModelAttribute("user") 5 public User addAccount() { 6 return new User("jz","123"); 7 } 8 9 @RequestMapping(value = "/hell

跟着刚哥学习Spring框架--通过XML方式配置Bean（三）

Spring配置Bean有两种形式(XML和注解) 今天我们学习通过XML方式配置Bean 1. Bean的配置方式 通过全类名(反射)的方式   √ id:标识容器中的bean.id唯一. √ class:bean的全类名,通过反射的方式在IOC容器中创建Bean,所以要求Bean中必须有无参的构造器 2.依赖注入的方式 1)属性注入:通过setter方法注入Bean的属性值或依赖的对象 属性注入使用<Property>元素,使用name指定Bean的属性名称,使用value指定Bean的属

J2EE学习篇之--JDBC详解

今天我们来说一下关于JDBC的相关知识,关于JDBC我想大家都不陌生了,而且我记得早就开始使用它了,记得那是大二的时候做课程设计,但是那时候是为了完成任务,所以遇到问题就google,那时候也没有时间去整理,所以这次就来详细说一下关于JDBC的知识 摘要: JDBC(Java Data Base Connectivity,java数据库连接),由一些接口和类构成的API. J2SE的一部分,由java.sql,javax.sql包组成. 应用程序.JDBC API.数据库驱动及数据库之间的关系

Spring中的jar包详解

下面给大家说说spring众多jar包的特点吧,无论对于初学spring的新手,还是spring高手,这篇文章都会给大家带来知识上的收获,如果你已经十分熟悉本文内容就当做一次温故知新吧.spring.jar 是包含有完整发布的单个jar包,spring.jar中除了spring-mock.jar里所包含的内容外其他所有jar包的内容,因为只有在研发环境下才会用到spring-mock.jar来进行辅助测试,正式应用系统中是用不得这些类的. 除了spring.jar文件,Spring还包括有其他1