BlogJava-即兴的灵感-随笔分类-Spring

偶遇Spring MVC

improviser — Sun, 04 Nov 2007 02:44:00 GMT

    个人认为Spring其核心是其IOC和AOP方面，对其SpirngMVC框架并不关注，我看好的是JSF，简单易懂。但最近由于工作上需要，所以有需要对SpringMVC做个了解学习，因此，本次对SpirngMVC的相遇纯属偶遇....
    SpingMVC的架构其实也很简单，它通过一个共通的入门DispatcherServlet来接收所有的request，接下来根据request要求的页面通过handler转送给Controller处理，处理结果返回View给用户，因此对SpringMVC来说，其核心为DispatcherServlet。
    DispatcherServlet作为一扇门，我们要使用这个门，首先得安装上这个门，安装在哪呢？没错，就安装在web.xml这个大屋子，象其他servlet一样，描述servlet的名字和类，再给他一个mapping描述对应映射的网页。在下例中，我们给DispatcherServlet的起名为SpringMVCDemo，并让container知道所有.do结尾的request都丟给dispatcher。

     < servlet >
         < servlet-name > SpringMVCDemo servlet-name >
         < servlet-class >
            org.springframework.web.servlet.DispatcherServlet
         servlet-class >
         < load-on-startup > 1 load-on-startup >
     servlet >

     < servlet-mapping >
         < servlet-name > SpringMVCDemo servlet-name >
         < url-pattern > *.do url-pattern >
     servlet-mapping >

门安装好了之后，我们需要定义门能打开的范围，在哪定义呢？就在门的上面贴上一张“入门指导”，介绍从哪方面(hello.do)进门需要使用何种交通方式(springmvcController)进去，并定义该交通方式。

     < bean id ="urlMapping"
        class ="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" >
         < property name ="mappings" >
             < props >
                 < prop key ="/hello.do" > springmvcController prop >
             props >
         property >
     bean >


     < bean id ="springmvcController"
        class ="org.improviser.webapp.controller.SpringmvcController" >
     bean >

接下来该渲染一下页面了，下面为渲染所有以 WEB-INF/pages/ 开头，并以.jsp结尾的页面。

     < bean id ="viewResolver"
        class ="org.springframework.web.servlet.view.InternalResourceViewResolver" >
         < property name ="viewClass" >
             < value > org.springframework.web.servlet.view.JstlView value >
         property >
         < property name ="prefix" >
             < value > /WEB-INF/pages/ value >
         property >
         < property name ="suffix" >
             < value > .jsp value >
         property >
     bean >

上面提到的SpringmvcController，现在该作个定义了，该类需要实现Controller接口。

public class SpringmvcController implements Controller {
    /** Logger for this class and subclasses */
    protected final Log logger = LogFactory.getLog(getClass());

    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws ServletException, IOException {

        Map model = new HashMap();

        String str = "即兴诗人";
        logger.info("returning hello view with " + currTime);
        model.put("coldice", str);

        return new ModelAndView("hello", "message", model);
    }

编写jsp测试页面。

<html>
    <head>
        <title>Spring Applicationtitle>
    head>
    <body>
        <h1>
            <br />
            Hello
            <c:out value="${message.coldice}" />

            Spring MVC 测试成功！
        h1>
    body>
html>

现在对以上内容作个总结，正如上面所叙述，SpringMVC框架的处理过程机制如下图所示，接收请求页面，通过DispatcherServlet映射到相应规则处理，并找到相应的控制器，结果控制器处理后返回相应的页面最后返回给用户。

improviser 2007-11-04 10:44 发表评论

Spring笔记之十（Spring研读总结）

improviser — Sat, 29 Sep 2007 02:07:00 GMT

   通过这几天对Spring的研读，剖析了Spring的基本核心模块——IoC和AOP。今天将对其作个基础性的总结。

     Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式,同时为 J2EE 应用程序开发提供集成的框架。其中作为Spring的核心模块即是Spring面向方面编程(AOP)和控制反转(IOC)容器。Spring 设计的核心是 org.springframework.beans 包，BeanFactoryBeanFactory 支持两个对象模型单态和原型。BeanFactory是Spring作为IOC 容器的基础。

控制反转模式：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器）负责将这些联系在一起。在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。IOC 的一个实现模式:通过接口、通过 JavaBean 的属性、依赖性以构造函数的形式提供。

