Spring基础学习教程(Spring配置文件详解)-03

最新推荐文章于 2024-06-29 11:37:30 发布

Java潘老师

最新推荐文章于 2024-06-29 11:37:30 发布

阅读量436

点赞数

分类专栏： Spring 文章标签： spring

Spring 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

本文详细介绍了Spring配置文件的应用，包括默认配置文件applicationContext.xml的作用、如何使用XML定义Bean及其依赖关系，以及Spring配置文件中各种标签的基本用途。此外，还提供了12个Spring XML配置的最佳实践技巧。

摘要由CSDN通过智能技术生成

spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入（装配）及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring配置文件是一个或多个标准的XML文档，applicationContext.xml是Spring的默认配置文件，当容器启动时找不到指定的配置文档时，将会尝试加载这个默认的配置文件。

下面列举的是一份比较完整的配置文件模板，文档中各XML标签节点的基本用途也给出了详细的解释，这些XML标签节点在后续的知识点中均会用到，熟练掌握了这些XML节点及属性的用途后，为我们动手编写配置文件打下坚实的基础。

下面，就上面的配置列举一个示例：

[html]view plaincopy 
   
 
   
 
   
 <?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-2.5.xsd">  
     <!-- 定义使用C3P0连接池的数据源 -->  
     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
         <!-- 指定连接数据库的JDBC驱动 -->  
         <property name="driverClass">  
             <value>com.mysql.jdbc.Driver</value>  
         </property>  
         <!-- 连接数据库所用的URL -->  
         <property name="jdbcUrl">  
             <value>jdbc:mysql://localhost:3306/eportal?useUnicode=  
                 true&characterEncoding=gbk</value>  
         </property>  
         <!-- 连接数据库的用户名 -->  
         <property name="user">  
             <value>root</value>  
         </property>  
         <!-- 连接数据库的密码 -->  
         <property name="password">  
             <value>root</value>  
         </property>  
         <!-- 设置数据库连接池的最大连接数 -->  
         <property name="maxPoolSize">  
             <value>20</value>  
         </property>  
         <!-- 设置数据库连接池的最小连接数 -->  
         <property name="minPoolSize">  
             <value>2</value>  
         </property>  
         <!-- 设置数据库连接池的初始化连接数 -->  
         <property name="initialPoolSize">  
             <value>2</value>  
         </property>  
         <!-- 设置数据库连接池的连接的最大空闲时间，单位为秒 -->  
         <property name="maxIdleTime">  
             <value>20</value>  
         </property>  
     </bean>  
     <!-- 定义Hibernate的SessionFactory -->  
     <bean id="sessionFactory"  
         class="org.springframework.orm.  
 hibernate3.LocalSessionFactoryBean">  
         <!-- 依赖注入上面定义的数据源dataSource -->  
         <property name="dataSource" ref="dataSource" />  
         <!-- 注册Hibernate的ORM映射文件 -->  
         <property name="mappingResources">  
             <list>  
                 <value>com/eportal/ORM/News.hbm.xml</value>  
                 <value>com/eportal/ORM/Category.hbm.xml</value>  
                 <value>com/eportal/ORM/Memberlevel.hbm.xml</value>  
                 <value>com/eportal/ORM/Cart.hbm.xml</value>  
                 <value>com/eportal/ORM/Traffic.hbm.xml</value>  
                 <value>com/eportal/ORM/Newsrule.hbm.xml</value>  
                 <value>com/eportal/ORM/Merchandise.hbm.xml</value>  
                 <value>com/eportal/ORM/Admin.hbm.xml</value>  
                 <value>com/eportal/ORM/Orders.hbm.xml</value>  
                 <value>com/eportal/ORM/Cartselectedmer.hbm.xml</value>  
                 <value>com/eportal/ORM/Newscolumns.hbm.xml</value>  
                 <value>com/eportal/ORM/Member.hbm.xml</value>  
             </list>  
         </property>  
         <!-- 设置Hibernate的相关属性 -->  
         <property name="hibernateProperties">  
             <props>  
                 <!-- 设置Hibernate的数据库方言 -->  
                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
                 <!-- 设置Hibernate是否在控制台输出SQL语句，开发调试阶段通常设为true -->  
                 <prop key="show_sql">true</prop>  
                 <!-- 设置Hibernate一个提交批次中的最大SQL语句数 -->  
                 <prop key="hibernate.jdbc.batch_size">50</prop>  
                 <prop key="show_sql">50</prop>  
             </props>  
         </property>  
     </bean>  
     <!--定义Hibernate的事务管理器HibernateTransactionManager -->  
     <bean id="transactionManager"  
         class="org.springframework.orm.hibernate3.HibernateTransactionManager">  
         <!-- 依赖注入上面定义的sessionFactory -->  
         <property name="sessionFactory" ref="sessionFactory" />  
     </bean>  
     <!--定义Spring的事务拦截器TransactionInterceptor -->  
     <bean id="transactionInterceptor"  
         class="org.springframework.transaction.interceptor.TransactionInterceptor">  
         <!-- 依赖注入上面定义的事务管理器transactionManager -->  
         <property name="transactionManager" ref="transactionManager" />  
         <!-- 定义需要进行事务拦截的方法及所采用的事务控制类型 -->  
         <property name="transactionAttributes">  
             <props>  
                 <!-- 以browse、list、load、get及is开头的所有方法采用只读型事务控制类型 -->  
                 <prop key="browse*">PROPAGATION_REQUIRED,readOnly</prop>  
                 <prop key="list*">PROPAGATION_REQUIRED,readOnly</prop>  
                 <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>  
                 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>  
                 <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>  
                 <!-- 所有方法均进行事务控制，如果当前没有事务，则新建一个事务 -->  
                 <prop key="*">PROPAGATION_REQUIRED</prop>  
             </props>  
         </property>  
     </bean>  
     <!-- 定义BeanNameAutoProxyCreatorf进行Spring的事务处理 -->  
     <bean  
         class="org.springframework.aop.framework.autoproxy.    
 BeanNameAutoProxyCreator">  
         <!-- 针对指定的bean自动生成业务代理 -->  
         <property name="beanNames">  
             <list>  
                 <value>adminService</value>  
                 <value>columnsService</value>  
                 <value>newsService</value>  
                 <value>crawlService</value>  
                 <value>memberLevelService</value>  
                 <value>memberService</value>  
                 <value>categoryService</value>  
                 <value>merService</value>  
                 <value>cartService</value>  
                 <value>ordersService</value>  
                 <value>trafficService</value>  
             </list>  
         </property>  
         <!-- 这个属性为true时，表示被代理的是目标类本身而不是目标类的接口 -->  
         <property name="proxyTargetClass">  
             <value>true</value>  
         </property>  
         <!-- 依赖注入上面定义的事务拦截器transactionInterceptor -->  
         <property name="interceptorNames">  
             <list>  
                 <value>transactionInterceptor</value>  
             </list>  
         </property>  
     </bean>  
     <!-- 装配通用数据库访问类BaseDAOImpl -->  
     <bean id="dao" class="com.eportal.DAO.BaseDAOImpl">  
         <property name="sessionFactory" ref="sessionFactory" />  
     </bean>  
     <!-- 部署系统用户管理业务逻辑组件AdminServiceImpl -->  
     <bean id="adminService" class="com.eportal.service.AdminServiceImpl">  
         <property name="dao" ref="dao" />  
     </bean>  
     <!-- 部署新闻栏目管理业务逻辑组件ColumnsServiceImpl -->  
     <bean id="columnsService" class="com.eportal.service.ColumnsServiceImpl">  
         <property name="dao" ref="dao" />  
     </bean>  
       
     <!-- 部署订单管理业务逻辑组件OrderServiceImpl -->  
     <bean id="ordersService" class="com.eportal.service.OrderServiceImpl">  
         <property name="dao" ref="dao" />  
     </bean>  
     <!-- 部署流量统计业务逻辑组件TrafficServiceImpl -->  
     <bean id="trafficService" class="com.eportal.service.TrafficServiceImpl">  
         <property name="dao" ref="dao" />  
     </bean>  
     <!-- 部署Struts 2负责系统用户管理的控制器AdminAction -->  
     <bean id="adminAction" class="com.eportal.struts.action.  
 AdminAction"  
         scope="prototype">  
         <property name="service" ref="adminService" />  
     </bean>  
     <!-- 部署Struts 2负责新闻栏目管理的控制器ColumnsAction -->  
     <bean id="columnsAction" class="com.eportal.struts.action.  
 ColumnsAction"  
         scope="prototype">  
         <property name="service" ref="columnsService" />  
     </bean>  
     <!-- 部署Struts 2负责新闻管理的控制器NewsAction -->  
     <bean id="newsAction" class="com.eportal.struts.action.  
 NewsAction"  
         scope="prototype">  
         <property name="service" ref="newsService" />  
         <property name="columnsService" ref="columnsService" />  
     </bean>  
     <!-- 部署Struts 2负责新闻采集规则管理的控制器CrawlAction -->  
     <bean id="crawlAction" class="com.eportal.struts.action.  
 CrawlAction"  
         scope="prototype">  
         <property name="service" ref="crawlService" />  
         <property name="columnsService" ref="columnsService" />  
     </bean>  
       
 </beans>   
 

