BlogJava-我的漫漫程序之旅-文章分类-Spring

使用Spring的CharacterEncodingFilter应注意的问题

々上善若水々 — Mon, 28 Jan 2008 09:45:00 GMT

这是我的web.xml中配置:

    <filter>
        <filter-name>eXtremeExportfilter-name>
        <filter-class>
            org.extremecomponents.table.filter.ExportFilter
        filter-class>
    filter>
    <filter-mapping>
        <filter-name>eXtremeExportfilter-name>
        <url-pattern>*.dourl-pattern>
    filter-mapping>

    <filter>
        <filter-name>encodingFilterfilter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        filter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>GBKparam-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>encodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

看不出有什么问题,可当我插入测试数据时全是乱码.
数据库本身是没有问题的.

后来终于找到了解决的方法,原创列表组件的filter对
CharacterEncodingFilter的过滤有影响.调整一下顺序就行了.

    <filter>
        <filter-name>encodingFilterfilter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        filter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>GBKparam-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>encodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

    <filter>
        <filter-name>eXtremeExportfilter-name>
        <filter-class>
            org.extremecomponents.table.filter.ExportFilter
        filter-class>
    filter>
    <filter-mapping>
        <filter-name>eXtremeExportfilter-name>
        <url-pattern>*.dourl-pattern>
    filter-mapping>

调整后CharacterEncodingFilter表现良好,一切正常.就不会再出来
乱码的问题了.

々上善若水々 2008-01-28 17:45 发表评论

Spring发送邮件的简单例子

々上善若水々 — Fri, 11 Jan 2008 12:32:00 GMT

注意在做此例前确认你已经加入了
spring-misc相关包
以及mail.jar,activation.jar.
如没有可到我的网盘下载.
bean.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-2.0.xsd">
    <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">

        <property name="host">
            <value>smtp.163.comvalue>
        property>
        <property name="javaMailProperties">
            <props>

                <prop key="mail.smtp.auth">trueprop>
                <prop key="mail.smtp.timeout">25000prop>
            props>
        property>

        <property name="username">
            <value>78688287value>
        property>

        <property name="password">
            <value>******value>
        property>
    bean>

beans>

MailTest.java:

package com;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;

public class MailTest
{

    public static void main(String[] args)
    {
        //得到spring的context对象
        ApplicationContext ctx = new FileSystemXmlApplicationContext("/src/com/bean.xml");
        //mail提供者
        MailSender sender = (MailSender) ctx.getBean("mailSender");
        //创建一个简单mail消息对象
        SimpleMailMessage smm = new SimpleMailMessage();
        //收件人
        smm.setTo("zdw@live.cn");
        //发件人地址
        smm.setFrom("78688287@163.com");
        //标题
        smm.setSubject("test");
        //内容
        smm.setText("这是关于Spring Mail抽象层的简单测试");
        //发送
        sender.send(smm);
        //提示信息
        System.out.println("Send Ok!!");
    }

}

经测试一切正常.

々上善若水々 2008-01-11 20:32 发表评论

我的第一个aspectJ程序

々上善若水々 — Thu, 10 Jan 2008 10:04:00 GMT

MyClass.java:

package com;

public class MyClass
{
    public void foo(int age, String name)
    {
        System.out.println("Inside foo(int,String)");
    }

    public static void main(String[] args)
    {
        MyClass myClass = new MyClass();
        myClass.foo(1, "zdw");
    }

}

HelloWorld.aj:

package com;

public aspect HelloWorld
{
    //切入点
    pointcut callPointcut() : call(void MyClass.foo(int,String));
    //前置通知
    before() : callPointcut()
    {
        System.out.println("Hello World");
        System.out.println("In the advice attached to the call pointcut");
    }
}

々上善若水々 2008-01-10 18:04 发表评论

使用Spring进行面向切面编程（AOP）

々上善若水々 — Thu, 10 Jan 2008 09:40:00 GMT

摘要: 简介面向切面编程（AOP）提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编程（OOP）的不足。除了类（classes）以外，AOP提供了切面。切面对关注点进行模块化，例如横切多个类型和对象的事务管理。（这些关注点术语通常称作横切（crosscutting）关注点。） Spring的一个关键的组件就是 AOP框架。尽管如此，Spring IoC容器并不依赖于AOP，这... 阅读全文