    面向方面的编程，即 AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。当然，优势就是 Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用 Spring AOP 编写的应用程序代码是松散耦合的。AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中。

improviser 2007-09-29 10:07 发表评论

Spring笔记之九（AOP in Spring）

improviser — Fri, 28 Sep 2007 17:50:00 GMT

Spring IoC和 Spring AOP组合，一起形成了Spring，这样一个有机整体，使得构建轻量级的J2EE架构成为可能，而且事实证明，非常有效。没有Spring IoC的Spring AOP是不完善的，没有Spring AOP的Spring IoC是不健壮的。本文研究Spring框架中的面向方面编(Aspect-Oriented Programming，AOP)，进而通过例子解析如何运用Spring中的所有通知类型和切入点来实现更实用的方面和面向方面设计模式。

    AOP概念：
    Advice：如何将before通知、afterReturning通知和afterThrowing通知声明为bean。
　Pointcut：如何声明静态切入点逻辑以将XML Spring Bean Configuration文件中的所有内容联系在一起。
　Advisor：关联切入点定义与通知bean的方式。

    Spring AOP是使用代理来完成的，Spring 两种方式：JDK动态代理，需要设定一组代理接口；CGLIB 代理，可代理接口和类。Spring提供了5种Advice类型：Interception Around、Before、After Returning、Throw和Introduction。它们分别在以下情况下被调用：在JointPoint前后、JointPoint前、 JointPoint后、JointPoint抛出异常时、JointPoint调用完毕后。

配置文件：

1 <beans>
2     <bean id="myAOPProxy"
             class="org.springframework.aop.framework.ProxyFactoryBean">
3         <property name="proxyInterfaces">
4             <value>ITestvalue>
5         property>
6         <property name="target">
7             <ref local = "test"/>
8         property>
9         <property name="interceptorNames">
10             <value>myPotincutAdvisorvalue>
11         property>
12     bean>
13
14     <bean id="test" class="Test"/>
15
16     <bean id="MyInterceptor" class="MethodTimeCostInterceptor"/>
17
18     <bean id="myPotincutAdvisor"
             class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
19         <property name="advice">
20             <ref local="MyInterceptor"/>
21         property>
22         <property name="patterns">
23             <list>
24                 <value>.*value>
25                 <value>.*value>
26             list>
27         property>
28     bean>
29 beans>

分析代码：
1、<bean id="myAOPProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">声明注入了代理实例myAOPProxy。
2、 proxyInterfaces声明将被代理接口ITest。
3、 target声明被代理目的类。
4、 interceptorNames设置拦截器为myPotincutAdvisor。
5、 patterns为拦截器设置配匹方式，即在所被配匹成功的方法被调用时执行拦截器内容。

该配置文件，指定要加载一个接口与ITest相匹配的bean。该bean随后被关联到Test实现类。看起来好像是费了很大力气只为了加载一个简单的bean并调用一个方法，但是这个配置文件只是使 Spring框架可以透明地对应用程序应用其组件的众多特性的一个体现。

improviser 2007-09-29 01:50 发表评论

Spring笔记之八（Internationalization of spring）

improviser — Wed, 26 Sep 2007 17:00:00 GMT

    国际化支持在实际开发中可能是最常用的特性，本文分析Spring的 ApplicationContext 提供国际化支持，其提供了更加强大的功能，如信息的自动装配以及热部署功能（配置文件修改后自动读取，而无需重新启动应用程序）。
    目前Spring中提供了两个 MessageSource接口的实现，即ResourceBundleMessageSource和ReloadableResourceBundleMessageSource，后者提供了无需重启即可重新加载配置信息的特性。

