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>

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