`

spring配置文件详解

 
阅读更多
1.构造器注入
基于构造器的DI通过调用带参数的构造器来实现，每个参数代表着一个依赖。此外，还可通过给stattic工厂方法传参数来构造bean。
构造器参数解析根据参数类型进行匹配，如果bean的构造器参数类型定义非常明确，那么在bean被实例化的时候，bean定义中构造器参数的定义顺序就是这些参数的顺序，依次进行匹配，否则可以根据构造器参数类型匹配，如下：
view plaincopy to clipboardprint?<bean id="exampleBean" class="examples.ExampleBean"> 
  <constructor-arg type="int" value="7500000"/> 
  <constructor-arg type="java.lang.String" value="42"/> 
</bean> 
<bean id="exampleBean" class="examples.ExampleBean">
  <constructor-arg type="int" value="7500000"/>
  <constructor-arg type="java.lang.String" value="42"/>
</bean>


还可以通过index属性来显式指定构造参数的索引，比如下面的例子：
view plaincopy to clipboardprint?<bean id="exampleBean" class="examples.ExampleBean"> 
  <constructor-arg index="0" value="7500000"/> 
  <constructor-arg index="1" value="42"/> 
</bean> 
<bean id="exampleBean" class="examples.ExampleBean">
  <constructor-arg index="0" value="7500000"/>
  <constructor-arg index="1" value="42"/>
</bean>
2.Setter注入
通过调用无参构造器或无参static工厂方法实例化bean之后，调用该bean的setter方法，即可实现基于setter的DI。
首先是一个用XML格式定义的Setter DI例子:
view plaincopy to clipboardprint?<bean id="exampleBean" class="examples.ExampleBean"> 
  <!-- setter injection using the nested <ref/> element --> 
  <property name="beanOne"><ref bean="anotherExampleBean"/></property> 
  <!-- setter injection using the neater 'ref' attribute --> 
  <property name="beanTwo" ref="yetAnotherBean"/> 
  <property name="integerProperty" value="1"/> 
</bean> 
<bean id="exampleBean" class="examples.ExampleBean">
  <!-- setter injection using the nested <ref/> element -->
  <property name="beanOne"><ref bean="anotherExampleBean"/></property>
  <!-- setter injection using the neater 'ref' attribute -->
  <property name="beanTwo" ref="yetAnotherBean"/>
  <property name="integerProperty" value="1"/>
</bean>


在xml bean定义中指定的构造器参数将被用来作为传递给类ExampleBean构造器的参数。现在来研究一个替代构造器的方法，采用static工厂方法返回对象实例：
view plaincopy to clipboardprint?<bean id="exampleBean" class="examples.ExampleBean" 
      factory-method="createInstance"> 
  <constructor-arg ref="anotherExampleBean"/> 
  <constructor-arg ref="yetAnotherBean"/> 
  <constructor-arg value="1"/>  
</bean> 
<bean id="exampleBean" class="examples.ExampleBean"
      factory-method="createInstance">
  <constructor-arg ref="anotherExampleBean"/>
  <constructor-arg ref="yetAnotherBean"/>
  <constructor-arg value="1"/>
</bean>
<property/> 和<constructor-arg/> 元素中可以使用'value' 属性.
也可以按照下面这种方式配置一个java.util.Properties实例:
view plaincopy to clipboardprint?<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 
         jdbcjdbc.url=jdbc:mysql://localhost:3306/mydb 
      </value> 
   </property> 
</bean> 
<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>
idref元素用来将容器内其它bean的id传给<constructor-arg/> 或 <property/>元素，同时提供错误验证功能。
view plaincopy to clipboardprint?<bean id="theTargetBean" class="..."/> 
<bean id="theClientBean" class="..."> 
    <property name="targetName"> 
        <idref bean="theTargetBean" /> 
    </property> 
</bean> 
<bean id="theTargetBean" class="..."/>
<bean id="theClientBean" class="...">
    <property name="targetName">
        <idref bean="theTargetBean" />
    </property>
</bean>
如果被引用的bean在同一XML文件内，且bean名字就是bean id，那么可以使用local属性，此属性允许XML解析器在解析XML文件时对引用的bean进行验证。
引用其它的bean:
第一种形式也是最常见的形式是通过使用<ref/>标记指定bean属性的目标bean，通过该标签可以引用同一容器或父容器内的任何bean（无论是否在同一XML文件中）。XML 'bean'元素的值既可以是指定bean的id值也可以是其name值。
view plaincopy to clipboardprint?<ref bean="someBean"/> 
<ref bean="someBean"/>


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


第三种方式是通过使用ref的parent属性来引用当前容器的父容器中的bean。parent属性值既可以是目标bean的id值，也可以是name属性值。而且目标bean必须在当前容器的父容器中。使用parent属性的主要用途是为了用某个与父容器中的bean同名的代理来包装父容器中的一个bean(例如，子上下文中的一个bean定义覆盖了他的父bean)。
view plaincopy to clipboardprint?<!-- in the parent context --> 
<bean id="accountService" class="com.foo.SimpleAccountService"> 
    <!-- insert dependencies as required as here --> 
</bean> 
<!-- in the child (descendant) context --> 
<bean id="accountService"  <-- notice that the name of this bean is the same as the name of the 'parent' bean 
      class="org.springframework.aop.framework.ProxyFactoryBean"> 
      <property name="target"> 
          <ref parent="accountService"/>  <-- notice how we refer to the parent bean 
      </property> 
    <!-- insert other configuration and dependencies as required as here --> 
</bean> 
<!-- in the parent context -->
<bean id="accountService" class="com.foo.SimpleAccountService">
    <!-- insert dependencies as required as here -->
</bean>
<!-- in the child (descendant) context -->
<bean id="accountService"  <-- notice that the name of this bean is the same as the name of the 'parent' bean
      class="org.springframework.aop.framework.ProxyFactoryBean">
      <property name="target">
          <ref parent="accountService"/>  <-- notice how we refer to the parent bean
      </property>
    <!-- insert other configuration and dependencies as required as here -->
</bean>


内部bean:
所谓的内部bean（innerbean）是指在一个bean的<property/>或<constructor-arg/>元素中使用<bean/>元素定义的bean。内部bean定义不需要有id或name属性，
即使指定id 或 name属性值也将会被容器忽略。
集合:
通过<list/>、<set/>、<map/>及<props/>元素可以定义和设置与Java Collection类型对应List、Set、Map及Properties的值。
view plaincopy to clipboardprint?<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> 
<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>


集合的合并:
SpringIoC容器将支持集合的合并。这样我们可以定义parent-style和child-style的<list/>、<map/>、<set/>或<props/>元素，子集合的值从其父集合继承和覆盖
而来；也就是说，父子集合元素合并后的值就是子集合中的最终结果，而且子集合中的元素值将覆盖父集全中对应的值。
view plaincopy to clipboardprint?<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> 
<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>
Nulls:
<null/>用于处理null值。Spring会把属性的空参数当作空字符串处理:
view plaincopy to clipboardprint?<bean class="ExampleBean"> 
  <property name="email"><null/></property> 
</bean> 
<bean class="ExampleBean">
  <property name="email"><null/></property>
</bean>
map中entry元素的简写形式为key/key-ref 和 value /value-ref属性。
使用p名称空间配置属性：
view plaincopy to clipboardprint?<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> 
<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,如下：
view plaincopy to clipboardprint?<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> 
<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>



使用depends-on：
depends-on属性可以用于当前bean初始化之前显式地强制一个或多个bean被初始化。
若需要表达对多个bean的依赖，可以在'depends-on'中将指定的多个bean名字用分隔符进行分隔，分隔符可以是逗号、空格及分号等。
view plaincopy to clipboardprint?<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" /> 
<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" />


延迟初始化bean：
在XML配置文件中，延迟初始化将通过<bean/>元素中的lazy-init属性来进行控制。
view plaincopy to clipboardprint?<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/> 
<bean id="lazy" class="com.foo.ExpensiveToCreateBean" lazy-init="true"/>
在容器层次上通过在<beans/>元素上使用'default-lazy-init'属性来控制延迟初始化也是可能的。
view plaincopy to clipboardprint?<beans default-lazy-init="true"> 
    <!-- no beans will be pre-instantiated... --> 
</beans> 
<beans default-lazy-init="true">
    <!-- no beans will be pre-instantiated... -->
</beans>
自动装配（autowire）协作者：
Spring IoC容器可以自动装配（autowire）相互协作bean之间的关联关系。autowire一共有五种类型：no、byName（根据属性名自动装配）、
byType（如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配）、constructor（与byType的方式类似，不同之处在于它应用于构造器参数）、
autodetect（通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配）
依赖检查:
Spring除了能对容器中bean的依赖设置进行检查外，还可以检查bean定义中实际属性值的设置，当然也包括采用自动装配方式设置属性值的检查。
依赖检查默认为not，它有几种不同的使用模式，在xml配置文件中，可以在bean定义中为dependency-check属性使用以下几种值:
none: 没有依赖检查，如果bean的属性没有值的话可以不用设置。
simple: 对于原始类型及集合（除协作者外的一切东西）执行依赖检查
object: 仅对协作者执行依赖检查
all: 对协作者，原始类型及集合执行依赖检查
分享到：
| freemark开发指南(入门)----转载
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring配置文件详解，每一步都含有注释

    spring配置文件详解，交你如何理解spring，熟练运用spring

    spring 配置文件详解

    Spring 配置文件详解 Spring 配置文件是指-guide Spring 工厂进行 Bean 生产、依赖关系注入（装配）及 Bean 实例分发的“图纸”。Java EE 程序员必须学会并灵活应用这份“图纸”准确地表达自己的“生产意图”。...

    spring所有配置文件详解

    ### Spring配置文件详解 #### 一、引言 在Java Web开发领域，Spring框架因其强大的功能和灵活性而受到广泛欢迎。对于初学者来说，理解Spring的配置方式是至关重要的第一步。本文将详细介绍Spring中常见的配置文件...

    Spring 配置文件详解.doc

    Spring 配置文件详解 Spring 框架中的配置文件是项目的核心组件之一，用于定义和管理应用程序中的 Bean 对象。配置文件通常以 XML 文件形式存在，用于描述 Bean 对象的定义、关系和依赖关系。在本文中，我们将详细...

    spring 配置文件详解.txt

    ### Spring配置文件详解 #### 一、Spring框架与配置文件的重要性 Spring框架是Java平台上的一个开源框架，它提供了一种轻量级的方式来管理和组织Java应用程序中的组件。Spring框架的核心特性之一是依赖注入...

    Spring配置文件详解1

    下面我们将深入探讨Spring配置文件中的关键知识点。 首先，我们来看`&lt;context:component-scan&gt;`标签，它用于开启注解扫描。这个标签告诉Spring去寻找特定包下的所有使用了Spring注解（如@Service、@Repository、@...

    spring配置文件详解--真的蛮详细

    spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入（装配）及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring配置文件是一个或多个标准的XML文档...

    详解Spring的配置文件

    ### Spring配置文件详解 #### 一、Spring框架简介与配置文件的重要性 Spring 是一个开源的 Java 平台框架，提供了一种轻量级的应用程序开发方式。它通过依赖注入（Dependency Injection, DI）和面向切面编程...

    spring mvc的配置文件详解

    ### Spring MVC 的配置文件详解 #### 一、配置分发器 (DispatcherServlet) Spring MVC 的核心组件之一就是 DispatcherServlet，它作为整个框架的入口，负责处理所有进入 Spring Web 应用程序的请求。为了使 ...

    Spring整合配置文件详解.doc

    #### 二、Spring配置文件详解 **1. 构造注入** 构造注入是Spring框架中一种常见的依赖注入方式，通过构造器来传递依赖。这种方式的优点在于，可以确保类在初始化时就有必要的依赖。例如，在配置文件中可以这样定义...

    spring配置文件加密实现

    为了保护这些敏感信息不被非法访问或篡改，我们可以对Spring配置文件进行加密处理。本文将深入探讨如何在Java环境中，利用TE网络技术实现Spring配置文件的加密。 首先，我们需要理解Spring配置文件的基本结构。...

    spring配置activemq详解

    在"spring配置activemq详解"这个主题中，我们将探讨如何在Spring项目中配置和使用ActiveMQ。以下是对这个主题的详细说明： 1. **配置ActiveMQ**： - 首先，我们需要在项目中引入ActiveMQ的相关依赖，这通常通过在`...

    Spring之AOP配置文件详解

    ### Spring之AOP配置文件详解 #### 一、前言 在Java开发中，Spring框架因其强大的功能和灵活的配置而被广泛应用于企业级应用的开发。其中，面向切面编程（Aspect Oriented Programming，简称AOP）是Spring框架的...

    spring boot配置文件参数详解

    spring boot配置文件参数详解，spring boot配置文件参数详解，spring boot配置文件参数详解，spring boot配置文件参数详解，

    spring配置文件

    《Spring配置文件详解》 Spring框架的核心之一就是其配置文件，它是实现依赖注入（Dependency Injection，简称DI）的关键。配置文件通常以XML格式存在，用于定义bean及其相互依赖关系，从而构建应用程序的组件模型...

    spring配置文件模板

    《Spring配置文件模板详解》 在Java开发领域，Spring框架以其强大的依赖注入（Dependency Injection，简称DI）和面向切面编程（Aspect-Oriented Programming，简称AOP）能力，成为了企业级应用开发的重要选择。而...

Magicbox
Global site tag (gtag.js) - Google Analytics