    在下面的配置文件中，通过MessageResource的一个实现类org.springframework.context.support.ResourceBundleMessageSource来获得国际化的信息。

1 <beans>
2 <description>Spring Quick Startdescription>
3 <bean id="messageSource"
class="org.springframework.context.support.ResourceBundleMessageSource">
4 <property name="basenames">
5 <list>
6 <value>messagesvalue>
7 list>
8 property>
9 bean>
10 beans>
11

这里声明了一个名为 messageSource 的Bean（ 注意： 对于Message定义，Bean ID必须为messageSource，这是目前Spring的编码规约），对应类为ResourceBundleMessageSource。

而其中的basename属性用來设定资源信息文件的前置文件名称，在本例中为messages。Spring会自动在CLASSPATH根路径中按照如下顺序搜寻资源信息文件并进行加载（以Locale为zh_CN为例，其实Spring在实际上调用了JDK的ResourceBundle读取配置文件） :

messages_zh_CN.properties

messages_zh.properties

messages.properties

messages_zh_CN.class

messages_zh.class

messages.class

资源配置信息文件中的内容

1 messages_zh_CN.properties：
2 userinfo=当前登录用户: [{0}] 登录时间:[{1}]
3 messages_en_US.properties：
4 userinfo=Current Login user: [{0}] Login time:[{1}]
5

测试代码：

1 ApplicationContext ctx =
new FileSystemXmlApplicationContext("bean.xml");
2 Object[] arg = new Object[]
3 { "Erica", Calendar.getInstance().getTime()
4 };
5 //以系统默认Locale加载信息(对于中文WinXP而言，默认为zh_CN)
6 String msg = ctx.getMessage("userinfo", arg);
7 System.out.println("Message is ===> "+msg);
8

代码中，我们将一个Object数组arg作为参数传递给ApplicationContext.getMessage方法，这个参数中包含了出现在最终文字信息中的可变内容，ApplicationContext 将根据参数中的Locale信息对其进行处理（如针对不同 Locale设定日期输出格式），并用其替换配置文件中的{n}标识（n代表参数数组中的索引，从1 开始）。

运行上面的代码，得到以下输出的内容：
Message is ===> |ì〃¤?°|ì???¨???〃: [Erica] |ì???¨o〃¤??:[07-9-27 上午1:27]

针对ResourceBundle的编码过程中发生的问题。这是由于转码过程中产生的编码问题引发的。比较简单的解决办法是通过JDK提供的转码工具native2ascii.exe 进行转换。执行：native2ascii messages_zh_CN.properties msg.txt。再用msg.txt文件替换Messages_zh_CN.properties 文件。

再次运行示例代码，得到正确输出：

Message is ===> 当前登录用户: [Erica] 登录时间:[07-9-27 上午1:30]

尝试在代码中指定不同的Locale参数：

String msg = ctx.getMessage("userinfo", arg, Locale.US);再次运行，可以看到：

Message is ===> Current Login user: [Erica] Login time::[9/27/07 1:35AM]

可见，前者根据当前默认Locale"zh_CN"，getMessage方法自动加载了messages_zh_CN.properties文件；后者getMessage方法根据指定编码"en_US"加载了messages_en_US.properties文件。

improviser 2007-09-27 01:00 发表评论

Spring笔记之七（Types of Injection）

improviser — Wed, 26 Sep 2007 15:59:00 GMT

本文研究Spring的三种依赖注入实现类型——接口注入（Interface Injection）、设值注入（Setter Injection）、构造子注入（Constructor Injection）。

Type1 接口注入： 传统的创建接口对象的方法，借助接口来将调用者与实现者分离。如下面的代码所示：

1 public class ClassA
2 {
3 private InterfaceB clzB;
4 public doSomething()
5 {
6 Ojbect obj = Class.forName(Config.BImplementation).newInstance();
7 clzB = (InterfaceB)obj;
8 clzB.doIt();
9 }
10 ……
11 }
12

在代码中创建InterfaceB实现类的实例，并将该对象赋予clzB。也就是依据Java中的对象动态多态技术：InterfaceB clzB=new InterfaceBImpleClass();为了将调用者与实现者在编译期分离，于是有了上面的代码，我们根据预先在配置文件中设定的实现类的类名(Config.BImplementation)，动态加载实现类，并通过InterfaceB强制转型后为 ClassA所用。

Type2 设值注入： 在各种类型的依赖注入模式中，设值注入模式在实际开发中得到了最广泛的应用（其中很大一部分得力于Spring框架的
影响）。使用IoC的Setter注射，一些外部元数据被用于解决依赖性问题。并且在Spring中，这种元数据采取了简单的XML配置文件的形式。

下面为某个类的示例代码
(其中包含有一个message属性，该类通过其setMessage()方法获得右容器所提供的值。)

1 public class UpperAction  implements Action
2 {
3   private String message;
4   public String getMessage()
5   {
6     return message;
7   }
8   public void setMessage(String string)
9   {
10     message = string;
11   }
12 }
13

其中message 属性的值通过配置文件来提供

1 <bean id="theUpperAction"  class="springj2seapp.UpperAction">
2      <property name="message">
3         <value>HeLLo,UpperAction value>
4     property>
5 bean>
6

Type3 构造子注入： 在Type3类型的依赖注入机制中，依赖关系是通过类构造函数建立，容器通过调用类的构造方法，将其所需的依赖关系注入其中。

示例代码：
配置文件如下
1 <bean id="exampleBean" class="examples.ExampleBean">
2
3   <constructor-arg>
4
5 <ref bean="anotherExampleBean"/>
6 constructor-arg>
7   <constructor-arg><ref bean="yetAnotherBean"/>constructor-arg>
8   <constructor-arg type="int">
9 <value>1value>
10 constructor-arg>
11 bean>
12 <bean id="anotherExampleBean" class="examples.AnotherBean"/>
13 <bean id="yetAnotherBean" class="examples.YetAnotherBean"/>
14

ExampleBean代码：

1 public class ExampleBean
2 {
3     private AnotherBean beanOne;
4     private YetAnotherBean beanTwo;
5     private int i;
6     public ExampleBean(AnotherBean anotherBean, YetAnotherBean yetAnotherBean,
                                                                    int i)
7 {
8         this.beanOne = anotherBean;
9         this.beanTwo = yetAnotherBean;
10         this.i = i;
11     }
12 }
13

当构造方法中带多个不同的基本数据类型的参数时，为了避免产生二义性，可以采用type或者index来指定构造方法的参数的类型和顺序。
如：
type方法

1 <constructor-arg type="int">
2 <value>7500000value>
3 constructor-arg>
4 <constructor-arg type="java.lang.String">
5 <value>42value>
6 constructor-arg>
7

index方法

1 <bean id="exampleBean" class="examples.ExampleBean">
2 <constructor-arg index="0">
3 <value>7500000value>
4 constructor-arg>
5 <constructor-arg index="1">
6 <value>42value>
7 constructor-arg>
8 bean>
9

总结：
type1在灵活性、易用性上不如其他两种注入模式， Type2 和Type3型的依赖注入实现则是目前主流的IOC实现模式， Type3 和Type2模式各有千秋，而Spring都对Type3和Type2类型的依赖注入机制提供了良好支持。以Type3类型为主，辅之以Type2类型机制作为补充，可以达到最好的依赖注入效果，不过对于基于Spring Framework开发的应用而言，Type2使用更加广泛。

improviser 2007-09-26 23:59 发表评论

Spring笔记之六（IoC Singleton）

improviser — Wed, 26 Sep 2007 05:22:00 GMT

Spring中BeanFactory支持两个对象模型

单态： 模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。

原型： 模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。

实例：

1  <  beans  >
2
3
4      <bean id="nonSingleton" class="java.lang.String" singleton="true">
5          <constructor-arg>
6               <value>Valuevalue>
7          constructor-arg>
8       bean>
9
10  beans>
11
12 singleton：指定此JavaBean是否采用单例（Singleton）模式，如果设为"true"，则在BeanFactory作用范围内，只维护此JavaBean  的一个实例，代码通过BeanFactory   获得此JavaBean  实例的引用。反之，如果设为"false"，则通过BeanFactory获取此Java Bean  实例时，BeanFactory每次都将创建一个新的实例返回。

