Spring(二)之配置

  • 依赖配置详解
    • 直接变量基本类型Strings类型等
      • idref元素
      • 引用其它的bean协作者
      • 内部bean
      • 集合重点
        • 注入值基本集合
        • 集合的合并
    • XML配置文件的简写及其他
      • 基于XML配置元数据
      • 使用p名称空间配置属性
      • depends-on

依赖配置详解

   bean的属性及构造器参数既可以引用容器中的其他bean,也可以是内联(inline)bean。在spring的XML配置中使用和元素定义。

直接变量(基本类型、Strings类型等。)

  <value/>元素通过人可以理解的字符串来指定属性或构造器参数的值。正如前面所提到的,JavaBean PropertyEditor将用于把字符串从java.lang.String类型转化为实际的属性或参数类型。

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

  <property name="driverClassName">
    <value>com.mysql.jdbc.Driver</value>
  </property>
  <property name="url">
    <value>jdbc:mysql://localhost:3306/mydb</value>
  </property>
  <property name="username">
    <value>root</value>
  </property>
  <property name="password">
    <value>masterkaoli</value>
  </property>
</bean>

  <property/> 和<constructor-arg/> 元素中也可以使用’value’ 属性,这样会使我们的配置更简洁,比如下面的配置

<bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

  <!-- results in a setDriverClassName(String) call -->
  <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
  <property name="username" value="root"/>
  <property name="password" value="masterkaoli"/>
</bean>

   Spring团队更倾向采用属性方式(使用元素)来定义value值。当然我们也可以按照下面这种方式配置一个java.util.Properties实例

<bean id="mappings" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

   <!-- typed as a java.util.Properties -->
   <property name="properties">
      <value>
         jdbc.driver.className=com.mysql.jdbc.Driver
         jdbc.url=jdbc:mysql://localhost:3306/mydb
      </value>
   </property>
</bean>

  如果采用上面的配置,Spring容器将使用JavaBean PropertyEditor把元素中的文本转换为一个java.util.Properties实例

idref元素

  idref元素用来将容器内其它bean的id传给 或 元素,同时提供错误验证功能。(如果使用元素指定拦截器名字,可以避免因一时疏忽导致的拦截器ID拼写错误。)

<bean id="theTargetBean" class="..."/>

<bean id="theClientBean" class="...">
    <property name="targetName">
        <idref bean="theTargetBean" />
    </property>
</bean>

  上述bean定义片段完全地等同于(在运行时)以下的片段:

<bean id="theTargetBean" class="..." />

<bean id="client" class="...">
    <property name="targetName" value="theTargetBean" />
</bean>

  第一种形式比第二种更可取的主要原因是,使用idref标记允许容器在部署时 验证所被引用的bean是否存在。而第二种方式中,传给client bean的targetName属性值并没有被验证。任何的输入错误仅在client bean实际实例化时才会被发现(可能伴随着致命的错误)。如果client bean 是prototype类型的bean,则此输入错误(及由此导致的异常)可能在容器部署很久以后才会被发现。

  此外,如果被引用的bean在同一XML文件内,且bean名字就是bean id,那么可以使用local属性,此属性允许XML解析器在解析XML文件时对引用的bean进行验证

<property name="targetName">
   <idref local="theTargetBean"/>
</property>

引用其它的bean(协作者)

  在元素内部还可以使用ref元素。该元素用来将bean中指定属性的值设置为对容器中的另外一个bean的引用。如前所述,该引用bean将被作为依赖注入,而且在注入之前会被初始化(如果是singleton bean则已被容器初始化)。尽管都是对另外一个对象的引用,但是通过id/name指向另外一个对象却有三种不同的形式,不同的形式将决定如何处理作用域及验证。

  第一种形式也是最常见的形式是通过使用标记指定bean属性的目标bean,通过该标签可以引用同一容器或父容器内的任何bean(无论是否在同一XML文件中)。XML ‘bean’元素的值既可以是指定bean的id值也可以是其name值

  <ref bean=”someBean”/>
  第二种形式是使用ref的local属性指定目标bean,它可以利用XML解析器来验证所引用的bean是否存在同一文件中。local属性值必须是目标bean的id属性值。如果在同一配置文件中没有找到引用的bean,XML解析器将抛出一个例外。如果目标bean是在同一文件内,使用local方式就是最好的选择(为了尽早地发现错误)。

  <ref local=”someBean”/>
  第三种方式是通过使用ref的parent属性来引用当前容器的父容器中的bean。parent属性值既可以是目标bean的id值,也可以是name属性值。而且目标bean必须在当前容器的父容器中。使用parent属性的主要用途是为了用某个与父容器中的bean同名的代理来包装父容器中的一个bean(例如,子上下文中的一个bean定义覆盖了他的父bean)。