Spring ApplicationContext.xml配置的12个技巧

Spring是一个强有力的java程序框架，其被广泛应用于java的程序中。它用POJO提供了企业级服务。 Spring利用依赖注入可以获得简单而有效的测试能力。Spring beans，依赖关系，以及服务所需要的bean都将在配置文件中予以描述，配置文件一般采用XML格式。然而XML配置文件冗长而不易使用，在你进行一个使用了大量bean的大项目中它将变得难以阅读和控制。

在这篇文章中我将给你展示12种的有关Spring XML配置文件的最佳技巧。它们中的一些具有更多的实际意义，而不仅是最好的技巧。请注意另外一些因素，例如域模型的设计，会影响到XML配置，但是这篇文章更关注于XML配置的可读性和可操控性。

1．避免使用自动装配

Spring 可以通过bean类的自省来实现自动装配依赖，这样的话你就不必明确地描述bean的属性或者构造函数的参数。根据属性名称活匹配类型，bean属性可以自动进行装配。而构造函数可以根据匹配类型自动装配。你甚至可以设置自动装配进行自动侦测，这样Spring替你就会选择一个合适的机制。请看下面的例子：

<bean id="orderService"

class="com.lizjason.spring.OrderService"

autowire="byName"/>

OrderService 类的属性名被用来和容器中的一个bean实例进行匹配。自动装配会默默的保存一些类型信息并降低混乱。然而，由于它会牺牲掉这种配置的直观性和可维护性，你在实际的项目中将不会用到它。许多指南和陈述材料都把它吹捧为Spring的一个非常cool的特性，而没有提到它的这个缺点。依我之见，就像 Spring的对象池一样，它更多了一些商业味道。它看起来好像可以使XML配置文件更精简一些，但实际上却增加其复杂性，尤其是在你的较大规模的工程中已经定义了很多bean的时候更是如此。Spring允许你混合使用自动和手动装配，但是这种矛盾会使XML配置更加的令人费解。