     1 public class NonSingleton {
2
3 public static void main(String[] args) {
4
5 BeanFactory factory = new XmlBeanFactory(new FileSystemResource(
6                     "build/beans.xml"));
7
8    String s1 = (String)factory.getBean("nonSingleton");
9    String s2 = (String)factory.getBean("nonSingleton");
10    System.out.println("Identity Equal?: " + (s1 ==s2));
11    System.out.println("Value Equal:? " + s1.equals(s2));
12    System.out.println(s1);
13    System.out.println(s2);
14  }
15 }

分析结果：

Identity Equal?: true
Value Equal:? true
Value
Value

由结果可以看出由fantory产生的bean对象只有一个。

注意： 在Spring中消除了由用户自己来实现Singleton模式的应用，Spring Bean的缺省行为就是Singleton，不必再为了Singleton编码。

improviser 2007-09-26 13:22 发表评论

Spring笔记之五（Hierarchical Bean Factory Usage）

improviser — Mon, 24 Sep 2007 16:05:00 GMT

本文研究Spring分层Bean Factory用法，先看有关代码：

1 parent.xml
2
3 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
      "http://www.springframework.org/dtd/spring-beans.dtd">
4 <beans>
5     <bean id="injectBean" class="java.lang.String">
6            <constructor-arg>
7                <value>Bean In Parentvalue>
8            constructor-arg>
9     bean>
10     <bean id="injectBeanParent" class="java.lang.String">
11            <constructor-arg>
12                <value>Bean In Parentvalue>
13            constructor-arg>
14     bean>
15 beans>

1 beans.xml
2
3 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
4 <beans>
5
6     <bean id="target1" class="SimpleTarget">
7         <property name="val">
8             <ref bean="injectBeanParent"/>
9         property>
10     bean>
11
12     <bean id="target2" class="SimpleTarget">
13         <property name="val">
14             <ref local="injectBean"/>
15         property>
16     bean>
17
18     <bean id="target3" class="SimpleTarget">
19         <property name="val">
20             <ref parent="injectBean"/>
21         property>
22     bean>
23
24     <bean id="injectBean" class="java.lang.String">
25            <constructor-arg>
26                <value>Bean In Childvalue>
27            constructor-arg>
28     bean>
29 beans>
30

`SimpleTarget中只有一属性String val`

1 public static void main(String[] args) {
2         BeanFactory parent = new XmlBeanFactory(new FileSystemResource(
3                 "build/parent.xml"));
4         BeanFactory child = new XmlBeanFactory(new FileSystemResource(
5                 "build/beans.xml"), parent);
6
7         SimpleTarget target1 = (SimpleTarget) child.getBean("target1");
8         SimpleTarget target2 = (SimpleTarget) child.getBean("target2");
9         SimpleTarget target3 = (SimpleTarget) child.getBean("target3");
10
11         System.out.println(target1.getVal());
12         System.out.println(target2.getVal());
13         System.out.println(target3.getVal());
14     }

运行结果：
Bean In Parent
Bean In Child
Bean In Parent

分析过程：
在bean factory被加载过程中分别加载各层Bean Factory， BeanFactory parent = new XmlBeanFactory(new FileSystemResource("build/parent.xml"));
BeanFactory child = new XmlBeanFactory(new FileSystemResource("build/beans.xml" ), parent);
其中parent参数指定了bean factory间的父子关系。

分析结果：
第一行结果为在父factory中定义的参数，说明在子fantory中可以直接调用父fantory元素，类似于java中的继承关系。
第二行结果说明 < ref local ="injectBean" />中local指向本fantory元素。
第三行结果为Bean In Parent，说明 < ref parent ="injectBean" />中parent指向父fantory中元素。

improviser 2007-09-25 00:05 发表评论

Spring笔记之四（Spring Event）

improviser — Mon, 24 Sep 2007 14:38:00 GMT

摘要: Spring中提供一些Aware相关的接口，BeanFactoryAware、 ApplicationContextAware、ResourceLoaderAware、ServletContextAware等等，其中最常用到的是ApplicationContextAware。实现ApplicationContextAware的Bean，在Bean被初始后，将会被注入 ApplicationContext的实例。ApplicationContextAware提供了publishEvent()方法，实现Observer(观察者)设计模式的事件传播机，提供了针对Bean的事件传播功能。通过Application.publishEvent方法，我们可以将事件通知系统内所有的ApplicationListener。阅读全文

improviser 2007-09-24 22:38 发表评论

Spring笔记之三（Usage of property config）

improviser — Mon, 24 Sep 2007 05:51:00 GMT

摘要: 本文内容演示属性文件用法的简单例子。
首先定义模型接口Model，视图接口View，以及它们实现类ImpModel，ImpView.
Model中定义方法getString();View中定义Model实例为其属性，在实现类ImpView中实现方法
disPlay(),其方法体为Model实例的getString()方法，并将其打印出来。阅读全文

improviser 2007-09-24 13:51 发表评论

Spring笔记之二（Collection Injection）

improviser — Mon, 24 Sep 2007 02:23:00 GMT

摘要: 通过,,以及元素定义和设置与java collection类型对应的List，Set，Map，Rproperties的值。阅读全文

improviser 2007-09-24 10:23 发表评论

Spring笔记之一（初探Spring）

improviser — Sun, 23 Sep 2007 17:31:00 GMT

初探Spring程序，程序如下：

1 BeanNaming.java
2     package spring.beantest;
3
4     import org.springframework.beans.factory.BeanFactory;
5     import org.springframework.beans.factory.xml.XmlBeanFactory;
6     import org.springframework.core.io.FileSystemResource;
7
8     public class BeanNaming {
9     public static void main(String []args)
10     {
11         BeanFactory factory = new XmlBeanFactory(new FileSystemResource("src/applicationContext.xml"));
12
13         String s1 = (String)factory.getBean("name1");
14         String s2 = (String)factory.getBean("name2");
15         String s3 = (String)factory.getBean("name3");
16         String s4 = (String)factory.getBean("name4");
17
18         System.out.println((s1 == s2));
19         System.out.println((s2 == s3));
20         System.out.println((s3 == s4));
21
22         String[] x = factory.getAliases("name3");
23         for(String str:x)
24         {
25             System.out.println(str);
26         }
27
28       }
29     }
30
31       applicationContext.xml
32      xml version="1.0" encoding="UTF-8"?>
33      DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
34      <beans>
35
36      <bean id="name1" name="name2,name3,name4" class="java.lang.String"/>
37      beans>