<!-- in the parent context -->

    <bean id="accountService" class="com.foo.SimpleAccountService">
    </bean>
<!-- in the child (descendant) context -->

<bean id="accountService" class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="target">
          <ref parent="accountService"/>
      </property>
</bean>

内部bean

  所谓的内部bean(inner bean)是指在一个bean的或 元素中使用元素定义的bean。内部bean定义不需要有id或name属性,即使指定id 或 name属性值也将会被容器忽略。

    <bean id="outer" class="...">
        <property name="target">
            <bean class="com.example.Person">
                 <property name="name" value="Fiona Apple"/>
                <property name="age" value="25"/>
         </bean>
        </property>
    </bean>

  注意:内部bean中的scope标记及id或name属性将被忽略。内部bean总是匿名的且它们总是prototype模式的。同时将内部bean注入到包含该内部bean之外的bean是不可能的。

集合(重点)

  通过<list/>、<set/>、<map/><props/>元素可以定义和设置与Java Collection类型对应List、Set、MapProperties的值。

<bean id="moreComplexObject" class="example.ComplexObject">
  <!-- results in a setAdminEmails(java.util.Properties) call -->
  <property name="adminEmails">
    <props>
        <prop key="administrator">administrator@example.org</prop>
        <prop key="support">support@example.org</prop>
        <prop key="development">development@example.org</prop>
    </props>
  </property>

  <!-- results in a setSomeList(java.util.List) call -->
  <property name="someList">
    <list>
        <value>a list element followed by a reference</value>
        <ref bean="myDataSource" />
    </list>
  </property>

  <!-- results in a setSomeMap(java.util.Map) call -->
  <property name="someMap">
    <map>
        <entry>
            <key>
                <value>an entry</value>
            </key>
            <value>just some string</value>
        </entry>
        <entry>
            <key>
                <value>a ref</value>
            </key>
            <ref bean="myDataSource" />
        </entry>
    </map>
  </property>

  <!-- results in a setSomeSet(java.util.Set) call -->
  <property name="someSet">
    <set>
        <value>just some string</value>
        <ref bean="myDataSource" />
    </set>
  </property>
</bean>

map的key或value值,或set的value值还可以是以下元素:

bean | ref | idref | list | set | map | props | value | null

注入值(基本、集合)

  注入基本类型的值、注入集合类型的值

    <bean id="eb" class="basic.ExampleBean">
        <property name="name" value="C罗"/>
        <property name="age" value="22"/>
        <property name="cities">
            <list>
                <value>北京</value>
                <value>岳阳</value>
                <value>长沙</value>
                <!-- 允许重复元素 -->
                <value>长沙</value>
            </list>
        </property>
        <property name="interest">
            <set>
                <value>钓鱼</value>
                <value>做饭</value>
                <value>编程</value>
                <!-- 不允许重复元素 -->
                <value>编程</value>
            </set>
        </property>
        <property name="score">
            <map>
                <entry key="english" value="59.5"/>
                <entry key="math" value="69.5"/>
            </map>
        </property>
        <property name="db">
            <props>
                <prop key="username">Tom</prop>
                <prop key="password">1234</prop>
            </props>
        </property>
    </bean>

  将集合类型的值当做一个bean来配置。命名空间(namespace):为了区分同名元素而在

     <util:list id="citiesBean">
        <value>北京</value>
        <value>武汉</value>
        <value>济南</value>
     </util:list>
     <util:set id="interestBean">
        <value>台球</value>
        <value>钓鱼</value>
        <value>做饭</value>
     </util:set>
     <util:map id="scoreBean">
        <entry key="english" value="80"/>
        <entry key="math" value="90"/>
     </util:map>
     <util:properties id="dbBean">
        <prop key="username">Tom</prop>
        <prop key="password">1234</prop>
     </util:properties>
     <bean id="eb2" class="basic.ExampleBean">
        <property name="cities" ref="citiesBean"/>
        <property name="interest" ref="interestBean"/>
        <property name="score" ref="scoreBean"/>
        <property name="db" ref="dbBean"/>
     </bean>

     <!--
        读取location指定位置的文件的内容。
        classpath:是spring框架内部的约定。
      -->
     <util:properties id="config"
     location="classpath:config.properties"/>

