HL🌱数字花园

第4章Spring的IoC容器之BeanFactory二

2024年9月22日24分钟阅读

BeanFactory的XML之旅

beans 和 bean

所有注册到容器的业务对象，在Spring中称之为Bean。所以，每一个对象在XML中的映射也自然而然地对应一个叫做<bean>的元素。既然容器最终可以管理所有的业务对象，那么在XML中把这些叫做<bean>的元素组织起来的，就叫做<beans>。

1. beans

<beans>是XML配置文件中最顶层的元素，它下面可以包含0或者1个<description>和多个<bean>以及<import>或者<alias>，如图4-4所示。

image-20220403143725195

<beans>作为所有<bean>的“统帅”，它拥有相应的属性(attribute)对所辖的<bean>进行统一的默认行为设置，包括如下几个。

  • default-lazy-init 。其值可以指定为true或者false，默认值为false。用来标志是否对所有的<bean>进行延迟初始化。
  • default-autowire 。可以取值为no、byName、byType、constructor以及autodetect。默认值为no，如果使用自动绑定的话，用来标志全体bean使用哪一种默认绑定方式。
  • default-dependency-check 。可以取值none、objects、simplze以及all，默认值为none，即不做依赖检查。
  • default-init-method 。如果所管辖的<bean>按照某种规则，都有同样名称的初始化方法的话，可以在这里统一指定这个初始化方法名，而不用在每一个<bean>上都重复单独指定。
  • default-destroy-method 。与default-init-method相对应，如果所管辖的bean有按照某种规则使用了相同名称的对象销毁方法，可以通过这个属性统一指定。

当然，如果你不清楚上面这些默认的属性具体有什么用，那也不必着急。在看完对<bean>的讲解之后，再回头来看，就会明了多了。给出这些信息，是想让你知道，如果在某个场景下需要对大部分<bean>都重复设置某些行为的话，可以回头看一下，利用<beans>是否可以减少这种不必要的工作。

2. <description>、<import>和<alias>

之所以把这几个元素放到一起讲解，是因为通常情况下它们不是必需的。

  • <description>

可以通过<description>在配置的文件中指定一些描述性的信息。

  • <import>

可以通过<import>元素对其所依赖的配置文件进行引用。

  • <alias>

可以通过<alias>为某些<bean>起一些“外号”(别名)，通常情况下是为了减少输入。

<bean> 的介绍

每个业务对象作为个体，在Spring的XML配置文件中是与<bean>元素一一对应的。如下代码演示了最基础的对象配置形式：

    <bean id="djNewsListener" class="..impl.DowJonesNewsListener">
    </bean>

id属性

通常，每个注册到容器的对象都需要一个 唯一标志来将其与其他bean区分。通过id属性来指定当前注册对象的beanName是什么。这里，通过id指定beanName为djNewsListener。实际上，并非任何情况下都需要指定每个<bean>的id，有些情况下，id可以省略，比如后面会提到的内部<bean>以及不需要根据beanName明确依赖关系的场合等。

除了可以使用id来指定<bean>在容器中的标志，还可以使用name属性来指定<bean>的别名(alias)。比如，以上定义，我们还可以像如下代码这样，为其添加别名:

 
    <bean id="djNewsListener"
      name="/news/djNewsListener,dowJonesNewsListener"
    	class="..impl.DowJonesNewsListener">
    </bean>

与id属性相比，name属性的灵活之处在于，name可以使用id不能使用的一些字符，比如/。而且还可以通过逗号、空格或者冒号分割指定多个name。name的作用跟使用<alias>为id指定多个别名基本相同:

    <alias name="djNewsListener" alias="/news/djNewsListener"/>
    <alias name="djNewsListener" alias="dowJonesNewsListener"/>

class属性

每个注册到容器的对象都需要通过<bean>元素的class属性指定其类型，在大部分情况下，该属性是必须的。仅在少数情况下不需要指定，如后面将提到的在使用抽象配置模板的情况下。

bean的互相依赖

各个业务对象之间会相互协作来更好地完成同一使命。这时，各个业务对象之间的相互依赖就是无法避免的。 对象之间需要相互协作，在横向上它们存在一定的依赖性。而现在我们就是要看一下，在Spring的IoC容器的XML配置中，应该如何表达这种依赖性。