々上善若水々 2008-01-10 17:40 发表评论

Spring AOP初探

々上善若水々 — Mon, 31 Dec 2007 13:48:00 GMT

AOP正在成为软件开发的下一个圣杯。使用AOP，你可以将处理aspect的代码注入主程序，通常主程序的主要目的并不在于处理这些aspect。AOP可以防止代码混乱。
为了理解AOP如何做到这点，考虑一下记日志的工作。日志本身不太可能是你开发的主程序的主要任务。如果能将“不可见的”、通用的日志代码注入主程序中，那该多好啊。AOP可以帮助你做到。
Spring framework是很有前途的AOP技术。作为一种非侵略性的，轻型的AOP framework，你无需使用预编译器或其他的元标签，便可以在Java程序中使用它。这意味着开发团队里只需一人要对付AOP framework，其他人还是象往常一样编程。
AOP是很多直觉难以理解的术语的根源。幸运的是，你只要理解三个概念，就可以编写AOP模块。这三个概念是：advice，pointcut和 advisor。advice是你想向别的程序内部不同的地方注入的代码。pointcut定义了需要注入advice的位置，通常是某个特定的类的一个 public方法。advisor是pointcut和advice的装配器，是将advice注入主程序中预定义位置的代码。

既然我们知道了需要使用advisor向主要代码中注入“不可见的”advice，让我们实现一个Spring AOP的例子。在这个例子中，我们将实现一个before advice，这意味着advice的代码在被调用的public方法开始前被执行。以下是这个before advice的实现代码：

package com.company.springaop.test;

import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class TestBeforeAdvice implements MethodBeforeAdvice {

  public void before(Method m, Object[] args, Object target)
  throws Throwable {
    System.out.println("Hello world! (by "
        + this.getClass().getName()
        + ")");
  }
}

接口MethodBeforeAdvice只有一个方法before需要实现，它定义了advice的实现。before方法共用三个参数，它们提供了相当丰富的信息。参数Method m是advice开始后执行的方法。方法名称可以用作判断是否执行代码的条件。Object[] args是传给被调用的public方法的参数数组。当需要记日志时，参数args和被执行方法的名称，都是非常有用的信息。你也可以改变传给m的参数，但要小心使用这个功能；编写最初主程序的程序员并不知道主程序可能会和传入参数的发生冲突。Object target是执行方法m对象的引用。

在下面的BeanImpl类中，每个public方法调用前，都会执行advice：

package com.company.springaop.test;

public class BeanImpl implements Bean {

  public void theMethod() {
    System.out.println(this.getClass().getName()
        + "." + new Exception().getStackTrace()[0].getMethodName()
        + "()"
        + " says HELLO!");
  }
}

类BeanImpl实现了下面的接口Bean：

package com.company.springaop.test;

public interface Bean {
public void theMethod();
}

虽然不是必须使用接口，但面向接口而不是面向实现编程是良好的编程实践，Spring也鼓励这样做。

pointcut和advice通过配置文件来实现，因此，接下来你只需编写主方法的Java代码：

package com.company.springaop.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class Main {

  public static void main(String[] args) {
    //Read the configuration file
    ApplicationContext ctx
        = new FileSystemXmlApplicationContext("springconfig.xml");

    //Instantiate an object
    Bean x = (Bean) ctx.getBean("bean");

    //Execute the public method of the bean (the test)
    x.theMethod();
  }
}

我们从读入和处理配置文件开始，接下来马上要创建它。这个配置文件将作为粘合程序不同部分的“胶水”。读入和处理配置文件后，我们会得到一个创建工厂ctx。任何一个Spring管理的对象都必须通过这个工厂来创建。对象通过工厂创建后便可正常使用。

仅仅用配置文件便可把程序的每一部分组装起来。