2．使用命名规范

和Java 编码的理念一样，在项目中始终用清晰的，描述性的，一致的命名规范对开发人员理解XML配置非常有用。拿bean ID举例来说，你可以遵循Java类中属性的命名规范。比如说，OrderServiceDAO的bean ID应该是orderServiceDAO。对于大项目来说，在bean ID前加包名来作为前缀。

3．使用简化格式

简化格式有利于减少冗余，因为它把属性值和引用作为属性，而不是子元素。看下面的例子：

    <bean id="orderService"

        class="com.lizjason.spring.OrderService">

        <property name="companyName">

            <value>lizjason</value>

        </property>

        <constructor-arg>

            <ref bean="orderDAO">

        </constructor-arg>

    </bean>

以上程序可以重新以简化格式书写为：

    <bean id="orderService"

        class="com.lizjason.spring.OrderService">

        <property name="companyName"

            value="lizjason"/>

        <constructor-arg ref="orderDAO"/>

    </bean>

简化格式在1.2版本时已经可用了，但请注意不存在<ref local="...">这种简化格式不仅可以较少你的代码输入量，而且可以使XML配置更加的清晰。当你的配置文件中存在大量的bean定义时，它可以显著地提高可读性。

4．尽量使用type而不是index去解决构造函数参数的匹配问题