既然业务对象现在都符合IoC的规则，那么要了解的表达方式其实也很简单，无非就是看一下构造方法注入和setter方法注入通过XML是如何表达的而已。那么，让我们开始吧!

1. 构造方法注入的XML之道

按照Spring的IoC容器配置格式，要通过构造方法注入方式，为当前业务对象注入其所依赖的对象， 需要使用<constructor-arg>。正常情况下，如以下代码所示:

 
    <bean id="djNewsProvider" class="..FXNewsProvider">
      <constructor-arg>
    		<ref bean="djNewsListener"/>
      </constructor-arg>
    	<constructor-arg>
    		<ref bean="djNewsPersister"/>
      </constructor-arg>
    </bean>

对于<ref>元素，稍后会进行详细说明。这里你只需要知道，通过这个元素来指明容器将为djNewsProvider这个<bean>注入通过<ref>所引用的Bean实例。这种方式可能看起来或者编写起来不是很简洁，最新版本的Spring也支持配置简写形式，如以下代码所示:

 
    <bean id="djNewsProvider" class="..FXNewsProvider">
      <constructor-arg ref="djNewsListener"/>
      <constructor-arg ref="djNewsPersister"/>
    </bean>

有些时候，容器在加载XML配置的时候，因为某些原因，无法明确配置项与对象的构造方法参数列表的一一对应关系，就需要请<constructor-arg>的type或者index属性出马。比如，对象存在多个构造方法，当参数列表数目相同而类型不同的时候，容器无法区分应该使用哪个构造方法来实例化对象，或者构造方法可能同时传入最少两个类型相同的对象。

type属性

假设有一个对象定义如下方代码所示。

    /**
     * 随意声明的一个业务对象定义
     */
    public class MockBusinessObject {
        private String dependency1;
        private int dependency2;
 
        public MockBusinessObject(String dependency) {
            this.dependency1 = dependency;
        }
 
        public MockBusinessObject(int dependency) {
            this.dependency2 = dependency;
        }
        ...
 
        @Override
        public String toString() {
            return new ToStringBuilder(this).append("dependency1", dependency1).append("dependency2", dependency2).toString();
        }
    }

该类声明了两个构造方法，分别都只是传入一个参数，且参数类型不同。这时，我们可以进行配置，如以下代码所示:

 
    <bean id="mockBO" class="..MockBusinessObject">
    	<constructor-arg>
    		<value>111111</value>
    	</constructor-arg>
    </bean>

如果从BeanFactory取得该对象并调用toString()查看的话，我们会发现Spring调用的是第一个构造方法，因为输出是如下内容:

    ..MockBusinessObject@f73c1[dependency1=111111,dependency2=0]

但是，如果我们想调用的却是第二个传入int类型参数的构造方法，又该如何呢?可以使用type属性，通过指定构造方法的参数类型来解决这一问题，配置内容如下代码所示:

 
    <bean id="mockBO" class="..MockBusinessObject">
    	<constructor-arg type="int">
    		<value>111111</value>
    	</constructor-arg>
    </bean>

现在，我们得到了自己想要的对象实例，如下的控制台输出信息印证了这一点:

 ..MockBusinessObject@f73c1[dependency1=<null>,dependency2=111111]

index属性