xml version="1.0" encoding="UTF-8"?>
DOCTYPE beans PUBLIC  "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

  <bean id="bean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces">
      <value>com.company.springaop.test.Beanvalue>
    property>
    <property name="target">
      <ref local="beanTarget"/>
    property>
    <property name="interceptorNames">
      <list>
        <value>theAdvisorvalue>
      list>
    property>
  bean>


  <bean id="beanTarget" class="com.company.springaop.test.BeanImpl"/>



  <bean id="theAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    <property name="advice">
      <ref local="theBeforeAdvice"/>
    property>
    <property name="pattern">
      <value>com\.company\.springaop\.test\.Bean\.theMethodvalue>
    property>
  bean>


  <bean id="theBeforeAdvice" class="com.company.springaop.test.TestBeforeAdvice"/>
beans>

四个bean定义的次序并不重要。我们现在有了一个advice，一个包含了正则表达式pointcut的advisor，一个主程序类和一个配置好的接口，通过工厂ctx，这个接口返回自己本身实现的一个引用。

BeanImpl和TestBeforeAdvice都是直接配置。我们用一个唯一的ID创建一个bean元素，并指定了一个实现类。这就是全部的工作。

advisor通过Spring framework提供的一个RegexMethodPointcutAdvisor类来实现。我们用advisor的一个属性来指定它所需的 advice-bean。第二个属性则用正则表达式定义了pointcut，确保良好的性能和易读性。

最后配置的是bean，它可以通过一个工厂来创建。bean的定义看起来比实际上要复杂。bean是ProxyFactoryBean的一个实现，它是Spring framework的一部分。这个bean的行为通过一下的三个属性来定义：

属性proxyInterface定义了接口类。
属性target指向本地配置的一个bean，这个bean返回一个接口的实现。
属性interceptorNames是唯一允许定义一个值列表的属性。这个列表包含所有需要在beanTarget上执行的advisor。注意，advisor列表的次序是非常重要的。

Spring工具

虽然你可以手工修改Ant构建脚本，但使用SpringUI（译注：SpringUI现在是Spring framework的一部分，并改名为spring-ide），使用Spring AOP变得很简单，只要点点鼠标即可。你可以把SpringUI安装成Eclipse的一个plug-in。然后，你只需在你的project上右击鼠标，并选择“add Spring Project Nature”。在project属性中，你可以在“Spring Project”下添加Spring配置文件。在编译前把下面的类库加入project：aopalliance.jar，commons- logging.jar，jakarta-oro-2.0.7.jar和spring.jar。运行程序时你会看到下面的信息：

(logging information)
Hello world! (by com.company.springaop.test.TestBeforeAdvice)
com.company.springaop.test.BeanImpl.theMethod() says HELLO!

优点和缺点

Spring比起其他的framework更有优势，因为除了AOP以外，它提供了更多别的功能。作为一个轻型framework，它在J2EE 不同的部分都可以发挥作用。因此，即使不想使用Spring AOP，你可能还是想使用Spring。另一个优点是，Spring并不要求开发团队所有的人员都会用它。学习Spring应该从Spring reference的第一页开始。读了本文后，你应该可以更好地理解Spring reference了。Spring唯一的缺点是缺乏更多的文档，但它的mailing list是个很好的补充，而且会不断地出现更多的文档。

々上善若水々 2007-12-31 21:48 发表评论

反向控制和面向切面编程在Spring的应用

々上善若水々 — Mon, 31 Dec 2007 13:40:00 GMT

引言

　　在J2EE的整个发展历程中，现在正是一个非常时刻。从很多方面来说，J2EE都是一个伟大的成功：它成功地在从前没有标准的地方建立了标准；大大提升了企业级软件的开放程度，并且得到了整个行业和开发者的广泛认可。然而，J2EE在一些方面已经开始捉襟见肘。J2EE应用开发的成本通常很高。J2EE应用项目至少和从前的非J2EE项目一样容易失败——如果不是更容易失败的话。这样的失败率高得让人难以接受。在这样的失败率之下，软件开发几乎变成了碰运气。而在J2EE遭遇失败的场景中，EJB通常都扮演着重要的角色。因此，J2EE社群不断地向着更简单的解决方案、更少使用EJB的方向发展^[1]。然而，每个应用程序都需要一些基础设施，拒绝使用EJB并不意味着拒绝EJB所采用的基础设施解决方案。那么，如何利用现有的框架来提供这些基础设施服务呢，伴随着这个问题的提出，一个轻量级的J2EE解决方案出现了，这就是Spring Framework。

