SpringMvc 笔记

 整理出来是 SpringMvc 笔记  方便以后查询     框架太多了  不经常使用 忘记的可能性很大   自己整理一套笔记   一看就明白了

  1 对比
     原始请求响应流程

     1   发送请求 -->    2  控制层           -->  模型层进行处理 --> 视图  --> 渲染HTML
                         创建模型层 对象 

     Mvc模式

     1  发送请求  -->  2 控制层     --->  3 处理器映射器
                                    <--     返回结果 （寻找请求处理的类）

                                    --->  4 处理器执行器
                                    <--        返回处理结果 ModelAndView（执行 映射器查询到的 处理类 执行对应处理方法）

                                    --->  5 视图解析器
                                    <--        返回查询到的视图地址 （解析视图 （获取当前请求 对应的 视图页面））

                                    --->  6 渲染视图
     7    返回响应 <--               <--        渲染视图  （JSP）

     PS:   控制层 是前端执行器     具体执行类 是 后端控制器 

 配置文件模式
 {

     1  配置SpringMvc 前端控制器 DispatcherServlet

         SpringMvc 是基于 servlet的

         web.xml配置前端控制器：DispatcherServlet    

         <!-- 配置springmvc核心分发器，对所有的url后缀为action的进行过滤 -->
         <servlet>
             <servlet-name>action</servlet-name>
             <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
             <!-- 改变springmvc配置文件的位置和名称 -->
             <init-param>
                 <param-name>contextConfigLocation</param-name>
                 <param-value>classpath:springmvc.xml</param-value>
             </init-param>
         </servlet>
         <servlet-mapping>
             <servlet-name>action</servlet-name>
             <url-pattern>/</url-pattern>
         </servlet-mapping>

     2   配置springmvc.xml

         <!-- 配置处理器映射器,springmvc默认的处理器映射器
         BeanNameUrlHandlerMapping：根据bean(自定义Controler)的name属性的url去寻找hanler(Action:Controller)
          -->
         <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>

         <!-- 配置处理器适配器执行Controlelr ,springmvc默认的
         SimpleControllerHandlerAdapter:执行Controller
         -->
         <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

         <!-- 配置自定义Controler -->  也就是执行方法
         <bean id="myController" name="/hello.do" class="cn.controller.MyController"></bean>

         public class MyController implements Controller{

             public ModelAndView handleRequest(HttpServletRequest arg0,
                     HttpServletResponse arg1) throws Exception {
                 // 接受请求，接受参数，验证参数
                 //封装参数，调用业务方法
                 //返回视图
                 ModelAndView mv = new ModelAndView();
                 //设置页面回显数据
                 mv.addObject("hello", "欢迎学习springmvc！");

                 //指定跳转的视图
                 //返回物理视图
                 //mv.setViewName("/WEB-INF/jsps/index.jsp");
                 //返回逻辑视图
                 mv.setViewName("index");

                 return mv;
             }

         }

         <!-- 配置sprigmvc视图解析器：解析逻辑试图
              后台返回逻辑试图：index
             视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
         -->
         <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
             <property name="prefix" value="/WEB-INF/jsps/"></property>
             <property name="suffix" value=".jsp"></property>
         </bean>

     配置完上面的  就可以运行 Spring Mvc 了
 }    

 处理器映射器
 {

     1   简单处理器映射器   SimpleUrlHandlerMaping

             多个 Url 地址 指向一个处理类    和 手动控制 Url映射地址

         <!-- 简单处理器映射器：
              把Url进行集中配置
          -->
          <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
          <property name="mappings">
          <props>
          <prop key="/abc.do">myController</prop>
          <prop key="/ss.do">http</prop>
          <prop key="/mine.do">http</prop>
          </props>
          </property>

         <!-- 配置自定义Controler -->
         <bean id="myController" name="/hello.do" class="cn.lw.controller.MyController"></bean>

         <!-- 配置自定义HttpController -->
         <bean id="http" class="cn.lw.controller.HttpController"></bean>

     2  控制类名处理程序映射   ControllerClassNameHandlerMapping

         根据类名（MyController）类名.do来访问,类名首字母小写

          <!-- 定义通过: 类名.do 形式来访问controller -->
          <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"></bean>

          <bean id="myController" name="/hello.do" class="cn.lw.controller.MyController"></bean>

          Url :  myController.do 

     3   默认处理器映射器   BeanNameUrlHandlerMapping

         根据url请求去匹配bean的name属性url，从而获取Controller 执行类
         <bean  name="/hello.do" class="cn.controller.MyController"></bean>

 PS： 多个处理器映射器是可以共存的      

 }     

 处理器适配器
 {

     1  默认的处理器适配器 SimpleControllerHandlerAdapter

         调用controller里面方法，返回modelAndView。

         <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

         该 处理器适配器 只处理 继承了  Controller 接口的  controller类

     2  HttpRequestHandlerAdapter

         <!-- HttpRequestHandlerAdapter负责执行实现接口HttpRequestHandler的后端
              控制器。
          -->
         <bean class="org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter"></bean>

          该 处理器适配器 只处理 继承了  HttpRequestHandler 接口的  controller类

         public class HttpController implements HttpRequestHandler{

             public void handleRequest(HttpServletRequest request, HttpServletResponse response)
                     throws ServletException, IOException {
                 //给Request设置值，在页面进行回显
                 request.setAttribute("hello", "这是HttpRequestHandler！");
                 //跳转页面
                 request.getRequestDispatcher("/WEB-INF/jsps/index.jsp").forward(request, response);

             }

         PS: 两个    处理器适配器 是可以共从的

         }
 }

 命令控制器
 {
     用于接收页面参数
     public class CommandController extends AbstractCommandController{

     //指定参数绑定到那个javaBean
     public CommandController(){
         this.setCommandClass(User.class);
     }
     @Override
     protected ModelAndView handle(HttpServletRequest request,
             HttpServletResponse response, Object command, BindException errors)
             throws Exception {
         //把命令对象强转成User对象
         User user = (User) command;
         ModelAndView mv = new ModelAndView();
         mv.addObject("user", user);
         mv.setViewName("index");
         return mv;
     }
     }
 }

 乱码问题
 {

     Get方式：
        在Servers下面找 server.xml
        <Connector URLEncoding="UTF-8" connectionTimeout="20000"  port=.....>

     Post方式
        使用 String编码过滤器：
         在web.xml配置
           <filter>
           <filter-name>characterEncoding</filter-name>
           <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
           <init-param>
           <param-name>encoding</param-name>
           <param-value>UTF-8</param-value>
           </init-param>
           </filter>

           <filter-mapping>
           <filter-name>characterEncoding</filter-name>
           <url-pattern>/*</url-pattern>
           </filter-mapping>

 }

 时间类型转换问题
 {

     SpringMvc 会自动调用 一个initBinder 方法  

     @Override
     protected void initBinder(HttpServletRequest request,
             ServletRequestDataBinder binder) throws Exception {
         String str = request.getParameter("birthday");
         if(str.contains("/")){

             binder.registerCustomEditor(Date.class,
                     new CustomDateEditor(new SimpleDateFormat("yyyy/MM/dd"), true));
         }else{

             binder.registerCustomEditor(Date.class,
                     new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
         }
     }

 }     

 配置文件开发实在是蛋疼 

 ------------------------------------------分割线------------------------------------------

 注解模式
 {

     配置Web.xml
         和配置文件中的一样 不需要更改什么

     配置springmvc配置文件

         <!-- 包自动扫描 -->
         <context:component-scan base-package="cn.lw.controller"/>
         <!-- 配置注解处理器映射器
             功能：寻找执行类Controller
         -->
         <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"></bean>

         <!-- 配置注解处理器适配器
             功能：调用controller方法，执行controller
         -->
         <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"></bean>

         <!-- 配置sprigmvc视图解析器：解析逻辑试图
              后台返回逻辑试图：index
             视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
         -->
         <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/jsps/"></property>
         <property name="suffix" value=".jsp"></property>
         </bean>
         </beans>

     自定义 Connector

         @Controller//<bean class="UserController"/>
         @RequestMapping("/user")
         public class UserController {

             @RequestMapping(value="/hello.do",method={RequestMethod.GET,RequestMethod.POST})
             public String hello(){
                 return "index";
             }

             //跳转到add页面
             @RequestMapping("toAdd")
             public String toAdd(){
                 return "add";
             }

             //接受int类型参数
             @RequestMapping("recieveInt")
             public String recieveInt(Integer id){
                 System.out.println(id);
                 return "success";
             }

             //接受字符类型参数
             @RequestMapping("recieveStr")
             public String recieveStr(String username)
             {
                 System.out.println(username);
                 return "success";
             }

             //接受数组类型参数
             @RequestMapping("recieveArray")
             public String recieveArray(Integer[] ids){
                 System.out.println(ids);
                 return "success";
             }
             HTML
             {
                 ID：<input type="checkbox" name="ids" value="1" id="ids">
                 ID：<input type="checkbox" name="ids" value="2" id="ids">
                 ID：<input type="checkbox" name="ids" value="3" id="ids">
             }

             //接受参数封装User对象
             @RequestMapping("recieveUser")
             public String recieveUser(User user){
                 System.out.println(user);
                 return "success";
             }
             HTML
             {
                 姓名：<input type="text" name="user.username" id="username">
                 生日：<input type="text" name="user.birthday" id="birthday">
                 性别：<input type="text" name="user.sex" id="sex">
                 地址：<input type="text" name="user.address" id="address">
             }

             //接受包装类型参数
             @RequestMapping("recieveUserCustom")
             public String recieveUserCustom(UserCustom userCustom){
                 System.out.println(userCustom);
                 return "success";
             }
             HTML
             {
                 姓名：<input type="text" name="user.username" id="username">
                 生日：<input type="text" name="user.birthday" id="birthday">
                 性别：<input type="text" name="user.sex" id="sex">
                 地址：<input type="text" name="user.address" id="address">
             }

             //接受集合类型参数
             @RequestMapping("recieveList")
             public String recieveList(UserCustom userCustom){
                 System.out.println(userCustom);
                 return "success";
             }
             HTML
             {
                 姓名：<input type="text" name="userList[0].username" id="username">
                 地址：<input type="text" name="userList[0].address" id="address">
                 姓名：<input type="text" name="userList[1].username" id="username">
                 地址：<input type="text" name="userList[1].address" id="address">
             }

             //接受集合类型参数
             @RequestMapping("recieveMap")
             public String recieveMap(UserCustom userCustom){
                 System.out.println(userCustom);
                 return "success";
             }
             HTML
             {
                 姓名：<input type="text" name="maps['username']" id="username">
                 地址：<input type="text" name="maps['address']" id="address">
             }

             //页面回显
             @RequestMapping("list")
             public String list(Model model){
                 //model    相当于application域对象
                 List<User> userList = new ArrayList<User>();
                 User user1 = new User();
                 user1.setId(1);
                 user1.setSex("男");
                 user1.setUsername("张三");
                 user1.setAddress("北京");
                 user1.setBirthday(new Date());

                 User user2 = new User();
                 user2.setId(2);
                 user2.setSex("男2");
                 user2.setUsername("张三222");
                 user2.setAddress("北京222");
                 user2.setBirthday(new Date());

                 User user3 = new User();
                 user3.setId(3);
                 user3.setSex("男3");
                 user3.setUsername("张三333");
                 user3.setAddress("北京333");
                 user3.setBirthday(new Date());

                 userList.add(user1);
                 userList.add(user2);
                 userList.add(user3);

                 // springmvc使用 model 这个对象进行 数据传递
                 // model对象相当于 application 域  页面可以使用EL 进行处理
                 model.addAttribute("userList", userList);
                 return "list";

             }

             //修改
             @RequestMapping("updateByID/{id}")
             public String updateByID(@PathVariable Integer id,Model model){
                 User user1 = new User();
                 user1.setId(id);
                 user1.setSex("男");
                 user1.setUsername("张三");
                 user1.setAddress("北京");
                 user1.setBirthday(new Date());

                 model.addAttribute("user", user1);

                 return "edit";
             }

             //测试转发
             @RequestMapping("forward")
             public String forward(){

                 return "forward:/items/list.do";
             }

             //测试重定向
             @RequestMapping("redirect")
             public String redirect(){

                 return "redirect:/items/list.do";
             }
         }

     RequestMapping 注解

         requestMapping(“hello”)
         requestMapping(“/hello.do”)
         requestMapping(value=”/hello.do”)
         requestMapping(value=”/hello.do”,method=RequestMethod.GET)

         浏览器直接访问,a标签都是get请求
         表单提交(指定post)，ajax指定post提交，post提交。
         requestMapping(value=”/hello.do”,method=RequestMethod.POST) 

         requestMapping(value=”/hello.do”,method={RequestMethod.POST, RequestMethod.GET})

         RequestMapping 根路径问题

         如果出现方法名称相同 那就需要设置这个具体是哪个执行类的根路径

         @RequestMapping("/a")
         public class aController{

             @RequestMapping("save")
             public void save(){
             }
         }
         Url 就是 /a/save.do

         @RequestMapping("/b")
         public class bController{

             @RequestMapping("save")
             public void save(){
             }
         }
         Url 就是 /b/save.do

     RequestParam 注解

         defaultValue是默认值
         value是别名  如 页面传递过来的是 id  就可以在方法中使用ids接收
         required是 是否该参数必须传递 设置默认值后 改参数不起作用    如果没有传递 400错误

         @RequestMapping("/home")
         public String gohome(HttpServletRequest request,
                 @RequestParam(defaultValue="1",value="id",required=true)String ids){
             System.out.println(request.getRequestURL());
             return "index";
         }

 }

 URL模版映射
 {

    普通页面访问传参
    Url :/执行类路径地址/updateid?id=1

            @RequestMapping("updateid")
            public String updateByID(Integer id,Model model){
                 User user1 = new User();
                 user1.setId(id);
                 user1.setSex("男");
                 user1.setUsername("张三");
                 user1.setAddress("北京");
                 user1.setBirthday(new Date());
                 model.addAttribute("user", user1);
                 return "edit";
             }
     Restfull风格设计

     初始版本

     Url:/执行类路径地址/updateid/1.do
      //需要PathVariable这个注解
             @RequestMapping("updateByID/{id}")
             public String updateByID(@PathVariable Integer id,Model model){
                 User user1 = new User();
                 user1.setId(id);
                 user1.setSex("男");
                 user1.setUsername("张三");
                 user1.setAddress("北京");
                 user1.setBirthday(new Date());

                 model.addAttribute("user", user1);

                 return "edit";
             }
     真正使用
     配置Web

     添加一个约定 

       <servlet-mapping>
       <servlet-name>springmvc</servlet-name>
       <url-pattern>/rest/*</url-pattern>
       </servlet-mapping> 

     Url:/rest/执行类路径地址/updateid/1
 }

 转发和重定向
 {

    转发  forward

     本类进行转发
         方式一：return ”forward：list.do“；
         方式二：return ”forward：/user/list.do“；

             //测试转发
             @RequestMapping("forward")
             public String forward(){

                 return "forward:/user/list.do";
             }
         注意：user根路径前面必须有/

     跨类进行转发：
         转发方式：return ”forward：/order/list.do“；

   重定向 redirect    

     本类进行重定向
         方式一：return ”redirect：list.do“；
         方式二：return ”redirect：/user/list.do“；

     跨类进行重定向：
         转发方式：return ”redirect：/order/list.do“；

 }

  Mvc 注解模式 <mvc:annotation-driven/>
 {
    加入该标签  默认就创建了

    配置注解处理器映射器  功能：寻找执行类Controller
    RequestMappingHandlerMapping  

    配置注解处理器适配器  功能：调用controller方法，执行controller
    RequestMappingHandlerAdapter

    同时  默认提供了 json 格式的支持

    springmvc 配置
    {
         <!-- 包自动扫描 -->
         <context:component-scan base-package="cn.lw.controller"/>
         <!-- Mvc 注解模式 -->
         <mvc:annotation-driven/> 

         <!-- 配置sprigmvc视图解析器：解析逻辑试图
              后台返回逻辑试图：index
             视图解析器解析出真正物理视图：前缀+逻辑试图+后缀====/WEB-INF/jsps/index.jsp
         -->
         <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/jsps/"></property>
         <property name="suffix" value=".jsp"></property>
         </bean>
    }

 }

 SpringMvc 对json 格式的支持
 {

   加入Jar包

   使用<mvc:annotation-driven/> 无法对其扩展

     <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
     <property name="messageConverters">
     <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
     </property>

     由于

     @RequestMapping("requestJson")
     public @ResponseBody User requestJson(@RequestBody User user)
     {
         return user;
     }

    由于<mvc:annotation-driven/> 标签已经默认对Json支持了 所有 bean 就不用配置了 

 }

 SpringMvc 对多视图的支持
 {
   配置 springmvc配置文件
         <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
         <!-- 配置支持媒体类型 -->
         <property name="contentNegotiationManager">
             <bean
                 class="org.springframework.web.accept.ContentNegotiationManagerFactoryBean">
                 <property name="mediaTypes">
                     <map>
                         <entry key="json" value="application/json"></entry>
                         <entry key="xml" value="application/xml"></entry>
                     </map>
                 </property>
             </bean>
         </property>

         <!-- 指定默认视图 -->
         <property name="defaultViews">
             <!-- 支持多个视图 -->
             <list>
                 <!-- 对josn格式视图支持 -->
                 <bean
                     class="org.springframework.web.servlet.view.json.MappingJacksonJsonView"></bean>

                 <!-- xml格式视图支持 -->
                 <bean class="org.springframework.web.servlet.view.xml.MarshallingView">
                     <constructor-arg>
                         <bean class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
                             <property name="classesToBeBound">
                                 <list>
                                     <value>cn.lw.domain.User</value>
                                 </list>
                             </property>
                         </bean>
                     </constructor-arg>
                 </bean>
             </list>
         </property>
         </bean>

     @RequestMapping("userView")
     public User userView(){
         User u=new User();
         return u;
     }

     访问很简单  通过后缀名 就自动转换成对应格式了 

     /rest/user/userView.json
     /rest/user/userView.xml

      Ps： 配置 路径

 }

 文件上传
 {

   在SpringMVC中配置文件上传解析器

     <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
      <property name="maxUploadSize" value="10240000"/>
     </bean>

    夸服务器上传  如果不写ID 可能会出错

     解释一下 夸服务器上传 什么意思
        就是单独的拿出一台服务器来保存图片，改服务器什么都不做 建立一个文件夹  修改一下允许 修改的 权限
     最终结果就是  提供一个服务器路径 如 http://10.10.10.10:8080/imgs/1.img

    <script type="text/javascript">
     function submitImgSize1Upload(){
         var option={
                 type:'POST',
                 url:'${pageContext.request.contextPath }/upload/uploadPic.do',
                 dataType:'text',
                 data:{
                     fileName : 'imgSize1File'
                 },
                 success:function(data){
                     //把json格式的字符串转换成json对象
                     var jsonObj = $.parseJSON(data);
                     //返回服务器图片路径，把图片路径设置给img标签
                     $("#imgSize1ImgSrc").attr("src",jsonObj.fullPath);
                     //数据库保存相对路径
                     $("#imgSize1").val(jsonObj.relativePath);
                 }
             };
         $("#itemForm").ajaxSubmit(option);
     }
     </script>

    <form id="itemForm" action="${pageContext.request.contextPath }/items/saveOrUpdate.do" method="post">
    <input type='file' id='imgSize1File' name='imgSize1File' class="file" onchange='submitImgSize1Upload()' />
    </form>

    @RequestMapping("uploadPic")
     public void uploadPic(HttpServletRequest request,String fileName,PrintWriter out){
         //把Request强转成多部件请求对象
         MultipartHttpServletRequest mh = (MultipartHttpServletRequest) request;
         //根据文件名称获取文件对象
         CommonsMultipartFile cm = (CommonsMultipartFile) mh.getFile(fileName);
         //获取文件上传流
         byte[] fbytes = cm.getBytes();

         //文件名称在服务器有可能重复？
         String newFileName="";
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
         newFileName = sdf.format(new Date());

         Random r = new Random();

         for(int i =0 ;i<3;i++){
             newFileName=newFileName+r.nextInt(10);
         }

         //获取文件扩展名
         String originalFilename = cm.getOriginalFilename();
         String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));

         //创建jesy服务器，进行跨服务器上传
         Client client = Client.create();
         //把文件关联到远程服务器
         WebResource resource = client.resource(Commons.PIC_HOST+"/upload/"+newFileName+suffix);
         //上传
         resource.put(String.class, fbytes);

         //ajax回调函数需要会写写什么东西？
         //图片需要回显：需要图片完整路径
         //数据库保存图片的相对路径.
         String fullPath = Commons.PIC_HOST+"/upload/"+newFileName+suffix;

         String relativePath="/upload/"+newFileName+suffix;
         //{"":"","":""}
         String result="{\"fullPath\":\""+fullPath+"\",\"relativePath\":\""+relativePath+"\"}";

         out.print(result);
     }

 }    

 springmvc 页面缓存 freemarker
 {
    配置xml
     <!-- 配置freemarker模版文件前缀，模版文件编码 -->
     <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
     <property name="templateLoaderPath" value="/WEB-INF/jsps/"></property>
     <property name="defaultEncoding" value="UTF-8"></property>
     </bean>
     <!-- 配置freemarker视图解析后缀，页面显示视图编码 -->
     <bean class="org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver">
     <property name="suffix" value=".ftl"></property>
     <property name="contentType" value="text/html;charset=utf-8"></property>
     </bean>

     意思是  .ftl 后缀的  请求 都走 freemarker视图

     freemarker 有自己的 标签   和jsp 差不多  详细的请百度

 }    

 springMvc 拦截器
 {
    局部拦截器

     针对单个处理器映射器，就叫局部拦截器。

    全局拦截器

        <!--拦截器 -->
     <mvc:interceptors>
         <!--多个拦截器,顺序执行 -->
         <mvc:interceptor>
             <mvc:mapping path="/**"/>
             <bean class="cn.lw.interceptor.Interceptor1"></bean>
         </mvc:interceptor>
         <mvc:interceptor>
             <mvc:mapping path="/**"/>
             <bean class="cn.lw.interceptor.Interceptor2"></bean>
         </mvc:interceptor>
     </mvc:interceptors>

    public class Interceptor1 implements HandlerInterceptor{

     //preHandle在处理器映射器之前进行执行
     //return false:拦截 return true:放行
     public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1,
             Object arg2) throws Exception {
         System.out.println("这是第一个拦截器Interceptor1。。。preHandle");
         return true;
     }

     //还没有调用Controller，还没返回modelAndView执行
     public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
             Object arg2, ModelAndView arg3) throws Exception {
         System.out.println("这是第一个拦截器Interceptor1。。。postHandle");

     }

     //返回modelAndView之后执行
     public void afterCompletion(HttpServletRequest arg0,
             HttpServletResponse arg1, Object arg2, Exception arg3)
                     throws Exception {
         System.out.println("这是第一个拦截器Interceptor1。。。afterCompletion");

     }
 }

    Springmvc规定：凡是preHandle返回true，afterCompletion必须执行

     第一个拦截器放行，第二个拦截器也放行：

     这是第一个拦截器Interceptor1。。。preHandle
     这是第二个拦截器Interceptor2。。。preHandle
     这是第二个拦截器Interceptor2。。。postHandle
     这是第一个拦截器Interceptor1。。。postHandle
     这是第二个拦截器Interceptor2。。。afterCompletion
     这是第一个拦截器Interceptor1。。。afterCompletion

     第一个拦截器放行，第二个不放行：

     Springmvc规定：凡是preHandle返回true，afterCompletion必须执行。

     这是第一个拦截器Interceptor1。。。preHandle
     这是第二个拦截器Interceptor2。。。preHandle
     这是第一个拦截器Interceptor1。。。afterCompletion

 }    

一些问题

关于MVC REST 请求的问题 

格式1

    @RequestMapping(value = "{itemCatId}", method = RequestMethod.GET)
    public ResponseEntity<TbItemParam> queryItemParamByItemCatid(
            @PathVariable Long itemCatId)
    {

    }
格式2 

    @RequestMapping(value = "{itemCatId}", method = RequestMethod.GET)
    @ResponseBody
    public ResponseEntity<TbItemParam> queryItemParamByItemCatid(
            @PathVariable("itemCatId") Long itemCatId)
    {

    }

格式3
    @RequestMapping(value = "/destroy/{ConsumerID:^[0-9]*.*@[0-9]*}", method = RequestMethod.GET, produces = "application/json; charset=utf-8")
    @ResponseBody
    public String destroyMqConsumer(@PathVariable String ConsumerID)
    {

    }

返回值的问题
        try
        {
            TbItemParam queryitemParam = new TbItemParam();
            queryitemParam.setItemCatId(itemCatId);
            return ResponseEntity.ok(queryitemParam);  // 状态码是  200
            return ResponseEntity.status(HttpStatus.CREATED).build();  // 状态码是  200  不返回 实体数据
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(queryitemParam);  // 状态码是  200  返回 实体数据
        }
        catch (Exception e)
        {
            e.printStackTrace();
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null); // 状态码是  200  返回 实体数据 是null
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
            // 状态码是  500
        }

关于 请求过滤器 处理PUT 没有参数的问题

<!-- PUT 请求过滤器 处理PUT 没有参数的问题 -->
    <filter>
        <filter-name>HttpPutFormContentFilter</filter-name>
        <filter-class>org.springframework.web.filter.HttpPutFormContentFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>HttpPutFormContentFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>    

关于options  请求不处理的问题

    <servlet>
        <servlet-name>springdispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springMvc-viewresolver.xml</param-value>
        </init-param>
        <init-param>
            <param-name>dispatchOptionsRequest</param-name>
            <param-value>true</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

自己写的笔记，不管多久后 查看后也能非常快速的回顾起来。看别人写的始终是别人的