spring webwork 集成 三种方法

1.External-Ref

这种方法看起来比较烦琐,(这里描述的和spring文档里的有些区别,这种方法可按spring文档里的做法)

第一步:在web.xml里面增加一个listener,如下

xml 代码
  1. < listener >     
  2.          < listener-class > org.springframework.web.context.ContextLoaderListener </ listener-class >     
  3. </ listener >     
  4.   
  5. < listener >     
  6.          < listener-class > com.opensymphony.xwork.spring.SpringExternalReferenceResolverSetupListener </ listener-class >     
  7. </ listener >   

第二步:在Spring里面配置类似Dao之类的bean,例如 

xml 代码
  1. < bean   id = "myDAO"   class = "com.ryandaigle.persistence.MyDAO"   singleton = "true"   />   

第三步:配置XWork.xml,例如

xml 代码
  1. < package   name = "default"   extends = "webwork-default"     
  2.          externalReferenceResolver = "com.opensymphony.xwork.spring.SpringExternalReferenceResolver" >
  3.          < interceptors >     
  4.                  < interceptor   name = "reference-resolver"   class = "com.opensymphony.xwork.interceptor.ExternalReferencesInterceptor" />     
  5.                  < interceptor-stack   name = "myDefaultWebStack" >     
  6.                          < interceptor-ref   name = "defaultStack" />     
  7.                          < interceptor-ref   name = "reference-resolver" />     
  8.                  </ interceptor-stack >     
  9.          </ interceptors >     
  10.            
  11.          < default-interceptor-ref   name = "myDefaultWebStack" />     
  12.            
  13.          < action   name = "myAction"   class = "com.ryandaigle.web.actions.MyAction" >     
  14.                  < external-ref   name = "DAO" > myDAO </ external-ref >     
  15.                  < result   name = "success"   type = "dispatcher" >     
  16.                          < param   name = "location" > /success.jsp </ param >     
  17.                  </ result >     
  18.          </ action >                     
  19. </ package >    


2.SpringObjectFactory


我一直用这种方法,因为以前觉得是xwork本身提供的方法,升级有保障.

配置方法:
第一步.在spring的 applicationContext.xml (根据实际情况决定) 里面定义你的action,例如 

xml 代码
  1. < bean   name = "some-action"   class = "fully.qualified.class.name"   singleton = "false" >     
  2.      < property   name = "someProperty" > < ref   bean = "someOtherBean" /> </ property >     
  3. </ bean >    

可以看到,可以使用Spring的特性来给你的action设置属性等,当然也可以使用Spring的拦截器等 (可以使用不一定等于推荐使用)

注意一定是singleton="false",因为xwork的action是这样要求的.

第二步.在xwork.xml里定义你的action定义 

xml 代码
  1. < action   name = "myAction"   class = "some-action" >     
  2.      < result   name = "success" > view.jsp </ result >     
  3. </ action >    

 第三步.要使上面的关联生效,还要用我们的SpringObjectFactory来替换Xwork的默认ObjectFactory.
最新的SpringObjectFactory里面,有两种方法,其中我觉得A方法更直观一些.

A:修改web.xml

xml 代码
  1. <!-- 这个是spring的listener,可以改为你的自定义的spring的Listenter -->     
  2. < listener >     
  3.          < listener-class > org.springframework.web.context.ContextLoaderListener </ listener-class >     
  4. </ listener >     
  5.   
  6.   
  7. <!-- 这个必须在 Spring ContextLoaderListener 的后面 -->     
  8. < listener >     
  9.    < listener-class > com.opensymphony.xwork.spring.SpringObjectFactoryListener </ listener-class >     
  10. </ listener >   

 B.在spring的applicationContext.xml (根据实际情况决定)里面定义一个bean,例如 

xml 代码
  1. < bean   id = "spring-object-factory"   class = "com.opensymphony.xwork.spring.SpringObjectFactory"     
  2.          init-method = "initObjectFactory" />   

这样Spring会自动调用initObjectFactory方法来替换Xwork的默认ObjectFactory

3.ActionAutowiringInterceptor


这个方法是最近出现的,可能是最简洁的方法,但是不知道性能上有没有问题,我觉得jdk1.4以后应该没有任何问题吧,至于实际效果你的自己测试一下.

第一步:配置web.xml 

xml 代码
  1. <!-- 这个是spring的listener,可以改为你的自定义的spring的Listenter -->     
  2. < listener >      
  3.      < listener-class > org.springframework.web.context.ContextLoaderListener </ listener-class >     
  4. </ listener >     

       
 第二步配置xwork.xml里面的拦截器

xml 代码
  1. < interceptors >     
  2.    < interceptor   name = "autowire"   class = "com.opensymphony.xwork.spring.interceptor.ActionAutowiringInterceptor" >     
  3.      < param   name = "autowireStrategy" > @org.springframework.beans.factory.config.AutowireCapableBeanFactory@AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE </ param >     
  4.    </ interceptor >     
  5.    < interceptor-stack   name = "autowireDefault" >     
  6.      < interceptor-ref interceptor-ref = "autowire"   />     
  7.      < interceptor-ref interceptor-ref = "defaultStack"   />     
  8.    </ interceptor-stack >     
  9. </ interceptors >    

                你的拦截器里都要包含autowire,例如这个autowireDefault就相当于以前的默认的拦截器了.
其中的拦截器策略可以配置,上面配置的是根据类型,如果不配置,默认是根据名字.

一共有四种策略:
AUTOWIRE_CONSTRUCTOR
AUTOWIRE_BY_TYPE
AUTOWIRE_BY_NAME
AUTOWIRE_AUTODETECT

这种方法执行原理就是查找你的action的所有字段,如果和Spring的定义bean有相同的,就自动设置.

假设你的Spring的applicationContext.xml里面有这样一个定义:

xml 代码
  1. < bean   id = "userManager"   class = "com.test.UserManager"   />    

 如果你在xwork.xml 里面定义的某个action有一个字段叫userManager,那么在运行时刻就会自动被设置为Spring的配置文件里定义的Bean.

posted on 2010-04-12 14:23 飞熊 阅读(237) 评论(0)  编辑  收藏 所属分类: struts2.0


只有注册用户登录后才能发表评论。


网站导航:
 
<2010年4月>
28293031123
45678910
11121314151617
18192021222324
2526272829301
2345678

导航

统计

常用链接

留言簿(1)

随笔分类

随笔档案

文章分类

文章档案

收藏夹

搜索

最新评论

阅读排行榜

评论排行榜