当构造函数中有多个同类型的参数时，Spring只允许你使用从0开始的index或者value标签来解决这个问题。请看下面的例子：

    <bean id="billingService"

        class="com.lizjason.spring.BillingService">

        <constructor-arg index="0" value="lizjason"/>

        <constructor-arg index="1" value="100"/>

    </bean>

最好用type属性取代上面的做法：

    <bean id="billingService"

        class="com.lizjason.spring.BillingService">

        <constructor-arg type="java.lang.String"

            value="lizjason"/>

        <constructor-arg type="int" value="100"/>

    </bean>

用index可以稍微减少冗余，但是它更容易出错且不如type属性可读性高。你应该仅在构造函数中有参数冲突时使用index。

5．如可能，尽量复用bean定义

Spring 提供了一种类似于继承的机制来降低配置信息的重复并使XML配置更加的简单。一个子bean可以从它的父bean继承配置信息，本质上这个父bean就像它的子bean的一个模板。这是一个在大型项目中必须使用的特性。所有你要做的就是把父bean的abstract属性置为true，并在子bean中加以引用。例如：

    <bean id="abstractService" abstract="true"

        class="com.lizjason.spring.AbstractService">

        <property name="companyName"

            value="lizjason"/>

    </bean>

    <bean id="shippingService"

        parent="abstractService"

        class="com.lizjason.spring.ShippingService">

        <property name="shippedBy" value="lizjason"/>

    </bean>

shippingService bean继承了abstractService bean的属性companyName的值lizjason。注意，如果你为bean声名一个class或工厂方法，这个bean将会默认为abstract

6．尽量使用 ApplicationContext装配bean，而不是用import

像Ant脚本中imports一样，Spring的import 元素对于模块化bean的装配非常有用，例如：

    <beans>

        <import resource="billingServices.xml"/>

        <import resource="shippingServices.xml"/>

        <bean id="orderService"

            class="com.lizjason.spring.OrderService"/>

    <beans>

然而，比起在XML中用imports预装配这些bean，利用ApplicationContext来配置它们将更加灵活，也可以使XML配置更加的易于管理。你可以像下面这样传递一个bean定义数组到ApplicationContext的构造函数中：

String[] serviceResources =

{"orderServices.xml",

"billingServices.xml",

"shippingServices.xml"};

ApplicationContext orderServiceContext = new

ClassPathXmlApplicationContext(serviceResources);

7．用id来标识bean

你可以用id 或名字作为bean的标识。用id可读性较差，但是它可以影响XML分析器使bean的reference有效。如果id由于XML IDREF约束而无法使用，你可以用name作为bean的标识。XML IDREF约束是指id必须以字母开始(或者是在XML声名了的一个标点符号)，后面可以是字母，数字，连字符，下划线，冒号或full stops(不知道怎么翻译好)。在实际应用中很少会遇到XML IDREF约束问题。

8．在开发阶段使用依赖检查

你可以为bean的dependency-check属性设置一个值来取代默认的none，比如说simple，objects或者all，这样的话容器将替你做依赖有效性的检查。当一个bean的所有属性(或者某些属性目录)都被明确设置，或利用自动装配时将会非常有用。

    <bean id="orderService"

        class="com.lizjason.spring.OrderService"

        dependency-check="objects">

        <property name="companyName"

            value="lizjason"/>

        <constructor-arg ref="orderDAO"/>

    </bean>

在这个例子中，容器将确保这些属性不是privitives或者保证collections是为orderService bean设置的。为所有的bean设置默认的依赖检查是可能的，但这个特性由于有些bean的属性不需要设置而很少使用。

9．为每个配置文件加一个描述注释

在XML配置文件中最好使用有描述性的id和name，而不是成堆的注释。另外，加一个文件描述头将会非常有用，这个描述可以概括文件中定义的bean。另一个选择，你可以在 description元素中加入描述信息。例如：

    <beans>

        <description>

            This file defines billing service

            related beans and it depends on

            baseServices.xml,which provides

            service bean templates...

        </description>

...

    </beans>

用description元素的一个好处就是工具可以很容易的把描述信息从这个元素中提取出来。

