springMvc与struts2

先说点springmvc学习的事，高手跳过这个-->>> 
1.spring mvc的入门,不要google什么demo了，官方的这个肯定是最好的 
http://blog.springsource.com/2011/01/04/green-beans-getting-started-with-spring-mvc/ 
2.推荐两篇好文，只看spring reference貌似要深入点还是有难度的 
深入实战看这个http://elf8848.iteye.com/blog/875830 
源码看这个http://huibin.iteye.com/blog/618910 


正题： 
使用struts2已经这么久了，但springmvc一直是看过，没实战过，顺着mvc的模式对比对比两者，想从以下几个方面来聊下他们的区别 

1.拦截起角度 
请求拦截处理都是chain方式，使用起来如何呢？ 
入口一个是fiter，一个是servelt，每个请求进行chain处理，实现方式不太一样，效果类似 
struts2 
有一个钩子参数hook-->>ActionInvocation 

Java代码  

1. public interface Interceptor extends Serializable {    
2.     
3.     /**  
4.      * Called to let an interceptor clean up any resources it has allocated.  
5.      */    
6.     void destroy();    
7.     
8.     /**  
9.      * Called after an interceptor is created, but before any requests are processed using  
10.      * {@link #intercept(com.opensymphony.xwork2.ActionInvocation) intercept} , giving  
11.      * the Interceptor a chance to initialize any needed resources.  
12.      */    
13.     void init();    
14.     
15.     /**  
16.      * Allows the Interceptor to do some processing on the request before and/or after the rest of the processing of the  
17.      * request by the {@link ActionInvocation} or to short-circuit the processing and just return a String return code.  
18.      *  
19.      * @return the return code, either returned from {@link ActionInvocation#invoke()}, or from the interceptor itself.  
20.      * @throws Exception any system-level error, as defined in {@link com.opensymphony.xwork2.Action#execute()}.  
21.      */    
22.     String intercept(ActionInvocation invocation) throws Exception;    
23. }    

spring则划分成了三个方法，就需要分别调用，但却没有一个hook方式 

Java代码  

1. // 这里取出执行链中的 Interceptor进行前处理     
2.              if  (mappedHandler.getInterceptors() !=  null ) {     
3.                  for  ( int  i =  0 ; i < mappedHandler.getInterceptors().length; i++) {     
4.                     HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];     
5.                      if  (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {     
6.                         triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response,  null );     
7.                          return ;     
8.                     }     
9.                     interceptorIndex = i;     
10.                 }     
11.             }     
12.     
13.              //在执行handler之前，用 HandlerAdapter先检查一下handler的合法性：是不是按Spring的要求编写的。     
14.             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());     
15.             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());     
16.     
17.              // 这里取出执行链中的 Interceptor进行后处理     
18.              if  (mappedHandler.getInterceptors() !=  null ) {     
19.                  for  ( int  i = mappedHandler.getInterceptors().length -  1 ; i >=  0 ; i--) {     
20.                     HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];     
21.                     interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);     
22.                 }     
23.             }     
24.         }      

配置的角度： 
strus2有package划分，具体类来划分，配置intercepter，还可以有拦截器栈，并且有hook存在，可以调用action上面的信息，这个就可以做到根据action配置的注解之类的进行一些处理 

spring配置根据具体处理控制器，或者根据路径来，需要划分清晰的path 
这个struts2实用性要比spring好，但struts2的效果spring也是可以的 

2.参数处理角度 
http的string类型转换成java类型  
java类型在处理成具体业务类 
两次转换都有些小细节，好听点叫阻抗不匹配，struts2的方式有点重，特殊如类型转换modelDriver方式可以选择，可以做点特殊处理，但比起spring的灵活性，差很多 

spring可以选在通过注解注入特定参数，比较繁琐一点，也可以选择strus2的方式，不配置就是自动注入，签名的session级别的处理很好，让sesssion很清晰 
这点我觉得spring比struts2好，具体可以参见资料http://www.ibm.com/developerworks/cn/java/j-lo-spring25-mvc/ 

3.视图处理角度 
struts2 valuestack以及配套的OGNL很强大，但jstl貌似是主流，ognl附带的调用什么方法，view层总觉得被破坏了
spring通过model方式也是不错，非常灵活，要呈现的东西放入model，只不过需要定义好一些起名字的规则，不象struts2,具体参数是在action里面的 

4.异常处理角度 
spring的异常可以自己配置，也可以实用他的那个类似<global-exception-mappings> 的东东，也可以有自己写自己的异常处理类 
分为全局异常和包异常处理，但是不需要实现框架什么接口，spring则需要实现HandlerExceptionResolver如下 

Java代码  

1. // 这里catch住controller抛出的异常，使用持有的ExceptionResolver处理，当没有配置自己的处理器时，程序会将异常继续往上抛出，最终交给我们的容器处理    
2.             catch (Exception ex) {    
3.                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);    
4.                 mv = processHandlerException(processedRequest, response, handler, ex);    
5.                 errorView = (mv != null);    
6.             }    
7.   
8.         }    
9. // 当没有配置ExceptionResolver时，异常将到达这里，最终抛出    
10.         catch (Exception ex) {    
11.             // Trigger after-completion for thrown exception.    
12.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);    
13.             throw ex;    
14.         }    
15.         catch (Error err) {    
16.             ServletException ex = new NestedServletException("Handler processing failed", err);    
17.             // Trigger after-completion for thrown exception.    
18.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);    
19.             throw ex;    
20.         }    

Java代码  

1. //异常将会轮流来处理这个  
2. protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,  
3.             Object handler, Exception ex) throws Exception {  
4.   
5.         // Check registered HandlerExceptionResolvers...  
6.         ModelAndView exMv = null;  
7.         for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {  
8.             exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);  
9.             if (exMv != null) {  
10.                 break;  
11.             }  
12.         }  

struts2不能获取独特信息，只能搞个异常处理类来配置，但是strusts2的拦截起却给了获取处理流程信息，做异常处理的可能 


4.跟spring框架的融合 
springMvc与spring一家人，虽然spring是百搭风范 
具体：spring test很爽，可以测试action 
struts2通过插件来整合，具体哪里不如springmvc暂时没发现 
  
6.闲扯--特殊需求扩展满足如何，热门restful跟的如何？ 
struts2有插件可以做restful，这也说明strus2的插件可以做到一些特殊的事情，spring也可以支持restful方式，虽然我们现在做的是互联网项目，还是没转restful，两点，理解不够，转变困难，观望学习中