当某个业务对象的构造方法同时传入了多个类型相同的参数时，Spring又该如何将这些配置中的信息与实际对象的参数一一对应呢?好在，如果配置项信息和对象参数可以按照顺序初步对应的话，Spring还是可以正常工作的，如下方代码所示。

    public class MockBusinessObject {
        private String dependency1;
        private String dependency2;
 
        public MockBusinessObject(String dependency1, String {
            this.dependency1 = dependency1;
            this.dependency2 = dependency2;
        }
        ...
 
        @Override
        public String toString() {
            return new ToStringBuilder(this).append("dependency1", dependency1).append("dependency2", dependency2).toString();
        }
    }

并且，配置内容如以下代码所示:

    <bean id="mockBO" class="..MockBusinessObject">
      <constructor-arg value="11111"/>
      <constructor-arg value="22222"/>
    </bean>

那么，我们可以得到如下对象:

    ..MockBusinessObject@1ef8cf3[dependency1=11111,dependency2=22222]

但是，如果要让“11111”作为对象的第二个参数，而将“22222”作为第一个参数来构造对象，又该如何呢？好！可以颠倒配置项，如以下代码所示:

    <bean id="mockBO" class="..MockBusinessObject">
      <constructor-arg value="22222"/>
      <constructor-arg value="11111"/>
    </bean>

不过，还有一种方式，那就是像如下代码所示的那样，使用index属性:

 
    <bean id="mockBO" class="..MockBusinessObject">
      <constructor-arg index="1" value="11111"/>
      <constructor-arg index="0" value="22222"/>
    </bean>

index属性的取值从0开始，与一般的数组下标取值相同。所以，指定的第一个参数的index应该是0，第二个参数的index应该是1，依此类推。

2. setter方法注入的XML之道

与构造方法注入可以使用<constructor-arg>注入配置相对应，Spring为setter方法注入提供了<property>元素。

<property>有一个name属性(attribute)，用来指定该<property>将会注入的对象所对应的实例变量名称。之后通过value或者ref属性或者内嵌的其他元素来指定具体的依赖对象引用或者值，如以下代码所示:

 
    <bean id="djNewsProvider" class="..FXNewsProvider">
    	<property name="newsListener">
    		<ref bean="djNewsListener"/>
    	</property>
    	<property name="newPersistener">
    		<ref bean="djNewsPersister"/>
    	</property>
    </bean>

当然，如果只是使用<property>进行依赖注入的话，请确保你的对象提供了默认的构造方法，也就是一个参数都没有的那个。

以上配置形式还可以简化为如下形式:

 
    <bean id="djNewsProvider" class="..FXNewsProvider">
    	<property name="newsListener" ref="djNewsListener"/>
      <property name="newPersistener" ref="djNewsPersister"/>
    </bean>

使用<property>的setter方法注入和使用<constructor-arg>的构造方法注入并不是水火不容的。实际上，如果需要，可以同时使用这两个元素:

 
    <bean id="mockBO" class="..MockBusinessObject">
      <constructor-arg value="11111"/>
    	<property name="dependency2" value="22222"/>
    </bean>

当然，现在需要MockBusinessObject提供一个只有一个String类型参数的构造方法，并且为dependency2提供了相应的setter方法。下方代码演示了符合条件的一个业务对象定义。

 
    public class MockBusinessObject {
        private String dependency1;
        private String dependency2;
 
        public MockBusinessObject(String dependency) {
            this.dependency1 = dependency;
        }
 
        public void setDependency2(String dependency2) {
            this.dependency2 = dependency2;
        }
        ...
    }

3. property和constructor-arg中可用的配置项

之前我们看到，可以通过在<property>和<constructor-arg>这两个元素内部嵌套<value>或者<ref>，来指定将为当前对象注入的简单数据类型或者某个对象的引用。不过，为了能够指定多种注入类型，Spring还提供了其他的元素供我们使用，这包括bean、ref、idref、value、null、list、set、map、props。下面我们来逐个详细讲述它们。

(1)<value>。可以通过value为主体对象注入简单的数据类型，不但可以指定String类型的数据，而且可以指定其他Java语言中的原始类型以及它们的包装器(wrapper)类型，比如int、Integer等。 容器在注入的时候，会做适当的转换工作(我们会在后面揭示转换的奥秘)。你之前已经见过如何使用<value>了，不过让我们通过如下代码来重新认识一下它:

    <constructor-arg>
      <value>111111</value>
    </constructor-arg>
    <property name="attributeName">
    	<value>222222</value>
    </property>

需要说明的是，<value>是最“底层”的元素，它内部不能再嵌套使用其他元素了。

(2)<ref>。 使用ref来引用容器中其他的对象实例，可以通过ref的local、parent和bean属性来指定引用的对象的beanName是什么。下方代码演示了ref及其三个对应属性的使用情况。

 
    <constructor-arg>
    	<ref local="djNewsPersister"/>
    </constructor-arg>
    或者
    <constructor-arg>
    	<ref parent="djNewsPersister"/>
    </constructor-arg>
    或者
    <constructor-arg>
    	<ref bean="djNewsPersister"/>
    </constructor-arg>

local、parent和bean的区别在于:

  • local只能指定与当前配置的对象在 同一个配置文件的对象定义的名称 (可以获得XML解析器的id约束验证支持);

  • parent则只能指定位于当前容器的 父容器中定义的对象引用 ;

  • bean则基本上通吃，所以，通常情况下，直接使用bean来指定对象引用就可以了。

BeanFactory可以分层次(通过实现HierarchicalBeanFactory接口)，容器A在初始化的时候，可以首先加载容器B中的所有对象定义，然后再加载自身的对象定义，这样，容器B就成为了容器A的父容器，容器A可以引用容器B中的所有对象定义:

  BeanFactory parentContainer = new XmlBeanFactory(new ClassPathResource(“父容器配置文件路径”));
  BeanFactory childContainer = new XmlBeanFactory(new ClassPathResource(“子容器配置文件路径”),parentContainer);

childContainer中定义的对象，如果通过parent指定依赖，则只能引用parentContainer中的对象定义。

<ref>的定义为<!ELEMENT ref EMPTY>，也就是说，它下面没有其他子元素可用了。

(3)<idref>。如果要为当前对象注入所依赖的对象的名称，而不是引用，那么通常情况下，可以使用来达到这个目的，使用如下形式:

    <property name="newsListenerBeanName">
      <value>djNewsListener</value>
    </property>

但这种场合下，使用idref才是最为合适的。因为使用idref，容器在解析配置的时候就可以帮你检查这个beanName到底是否存在，而不用等到运行时才发现这个beanName对应的对象实例不存在。以下代码演示了idref的使用:

    <property name="newsListenerBeanName">
      <idref bean="djNewsListener"/>
    </property>

(4)内部<bean>。使用<ref>可以引用容器中独立定义的对象定义。但有时，可能我们所依赖的对象只有当前一个对象引用，或者某个对象定义我们不想其他对象通过<ref>引用到它。这时，我们可以使用内嵌的<bean>，将这个私有的对象定义仅局限在当前对象 。对于FX新闻系统的DowJonesNews-Listener而言，实际上只有道琼斯的FXNewsProvider会使用它。而且，我们也不想让其他对象引用到它。为此完全可以像下方代码这样，将它配置为内部<bean>的形式。

 
    <bean id="djNewsProvider" class="..FXNewsProvider">
      <constructor-arg index="0">
    		<bean class="..impl.DowJonesNewsListener">
    		</bean>
    	</constructor-arg>
      <constructor-arg index="1">
    		<ref bean="djNewsPersister"/>
      </constructor-arg>
    </bean>

这样，该对象实例就只有当前的djNewsProvider可以使用，其他对象无法取得该对象的引用。

(5)<list>。<list>对应注入对象类型为java.util.List及其子类或者数组类型的依赖对象。通过<list>可以有序地为当前对象注入以collection形式声明的依赖。下方代码给出了一个使用<list>的实例演示。

 
    // 使用<list>进行依赖注入的对象定义
    public class MockDemoObject {
    	private List param1;
      private String[] param2;
      ...
    	// 相应的setter和getter方法 ...
    }

配置类似于

 
    <property name="param1">
        <list>
            <value> something</value>
            <ref bean="someBeanName" />
            <bean class="..." />
        </list>
    </property>
    <property name="param2">
        <list>
            <value>stringValue1</value>
            <value>stringValue2</value>
        </list>
    </property>

(6)<set>。如果说<list>可以帮你有序地注入一系列依赖的话，那么<set>就是无序的，而且，对于set来说，元素的顺序本来就是无关紧要的。<set>对应注入Java Collection中类型为java.util.Set或者其子类的依赖对象。下方代码演示了通常情况下<set>的使用场景。

    // 使用<set>进行依赖注入的对象定义
    public class MockDemoObject {
    	private Set valueSet;
        // 必要的setter和getter方法
        ...
    }

配置类似于

 
    <property name="valueSet">
        <set>
            <value> something</value>
            <ref bean="someBeanName" />
            <bean class="..." />
            <list>
    		 	...
        	</list>
        </set>
    </property>

例子就是例子，只是为了给你演示这个元素到底有多少能耐。从配置上来说，这样多层嵌套、多元素混杂配置是完全没有问题的。不过，各位在具体编程实践的时候可要小心了。如果你真的想这么夹杂配置的话，不好意思，估计ClassCastException会很愿意来亲近你，而这跟容器或者配置一点儿关系也没有。

(7)<map>。与列表(list)使用数字下标来标识元素不同，映射(map)可以通过指定的键(key) 来获取相应的值。如果说在<list>中混杂不同元素不是一个好的实践(方式)的话，你就应该求助<map>。<map>与<list>和<set>的相同点在于，都是为主体对象注入Collection类型的依赖，不同点在于它对应注入java.util.Map或者其子类类型的依赖对象。下方代码演示了<map>的通常使用场景。

 
    // 使用<map>进行依赖注入的对象定义
    public class MockDemoObject {
    	private Map mapping;
        // 必要的setter和getter方法
        ...
    }

配置类似于

 
    <property name="mapping">
        <map>
            <entry key="strValueKey">
                <value>something</value>
            </entry>
            <entry>
                <key>objectKey</key>
                <ref bean="someObject" />
            </entry>
            <entry key-ref="lstKey">
                <list>
    				...
    			</list>
            </entry>
            ...
        </map>
    </property>

对于<map>来说，它可以内嵌任意多个<entry>，每一个<entry>都需要为其指定一个键和一个值， 就跟真正的java.util.Map所要求的一样。

  • 指定entry的键。可以使用<entry>的属性——key或者key-ref来指定键，也可以使用<entry>的内嵌元素<key>来指定键，这完全看个人喜好，但两种方式可以达到相同的效果。在<key>内部，可以使用以上提到的任何元素来指定键，从简单的<value>到复杂的Collection，只要映射需要，你可以任意发挥。
  • 指定entry对应的值。<entry>内部可以使用的元素，除了<key>是用来指定键的，其他元素可以任意使用，来指定entry对应的值。除了之前提到的那些元素，还包括马上就要谈到<props>。如果对应的值只是简单的原始类型或者单一的对象引用，也可以直接使用<entry>的value或者value-ref这两个属性来指定，从而省却多敲入几个字符的工作量。

key属性用于指定通常的简单类型的键，而key-ref则用于指定对象的引用作为键。

所以，如果你不想敲那么些字符，可以像下方代码所展示的那样使用<map>进行依赖注入的配置。

 
    public class MockDemoObject {
      private Map mapping;
      // 必要的setter和getter方法
      ...
    }

配置类似于

 
    <property name="valueSet">
        <map>
            <entry key="strValueKey" value="something" />
            <entry key-ref="" value-ref="someObject" />
            <entry key-ref="lstKey">
                <list>
                  ...
    			</list>
            </entry>
            ...
        </map>
    </property>

(8)<props>。<props>是简化后了的<map>，或者说是特殊化的map，该元素对应配置类型为java.util.Properties的对象依赖。因为Properties只能指定String类型的键(key)和值，所以，<props>的配置简化很多，只有固定的格式，见下方代码。

 
    public class MockDemoObject {
    	private Properties emailAddrs;
        // 必要的setter和getter方法
    	...
    }

配置类似于

 
    <property name="valueSet">
      <props>
    		<prop key="author">[email protected]</prop>
        	<prop key="support">[email protected]</prop>
        	...
    	</props>
    </property>

每个<props>可以嵌套多个<prop>，每个<prop>通过其key属性来指定键，在<prop>内部直接指 定其所对应的值。<prop>内部没有任何元素可以使用，只能指定字符串，这个是由java.util. Properties的语意决定的。

(9)<null/>。最后一个提到的元素是<null/>，这是最简单的一个元素，因为它只是一个空元素， 而且通常使用到它的场景也不是很多。对于String类型来说，如果通过value以这样的方式指定注入， 即<value></value>，那么，得到的结果是""，而不是null。所以，如果需要为这个string对应的值 注入null的话，请使用<null/>。当然，这并非仅限于String类型，如果某个对象也有类似需求，请不要犹豫。

关系图谱

反向链接