　　Spring是为简化企业级系统开发而诞生的，Spring框架为J2EE应用常见的问题提供了简单、有效的解决方案，使用Spring，你可以用简单的POJO(Plain Old Java Object)来实现那些以前只有EJB才能实现的功能。这样不只是能简化服务器端开发，任何Java系统开发都能从Spring的简单、可测试和松耦合特征中受益。可以简单的说，Spring是一个轻量级的反向控制（IoC）和面向切面编程（AOP）容器框架^[3]。Spring IoC，借助于依赖注入设计模式，使得开发者不用理会对象自身的生命周期及其关系，而且能够改善开发者对J2EE模式的使用；Spring AOP，借助于Spring实现的拦截器，开发者能够实现以声明的方式使用企业级服务，比如安全性服务、事务服务等。Spring IoC和 Spring ; AOP组合，一起形成了Spring，这样一个有机整体，使得构建轻量级的J2EE架构成为可能，而且事实证明，非常有效。没有Spring IoC的Spring AOP是不完善的，没有Spring AOP的Spring IoC是不健壮的。本文是以Spring架构的成功的实际商务系统项目为背景，阐述了反向控制原理和面向切面的编程技术在Spring框架中的应用，同时抽取适量代码示意具体应用，并和传统开发模式进行对比，展示了Spring framework的简单，高效，可维护等优点。

　　1、Spring IoC 1.1 反向控制原理

　　反向控制是Spring框架的核心。但是，反向控制是什么意思？到底控制的什么方面被反向了呢？2004年美国专家Martin Fowler发表了一篇论文《Inversion of Control Containers and the Dependency Injection pattern》阐述了这个问题，他总结说是获得依赖对象的方式反向了，根据这个启示，他还为反向控制提出了一个更贴切的名字：Dependency Injection(DI 依赖注入)。

　　通常，应用代码需要告知容器或框架,让它们找到自身所需要的类,然后再由应用代码创建待使用的对象实例。因此，应用代码在使用实例之前，需要创建对象实例。然而，IoC模式中,创建对象实例的任务交给IoC容器或框架(实现了IoC设计模式的框架也被称为IoC容器)，使得应用代码只需要直接使用实例，这就是IoC。相对IoC 而言，“依赖注入”的确更加准确的描述了这种设计理念。所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中。

　　1.2 IoC在Spring中的实现

　　任何重要的系统都需要至少两个相互合作的类来完成业务逻辑。通常，每个对象都要自己负责得到它的合作（依赖）对象。你会发现，这样会导致代码耦合度高而且难于测试。使用IoC，对象的依赖都是在对象创建时由负责协调系统中各个对象的外部实体提供的，这样使软件组件松散连接成为可能。下面示意了Spring IoC 应用，步骤如下：

　　（1）定义Action接口，并为其定义一个execute方法，以完成目标逻辑。多年前，GoF在《Design Pattern：Elements of Reusable Object-Oriented Software》一书中提出“Programming to an Interface，not an implementation”的原则，这里首先将业务对象抽象成接口，正是为了实施这个原则。

　　（2）类UpperAction实现Action接口，在此类中，定义一个String型的域message，并提供相应的setter和getter方法，实现的execute方法如下：

public String execute (String str) {
　return (getMessage () + str).toUpperCase () ;
}

　　（3）编写Spring配置文件（bean.xml）

＜beans＞
＜bean id="TheAction" class="net.chen.spring.qs.UpperAction"＞
＜property name="message"＞
＜value＞HeLLo＜/value＞
＜/property＞
＜/bean＞
＜/beans＞

　　（4）测试代码

public void testQuickStart () {
　ApplicationContext ctx=new
　FileSystemXmlApplicationContext ("bean.xml");
　Action a= (Action) ctx.getBean ("TheAction");
　System.out.println (a. execute ("Rod Johnson"));
}

　　上面的测试代码中，我们根据"bean.xml"创建了一个ApplicationContext实例，并从此实例中获取我们所需的Action实现，运行测试代码，我们看到控制台输出：