    输出结果为：
    true
    true
    true
    name1
    name4
    name2

    可以看出，使用中id属性和name属性几乎没有任何区别。调用beanfactory.getAliases(string)的方法时，传入的参数可以是任意一个bean名字，输出的别名则是除去作为参数本身之外的所有 bean名。


   另：在写 applicationContxt.xml文件时，如果没有定义，则会抛出Cannot find the declaration of element 'beans'异常。

      以上使用BeanFactory对配置文件进行加载，BeanFactory，是根据配置文件负责创建Bean的实例，并负责Bean的生命周期的管理- --，包括Bean的生成与销毁、Bean的创建方式的识别（是否为singleton）、Bean的各个属性的设定、依赖关系的建立等。
    ApplicationContext接口，提供了国际化、事件处理及beans在context中的自查能力。它也可创建具有层次结构context环境，将bean的作用域和可访问区域限制在应用程序的一个特定部分中。下面演示如何使用ApplicationContext接口。

1 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-    beans.dtd">
2     <beans>
3     <bean id="bean_1" class="BeanTest"/>
4     <bean id="bean_2" class="BeanTest"/>
5     beans>
6
7
8     public class BeanTest {
9     public void test() {
10         System.out.println("test..");
11     }
12    }
13
14
15    import org.springframework.context.ApplicationContext;
16    import org.springframework.context.support.FileSystemXmlApplicationContext;
17
18    public class BeanNameExample {
19
20     public static void main(String[] args) {
21         ApplicationContext ctx = new FileSystemXmlApplicationContext(
22         "build/applicationContext.xml");
23
24         BeanTest beanOne = (BeanTest)ctx.getBean("bean_1");
25         BeanTest beanTwo = (BeanTest)ctx.getBean("bean_2");
26
27         beanOne.test();
28         beanTwo.test();
29       }
30    }
31

综上，ApplicationContext与BeanFactory的不同点
BeanFactory提供了针对JavaBean的管理功能，而ApplicationContext提供了一个更为框架化的实现（从上面的示例中可以看出，BeanFactory的使用方式更加类似一个API，而非Framework style）。ApplicationContext覆盖了BeanFactory的所有功能，并提供了更多的特性。此外， ApplicationContext为与现有应用框架相整合，提供了更为开放式的实现（如对于Web应用，我们可以在web.xml中对 ApplicationContext进行配置）。

improviser 2007-09-24 01:31 发表评论