集合的合并

  Spring IoC容器支持集合的合并。这样我们可以定义parent-stylechild-style的、、或元素,子集合的值从其父集合继承和覆盖而来;也就是说,*父子集合元素合并*后的值就是子集合中的最终结果,而且子集合中的元素值将覆盖父集全中对应的值

  注意,关于合并的这部分利用了parent-child bean机制

<beans>
<bean id="parent" abstract="true" class="example.ComplexObject">
    <property name="adminEmails">
        <props>
            <prop key="administrator">administrator@example.com</prop>
            <prop key="support">support@example.com</prop>
        </props>
    </property>
</bean>
<bean id="child" parent="parent">
    <property name="adminEmails">
        <!-- the merge is specified on the *child* collection definition -->
        <props merge="true">
            <prop key="sales">sales@example.com</prop>
            <prop key="support">support@example.co.uk</prop>
        </props>
    </property>
</bean>
<beans>

在上面的例子中,childbean的adminEmails属性的元素上使用了merge=true属性。当child bean被容器实际解析及实例化时,其 adminEmails将与父集合的adminEmails属性进行合并。

administrator=administrator@example.com
sales=sales@example.com
support=support@example.co.uk

  子bean的Properties集合将从父继承所有属性元素。同时子bean的support值将覆盖父集合的相应值。不同的集合类型是不能合并(如map和 list是不能合并的),否则将会抛出相应的Exception。

XML配置文件的简写及其他

  配置元数据冗长不是什么好事情,因此我们将通过下面的方式来对配置进行“减肥”,第一种做法就是通过使用<property/>来定义值和对其他bean的引用,另一个做法就是采用不同的属性定义格式

基于XML配置元数据

  <property/>、<constructor-arg/>及<entry/>元素都支持value属性(attribute),它可以用来替代内嵌的<value/>元素。

<property name="myProperty">
  <value>hello</value>
</property>
<constructor-arg>
  <value>hello</value>
</constructor-arg>
<entry key="myKey">
  <value>hello</value>
</entry>

等同于:

<property name="myProperty" value="hello"/>
<constructor-arg value="hello"/>
<entry key="myKey" value="hello"/>

<property/>和<constructor-arg/>支持类似ref的简写属性,它可用来替代整个内嵌的<ref/>元素。因而,以下的代码:

<property name="myProperty">
  <ref bean="myBean">
</property>
<constructor-arg>
  <ref bean="myBean">
</constructor-arg>

等同于:

<property name="myProperty" ref="myBean"/>
<constructor-arg ref="myBean"/>

注意,尽管存在等同于<ref bean=”xxx”> 元素的简写形式,但并没有<ref local=”xxx”>的简写形式,为了对当前xml中bean的引用,你只能使用完整的形式。

最后,map中entry元素的简写形式为key/key-refvalue /value-ref属性,因而,以下的代码:

<entry>
  <key>
    <ref bean="myKeyBean" />
  </key>
  <ref bean="myValueBean" />
</entry>

等同于:

<entry key-ref="myKeyBean" value-ref="myValueBean"/>

使用p名称空间配置属性

  事实上,我们所看到的所有bean的配置格式都是基于一个 XML Schema文档。
  特定的名称空间并不需要定义在一个XSD文件中,它只在Spring内核中存在。我们所说的p名称空间就是这样,它不需要一个schema定义,与我们前面采用元素定义bean的属性不同的是,当我们采用了p名称空间,我们就可以**在bean元素中使用属性(attribute)来描述**bean的property值。

  下面的两段XML配置文件中都是用来定义同一个bean:一个采用的是标准的XML格式,一个是采用p名称空间。

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean name="classic" class="com.example.ExampleBean">
        <property name="email" value="foo@bar.com/>
    </bean>

    <bean name="p-namespace" class="com.example.ExampleBean"
          p:email="foo@bar.com"/>