……
HELLO ROD JOHNSON

　　仔细观察一下上面的代码，可以看到：

　　（1）我们的组件并不需要实现框架指定的接口，因此可以轻松的将组件从Spring中脱离，甚至不需要任何修改，这在基于EJB框架实现的应用中是难以想象的。

　　（2）组件间的依赖关系减少，极大改善了代码的可重用性。Spring的依赖注入机制，可以在运行期为组件配置所需资源，而无需在编写组件代码时就加以指定，从而在相当程度上降低了组件之间的耦合。

　　Spring给我们带来了如此这般的好处，那么，反过来，让我们试想一下，如果不使用Spring框架，回到我们传统的编码模式，情况会是怎样呢？

　　首先，我们必须编写一个配置文件读取类，以实现Message属性的可配置化。

　　其次，得有一个Factory模式的实现，并结合配置文件的读写完成Action的动态加载。于是，我们实现了一个ActionFactory来实现这个功能：

public class ActionFactory {
　public static Action getAction (String actionName) {Properties pro = new Properties ();
　try {
　　pro.load (new FileInputStream ("config.properties"));
　　String actionImplName =(String)pro.get(actionName);
　　String actionMessage =(String) pro.get (actionName+"_msg");
　　Object obj =Class.forName (actionImplName).newInstance ();
　　BeanUtils.setProperty(obj,"message",actionMessage);
　　return (Action) obj;
　} catch (FileNotFoundException e) {
　　……
　}
}

　　配置文件则采用properties文件形式如下所示：

TheAction=net.chen.spring.qs.UpperAction
TheAction_msg=HeLLo

　　测试代码也作相应修改。现在不论实现的好坏，总之通过上面新增的多行代码，终于实现了类似的功能。如果现在有了一个新的需求，这样这个ActionFactory每次都新建一个类的实例，显然这对系统性能不利，考虑到我们的两个Action都是线程安全的，修改一下ActionFactory，保持系统中只有一个Action实例供其它线程调用。另外Action对象创建后，需要做一些初始化工作。修改一下ActionFactory，使其在创建Action实例之后，随即就调用Action.init方法执行初始化。Action的处理这样就差不多了。下面我们来看看另外一个Factory

　　……

　　往往这些系统开发中最常见的需求，会导致我们的代码迅速膨胀，而Spring IoC的出现，则大大缓解了这样的窘境。通过以上实例，可以看出，Spring IoC为我们提供了如下几方面的优势：

　　（1）应用组件不需要在运行时寻找其协作者，因此更易于开发和编写应用；

　　（2）由于借助于IoC容器管理组件的依赖关系，使得应用的单元测试和集成测试更利于展开；

　　（3）通常，在借助于IoC容器关系业务对象的前提下，很少需要使用具体IoC容器提供的API，这使得集成现有的遗留应用成为可能。

　　因此，通过使用IoC能够降低组件之间的耦合度，最终，能够提高类的重用性，利于测试，而且更利于整个产品或系统集成和配置。

々上善若水々 2007-12-31 21:40 发表评论

spring中如何加载多个配置文件

々上善若水々 — Wed, 26 Dec 2007 00:04:00 GMT

Spring加载多个配置文件的方式

1.第一种，使用数组
代码

ApplicationContext contex=new ClassXmlApplicationContext(new String["a1.xml","a2.xml"]);

2.第二种，只用通配符
代码

ApplicationContext contex=new ClassXmlApplicationContext("a*.xml");

//但此种方法只对文件系统中的xml文件有效，针对jar包中的无效

3.第三种，引入
代码

ApplicationContext contex=new ClassXmlApplicationContext("a1.xml");

//在a1.xml中

<import resource="a2.xml"/>//

执行resource路径为相对a1.xml的路径

々上善若水々 2007-12-26 08:04 发表评论

Spring AOP学习体会

々上善若水々 — Sun, 02 Dec 2007 01:03:00 GMT

需明确的几个概念:

1、通知(Advice)：用于告知系统将有哪些新的行为。
2、切入点(Pointcut):定义了通知应该在应用到那些连接点
3、目标对象(Target)：被通知的对象。
4、代理(Proxy)：将通知应用到目标对象后创建的对象。

Spring有两种代理创建方式：

1.如果目标对象实现了一个或多个接口暴露的方法，Spring将使用JDK的java.lang.reflect.Proxy创建代理。这个类让Spring动态产生一个新的类，它实现了所需的接口，织入了通知，并且代理目标的所有请求。（这篇主要介绍这个方式）

2.如果目标对象没有实现任何接口，Spring使用CGLIB库生成目标对象的子类。在创建这个子类的时候，Spring将通知织入，并且将对目标对象的调用委托给这个子类。

下面以一个实例说明Spring AOP的基本开发方法：

一．创建通知

Spring连接点模型是建立在方法拦截上，这意味着你编写的Spring通知会在方法调用周围的各个地方织入系统中。

图1

TestAopServiceAdvice实现了接口MethodBeforeAdvice(前置通知)，并实现它的惟一的方法before，这个类就可以在调用目标对象前被调用。同样的还有AfterReturningAdvice(后置通知)，MethodInterceptor(环绕通知)，异常通知(ThrowsAdvice)，引入通知等。

在这个方法中我们输出了一个字符串TestAopServiceAdvice，用于验证这个方法是否在目标对象前调用了。

注意：我们无法改变before方法中的参数args和target中的值，args中存的是原来要传入目标对象的变量，target即指目标对象。

二．配置Spring XML配置文件

要在Spring中实现AOP，一般情况下需要配置4个bean：

1．目标对象（target）

2．通知(advice)

3．切入点(pointcut)

4．代理(proxy)

图2

切入点又分为静态切入点和动态切入点
1、静态切入点的意思是通知总是被执行,也是最常用的一种切入点。
2、动态切入点根据运行时方法的参数值决定通知是否被执行。

在图2中，定义了使用了一个Spring提供的静态切入点

NameMatchMethodPointAdvisor，它保证了当被调用的方法的名字与给出的映射名字相匹配的时候，这个切入点才匹配。

Spring提供的另一个静态切入点为RegexpMethodPointcutAdvisor，让你可以利用正则表达式来定义切入点.

使用ProxyBeanFactory可以创建一个被通知的类，即代理对象。它的最常用的二个控制行为的属性是:
1、proxyInterfaces：代理应该实现的接口列表
2、interceptorNames：需要应用到目标对象上的通知Bean的名字。可以是拦截器、Advisor或其他通知类的名字。

注：在用容器的getBean方法时，应该是getBean(代理类的名字)，而不是getBean(目标对象的名字)，否则AOP无法工作。

々上善若水々 2007-12-02 09:03 发表评论

Spring中bean的作用域

々上善若水々 — Sat, 24 Nov 2007 00:55:00 GMT

如何使用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"/>
或者<beanid="role" class="spring.chapter2.maryGame.Role" singleton="false"/> 3、request    request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效。request、session、global session使用的时候首先要在web.xml中做如下配置：
     如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：

<web-app>
  ...
  <listener>
<listener-class>org.springframework.web.context.request.RequestContextListenerlistener-class>
  listener>
  ...
web-app>

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

<web-app>
..
<filter>
    <filter-name>requestContextFilterfilter-name>
    <filter-class>org.springframework.web.filter.RequestContextFilterfilter-class>
filter>
<filter-mapping>
    <filter-name>requestContextFilterfilter-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在表示一个线程中有效，代码如下：

publicclass MyScope implements Scope {
     privatefinal ThreadLocal threadScope = new ThreadLocal() {
          protected Object initialValue(){
            returnnew HashMap();
          }
    };
     public Object get(String name, ObjectFactory objectFactory) {
        Map scope = (Map) threadScope.get();
        Object object = scope.get(name);
        if(object==null){
          object = objectFactory.getObject();
          scope.put(name, object);
        }
        return object;
     }
     public Object remove(String name){
        Map scope = (Map) threadScope.get();
        return scope.remove(name);
     }
     publicvoid registerDestructionCallback(String name, Runnable callback) {
     }
    public String getConversationId() {
       // TODO Auto-generated method stub
       returnnull;
    }
          }

々上善若水々 2007-11-24 08:55 发表评论