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

    public interface Interceptor extends Serializable {  
      
        /** 
         * Called to let an interceptor clean up any resources it has allocated. 
         */  
        void destroy();  
      
        /** 
         * Called after an interceptor is created, but before any requests are processed using 
         * {@link #intercept(com.opensymphony.xwork2.ActionInvocation) intercept} , giving 
         * the Interceptor a chance to initialize any needed resources. 
         */  
        void init();  
      
        /** 
         * Allows the Interceptor to do some processing on the request before and/or after the rest of the processing of the 
         * request by the {@link ActionInvocation} or to short-circuit the processing and just return a String return code. 
         * 
         * @return the return code, either returned from {@link ActionInvocation#invoke()}, or from the interceptor itself. 
         * @throws Exception any system-level error, as defined in {@link com.opensymphony.xwork2.Action#execute()}. 
         */  
        String intercept(ActionInvocation invocation) throws Exception;  
    }  

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

// 这里取出执行链中的 Interceptor进行前处理   
             if  (mappedHandler.getInterceptors() !=  null ) {   
                 for  ( int  i =  0 ; i < mappedHandler.getInterceptors().length; i++) {   
                    HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];   
                     if  (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {   
                        triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response,  null );   
                         return ;   
                    }   
                    interceptorIndex = i;   
                }   
            }   
  
             //在执行handler之前，用 HandlerAdapter先检查一下handler的合法性：是不是按Spring的要求编写的。   
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());   
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());   
  
             // 这里取出执行链中的 Interceptor进行后处理   
             if  (mappedHandler.getInterceptors() !=  null ) {   
                 for  ( int  i = mappedHandler.getInterceptors().length -  1 ; i >=  0 ; i--) {   
                    HandlerInterceptor interceptor = mappedHandler.getInterceptors()[i];   
                    interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);   
                }   
            }   
        }    

配置的角度：
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如下

// 这里catch住controller抛出的异常，使用持有的ExceptionResolver处理，当没有配置自己的处理器时，程序会将异常继续往上抛出，最终交给我们的容器处理  
            catch (Exception ex) {  
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);  
                mv = processHandlerException(processedRequest, response, handler, ex);  
                errorView = (mv != null);  
            }  

        }  
// 当没有配置ExceptionResolver时，异常将到达这里，最终抛出  
        catch (Exception ex) {  
            // Trigger after-completion for thrown exception.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
            throw ex;  
        }  
        catch (Error err) {  
            ServletException ex = new NestedServletException("Handler processing failed", err);  
            // Trigger after-completion for thrown exception.  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);  
            throw ex;  
        }  

//异常将会轮流来处理这个
protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
			Object handler, Exception ex) throws Exception {

		// Check registered HandlerExceptionResolvers...
		ModelAndView exMv = null;
		for (HandlerExceptionResolver handlerExceptionResolver : this.handlerExceptionResolvers) {
			exMv = handlerExceptionResolver.resolveException(request, response, handler, ex);
			if (exMv != null) {
				break;
			}
		}

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


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