</beans>

  从上面的bean定义中,我们采用p名称空间的方式包含了一个叫email的属性,而Spring会知道我们的bean包含了一个属性(property)定义。我们前面说了,p名称空间是不需要schema定义的,因此属性(attribute)的名字就是你bean的property的名字。

  下面的例子包含了两个bean定义,它们都引用了另一个bean

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean name="john-classic" class="com.example.Person">
        <property name="name" value="John Doe"/>
        <property name="spouse" ref="jane"/>
    </bean>

    <bean name="john-modern"
        class="com.example.Person"
        p:name="John Doe"
        p:spouse-ref="jane"/>

    <bean name="jane" class="com.example.Person">
        <property name="name" value="Jane Doe"/>
    </bean>
</beans>

  上面的例子不仅使用p名称空间包含了一个属性(property)值,而且使用了一个特殊的格式声明了一个属性引用。在第一个bean定义中使用了<property name=”spouse” ref=”jane”/>来建立beanjohn到beanjane的引用,而第二个bean定义则采用p:spouse-ref=”jane“属性(attribute)的方式达到了同样的目的。在这个例子中,”spouse”是属性(property)名,而”-ref“则用来说明该属性不是一个具体的值而是对另外一个bean的引用。

depends-on

  depends-on属性可以用于当前bean初始化之前显式地强制一个或多个bean被初始化。下面的例子中使用了depends-on属性来指定一个bean的依赖。

<bean id="beanOne" class="ExampleBean" depends-on="manager"/>

<bean id="manager" class="ManagerBean" />

  若需要表达对多个bean的依赖,可以在’depends-on’中将指定的多个bean名字用分隔符进行分隔,分隔符可以是逗号、空格及分号等。下面的例子中使用了’depends-on’来表达对多个bean的依赖。

<bean id="beanOne" class="ExampleBean" depends-on="manager,accountDao">
  <property name="manager" ref="manager" />
</bean>

<bean id="manager" class="ManagerBean" />
<bean id="accountDao" class="x.y.jdbc.JdbcAccountDao" />

  注意
  “depends-on”属性不仅用来指定初始化时的依赖,同时也用来指定相应的销毁时的依赖(该依赖只针对singletonbean)。depends-on属性中指定的依赖bean会在相关bean销毁之前被销毁,从而可以让用户控制销毁顺序。
## 延迟初始化bean ##
**  默认情况下,容器启动之后,会将所用作用域为
   singleton的bean创建好。
   可以设置lazy-init属性为true,表示延迟加载**
  ApplicationContext实现的默认行为就是在启动时将所有singleton bean提前进行实例化。提前实例化意味着作为初始化过程的一部分,ApplicationContext实例会创建并配置所有的singleton bean。通常情况下这是件好事,因为这样在配置中的任何错误就会即刻被发现(否则的话可能要花几个小时甚至几天)。

  有时候这种默认处理可能并不是你想要的。如果你不想让一个singleton bean在ApplicationContext初始化时被提前实例化,那么可以将bean设置为延迟实例化。一个延迟初始化bean将告诉IoC 容器是在启动时还是在第一次被用到时实例化。

  在XML配置文件中,延迟初始化将通过元素中的lazy-init属性来进行控制。例如:

<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/>

<bean name="not.lazy" class="com.foo.AnotherBean"/>

  当ApplicationContext实现加载上述配置时,设置为lazy的bean将不会在ApplicationContext启动时提前被实例化,而not.lazy却会被提前实例化。

  需要说明的是,如果一个bean被设置为延迟初始化,而另一个非延迟初始化的singleton bean**依赖于它**,那么当ApplicationContext提前实例化singleton bean时,它必须也确保所有上述singleton 依赖bean也被预先初始化,当然也包括设置为延迟实例化的bean。因此,如果Ioc容器在启动的时候创建了那些设置为延迟实例化的bean的实例,你也不要觉得奇怪,因为那些延迟初始化的bean可能在配置的某个地方被注入到了一个非延迟初始化singleton bean里面。

  在容器层次上通过在元素上使用’default-lazy-init’属性来控制延迟初始化也是可能的。如下面的配置:

<beans default-lazy-init="true">
    <!-- no beans will be pre-instantiated... -->
</beans>
时间: 2024-11-03 05:42:14

Spring(二)之配置的相关文章