10． 和team members沟通变更

当你修改java源码后，要确保更改了配置文件中的相应部分并把这个情况告知你的team members。XML配置文件也是代码，它们是程序的重要组成部分，但它们很难阅读和维护。大多数时间里，你需要同时看XML配置文件和java代码才能知道是怎么回事。

11． setter注入和构造函数注入，优先使用前者

Spring提供了三种注入方式：构造函数注入，setter注入和方法注入。一般我们使用前两种。

    <bean id="orderService"

        class="com.lizjason.spring.OrderService">

        <constructor-arg ref="orderDAO"/>

    </bean>

    <bean id="billingService"

        class="com.lizjason.spring.BillingService">

        <property name="billingDAO"

            ref="billingDAO">

    </bean>

在这个例子中，orderService bean用了构造函数注入，而BillingService bean用了setter注入。构造函数注入可以确保bean正确地构建，但是setter注入更加的灵活和易于控制，特别是当class有多个属性并且它们中的一些是可选的情况是更是如此。

12．不要滥用注入

就像前面提到的，Spring的ApplicationContextEclipse and IntelliJ，java代码更加的易于阅读，维护和管理比使XML文件 可以替你创建java对象，但不是所有的java对象都应该通过注入创建。例如，域对象就不应该通过ApplicationContext

创建。Spring是一个优秀的框架，但是考虑到可读性和可操控性，基于XML配置的配置会在定义很多bean的时候出现麻烦。过渡使用依赖注入将会使XML配置更加的复杂和冗长。切记，当使用高效的IDE时，例如

结论

XML是Spring 流行的配置格式。存在大量bean定义时，基于XML的配置会变得冗长而不易使用。Spring提供了丰富的配置选项。适当地使用这些选项可以使XML配置更加的清晰，但其它的一些选项，例如自动装配，可能会降低可读性和可维护性。参考本文中提到的这些技巧可能会帮助你创建干净而易读的XML配置文件

<bean

id="beanId"（1）

name="beanName"（2）

class="beanClass"（3）

parent="parentBean"（4）

abstract="true | false"（5）

singleton="true | false"（6）

lazy-init="true | false | default"（7）

dependency-check = "none | objects | simple | all | default"（9）

depends-on="dependsOnBean"（10）

init-method="method"（11）

destroy-method="method"（12）

factory-method="method"（13）

factory-bean="bean">（14）

</bean>

（1）、id: Bean的唯一标识名。它必须是合法的XML ID，在整个XML文档中唯一。

（2）、name: 用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。

（3）、class: 用来定义类的全限定名（包名＋类名）。只有子类Bean不用定义该属性。

（4）、parent: 子类Bean定义它所引用它的父类Bean。这时前面的class属性失效。子类Bean会继承父类Bean的所有属性，子类Bean也可以覆盖父类Bean的属性。注意：子类Bean和父类Bean是同一个Java类。

（5）、abstract（默认为”false”）：用来定义Bean是否为抽象Bean。它表示这个Bean将不会被实例化，一般用于父类Bean，因为父类Bean主要是供子类Bean继承使用。

（6）、singleton（默认为“true”）：定义Bean是否是Singleton（单例）。如果设为“true”,则在BeanFactory作用范围内，只维护此Bean的一个实例。如果设为“flase”，Bean将是Prototype（原型）状态，BeanFactory将为每次Bean请求创建一个新的Bean实例。

（7）、lazy-init（默认为“default”）：用来定义这个Bean是否实现懒初始化。如果为“true”，它将在BeanFactory启动时初始化所有的Singleton Bean。反之，如果为“false”,它只在Bean请求时才开始创建Singleton Bean。

（8）、autowire（自动装配，默认为“default”）：它定义了Bean的自动装载方式。

1、“no”:不使用自动装配功能。

2、“byName”:通过Bean的属性名实现自动装配。

3、“byType”:通过Bean的类型实现自动装配。

4、“constructor”:类似于byType，但它是用于构造函数的参数的自动组装。

5、“autodetect”:通过Bean类的反省机制（introspection）决定是使用“constructor”还是使用“byType”。

（9）、dependency-check（依赖检查，默认为“default”）：它用来确保Bean组件通过JavaBean描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用。

