webwork与spring集成的三种方法

1.External-Ref

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

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

                 < listener >  
                         < listener-class > org.springframework.web.context.ContextLoaderListener </ listener-class >  
                 </ listener >  
                
                 < listener >  
                         < listener-class > com.opensymphony.xwork.spring.SpringExternalReferenceResolverSetupListener </ listener-class >  
                 </ listener >

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

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

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

                 < package  name ="default"  extends ="webwork-default"  
                        externalReferenceResolver ="com.opensymphony.xwork.spring.SpringExternalReferenceResolver" >                 
                         < interceptors >  
                                 < interceptor  name ="reference-resolver"  class ="com.opensymphony.xwork.interceptor.ExternalReferencesInterceptor" />  
                                 < interceptor-stack  name ="myDefaultWebStack" >  
                                         < interceptor-ref  name ="defaultStack" />  
                                         < interceptor-ref  name ="reference-resolver" />  
                                 </ interceptor-stack >  
                         </ interceptors >  
                        
                         < default-interceptor-ref  name ="myDefaultWebStack" />  
                        
                         < action  name ="myAction"  class ="com.ryandaigle.web.actions.MyAction" >  
                                 < external-ref  name ="DAO" > myDAO </ external-ref >  
                                 < result  name ="success"  type ="dispatcher" >  
                                         < param  name ="location" > /success.jsp </ param >  
                                 </ result >  
                         </ action >                  
                 </ package >  

 

 

2.SpringObjectFactory

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

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

                 < bean  name ="some-action"  class ="fully.qualified.class.name"  singleton ="false" >  
                     < property  name ="someProperty" >< ref  bean ="someOtherBean" /></ property >  
                 </ bean >  

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

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

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

                 < action  name ="myAction"  class ="some-action" >  
                     < result  name ="success" > view.jsp </ result >  
                 </ action >  

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

A:修改web.xml

                             <!--  这个是spring的listener,可以改为你的自定义的spring的Listenter  -->  
                         < listener >  
                                 < listener-class > org.springframework.web.context.ContextLoaderListener </ listener-class >  
                         </ listener >  
                        
                
                         <!--  这个必须在 Spring ContextLoaderListener 的后面  -->  
                         < listener >  
                           < listener-class > com.opensymphony.xwork.spring.SpringObjectFactoryListener </ listener-class >  
                         </ listener >

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

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

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

 

3.ActionAutowiringInterceptor

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

第一步:配置web.xml 

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

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

                 < interceptors >  
                   < interceptor  name ="autowire"  class ="com.opensymphony.xwork.spring.interceptor.ActionAutowiringInterceptor" >  
                     < param  name ="autowireStrategy" > @org.springframework.beans.factory.config.AutowireCapableBeanFactory@AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE </ param >  
                   </ interceptor >  
                   < interceptor-stack  name ="autowireDefault" >  
                     < interceptor-ref ="autowire"   />  
                     < interceptor-ref ="defaultStack"   />  
                   </ interceptor-stack >  
                 </ interceptors >  

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

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

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

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

  < bean  id ="userManager"  class ="com.test.UserManager"   />  

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