xsd-初学者spring aop/tx配置出现问题不会

问题描述 初学者spring aop/tx配置出现问题不会 错误信息: Multiple annotations found at this line: - schema_reference.4: Failed to read schema document 'http://www.springframework.org/schema/context/spring-beans.xsd', because 1) could not find the document; 2) the documen

spring 配置文件在配置数据源时报错

问题描述 spring 配置文件在配置数据源时报错 我的配置 报错信息: SEVERE: Context initialization failed org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'upidaDB' defined in ServletContext resource [/WEB-INF/spring/spring-data.xml]: Error se

通向架构师的道路(第二十天)万能框架spring(二)maven结合spring与ibatis

一.前言 上次讲了Struts结合Spring并使用Spring的JdbcTemplate来搭建工程框架后我们面临着jar库无法管理,工程发布不方便,jar包在工程内太占空间,jar包冲突,管理,甚至漏包都问题.于是我们在讲"万能框架spring(二)"前,传授了一篇番外篇,即讲利用maven来管理我们的jar库. 从今天开始我们将结合"万能框架spring(一)"与番外篇maven来更进一步丰富我们的ssx框架,那么今天讲的是使用iBatis3结合SS来构建我们的

spring 注解-spring容器已经配置好数据连接池,类里面用jdbc方式是不是就不管用了

问题描述 spring容器已经配置好数据连接池,类里面用jdbc方式是不是就不管用了 求大肾解答,driud阿里巴巴的数据连接池bean配置在spring容器里面!我在JAVA类中@resource注入,datasource拿到连接!是null!数据库什么链接信息都是对的.求大神解答druid连接池,获取连接的详细代码,不要沉 解决方案 你有没有在JAVA类中写set方法 按理说不写也对啊 解决方案二: spring配置ibatis的jdbc方式和proxool连接池方式 解决方案三: 不要沉啊

spring mvc-springmvc spring hibernate 怎么配置连接两个数据库

问题描述 springmvc spring hibernate 怎么配置连接两个数据库 persistent.xml配置 <?xml version="1.0" encoding="UTF-8"?> <persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0"> <persistence-unit name=&q

关于spring自定义标签配置错误

问题描述 关于spring自定义标签配置错误 解决方案 解决方案二: 解决方案三: 解决方案四: 解决方案五: 希望大婶们帮帮忙,已经困扰我两天了.. 解决方案六: spring自定义标签 解决方案七: 解决方案八: spring.handler里配置了吗?

spring.net 泛型配置报错问题

问题描述 spring.net 泛型配置报错问题 我在一个类里定义了两个泛型对角如下: public class UserController : Controller { // // GET: /User/ BaseService<MDL.User_Test_T> user_test_t { set; get; } BaseService<MDL.Role_Info_T> role_info_t { set; get; } } xml 配置如下: <object type=

jbpm4.4 集成spring mvc 怎么配置?

问题描述 jbpm4.4 集成spring mvc 怎么配置? 如题 感谢回答~大神帮我看下如题 感谢回答~大神帮我看下如题 感谢回答~大神帮我看下 解决方案 https://github.com/search?utf8=%E2%9C%93&q=+jbpm+spring&type=Repositories&ref=searchresults 解决方案二: activiti集成spring的配置请参考 : http://git.oschina.net/wangkang/llsfw

spring bean prototype 配置不起作用

问题描述 spring bean prototype 配置不起作用 框架 struts2+spring,我有一个登录的vo,里面放用户的登录信息, 当第一个用户登录后,第二个用户再登录将第一个用户的信息冲掉,第一个登录的账号 刷新后成了第二个登陆者的信息. 使用的是spring的bean,配置如下: bean的配置 ## <bean id="userLoginInfo" class="com.user.vo.UserLoginInfo" scope="

手动装配Spring与Webwork配置的问题研究 高手进(修改spring-xwork-integration.jar方法实现)

问题描述 手动装配Spring与Webwork配置修改spring-xwork-integration.jar方法实现永久链接:http://panshunchang.javaeye.com/blog/675464我在网上看到一个spring结合webwork的实例,自己弄了一下,发现老出现一个奇怪的错误按照下面的配置,会出现一个一样的错误严重:Couldnotexecuteactionjava.lang.IllegalStateException:Theapplicationcontextha