1、 none：不进行依赖检查。

2、 objects：只做对象间依赖的检查。

3、 simple：只做原始类型和String类型依赖的检查

4、 all：对所有类型的依赖进行检查。它包括了前面的objects和simple。

（10）、depends-on（依赖对象）：这个Bean在初始化时依赖的对象，这个对象会在这个Bean初始化之前创建。

（11）、init-method:用来定义Bean的初始化方法，它会在Bean组装之后调用。它必须是一个无参数的方法。

（12）、destroy-method：用来定义Bean的销毁方法，它在BeanFactory关闭时调用。同样，它也必须是一个无参数的方法。它只能应用于singleton Bean。

（13）、factory-method：定义创建该Bean对象的工厂方法。它用于下面的“factory-bean”，表示这个Bean是通过工厂方法创建。此时，“class”属性失效。

（14）、factory-bean:定义创建该Bean对象的工厂类。如果使用了“factory-bean”则“class”属性失效。

下面列出<ref>元素的所有可用的指定方式：

bean：可以在当前文件中查找依赖对象，也可以在应用上下文（ApplicationContext）中查找其它配置文件的对象。

local：只在当前文件中查找依赖对象。这个属性是一个XML IDREF，所以它指定的对象必须存在，否则它的验证检查会报错。

external：在其它文件中查找依赖对象，而不在当前文件中查找。

总的来说，<ref bean="..."/>和<ref local="..."/>大部分的时候可以通用。“bean”是最灵活的方式，它允许你在多个文件之间共享Bean。而“local”则提供了便利的XML验证。

如何使用spring的作用域：

< bean id = "role" class = "spring.chapter2.maryGame.Role" scope= "singleton"/ >

这里的 scope 就是用来配置 spring bean 的作用域，它标识 bean 的作用域。

在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype）, Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。当然，Spring2.0对 Bean的类型的设计进行了重构，并设计出灵活的Bean类型支持，理论上可以有无数多种类型的Bean，用户可以根据自己的需要，增加新的Bean类型，满足实际应用需求。

1、singleton 作用域

当一个bean的作用域设置为singleton, 那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。

配置实例：

< bean id = "role" class = "spring.chapter2.maryGame.Role" scope= "singleton"/ >

或者

< bean id = "role" class = "spring.chapter2.maryGame.Role" singleton= "true"/ >

2、prototype

prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的 getBean()方法）都会产生一个新的bean实例，相当与一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用 bean的后置处理器，该处理器持有要被清除的bean的引用。）

配置实例：

< bean id = "role" class = "spring.chapter2.maryGame.Role" scope= "prototype"/ >

或者

< bean id = "role" class = "spring.chapter2.maryGame.Role" singleton= "false"/ >

3、request

request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，配置实例：

request、session、global session使用的时候首先要在初始化web的web.xml中做如下配置：

如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：

< web-app >

...

< listener >

< listener-class >org.springframework.web.context.request.RequestContextListener </ listener-class >

</ listener >

...

</ web-app >

，如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现：

< web-app >

< filter >

< filter-name >requestContextFilter </ filter-name >

< filter-class >org.springframework.web.filter.RequestContextFilter </ filter-class >

</ filter >

< filter-mapping >

< filter-name >requestContextFilter </ filter-name >

< url-pattern >/* </ url-pattern >

</ filter-mapping >

...

</ web-app >

接着既可以配置bean的作用域了：

< bean id = "role" class = "spring.chapter2.maryGame.Role" scope= "request"/ >

4、session

session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效，配置实例：

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

< bean id = "role" class = "spring.chapter2.maryGame.Role" scope= "session"/ >

5、global session

global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么web会自动当成session类型来使用。

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

< bean id = "role" class = "spring.chapter2.maryGame.Role" scope= "global session"/ >

6、自定义bean装配作用域

在spring2.0中作用域是可以任意扩展的，你可以自定义作用域，甚至你也可以重新定义已有的作用域（但是你不能覆盖singleton和 prototype），spring的作用域由接口org.springframework.beans.factory.config.Scope来定义，自定义自己的作用域只要实现该接口即可，下面给个实例：

我们建立一个线程的scope，该scope在表示一个线程中有效，代码如下：