SpringMVC

SpringMVC学习笔记

第一章 SpringMVC概述
- 1.1 SpringMVC简介
- 1.2 SpringMVC优点
- 1.3 第一个SpringMVC程序
第二章 SpringMV注解式开发
- 2.1 @RequestMapping定义请求规则
- 2.2 处理器方法的参数
- 2.3 处理器方法的返回值
- - 2.3.1 返回ModelAndView
  - 2.3.2 返回String
  - 2.3.3 返回void（了解）
  - 2.3.4 返回Object
- 2.4 解读标签
- 2.5 参考地址
第三章 SSM整合开发![在这里插入图片描述](https://img-blog.csdnimg.cn/09ec5a94b67742a19b697229926590a5.png)![在这里插入图片描述](https://img-blog.csdnimg.cn/0f0069fe776f4ae8a3871e9083b578a6.png)
- **1.建立数据库，创建Maven项目，并添加依赖（pom.xml）**
- **2.配置 web.xml**
- **3.创建包，组织程序的结构。**
- **4. 编写配置文件**
- 5.写代码，实体类，dao接口和mapper文件，service和实现类
- 6.写jsp页面
第四章 SpringMVC核心技术
- 4.1 请求转发与重定向
- - 4.1.1 请求转发
  - 4.1.2 重定向
- 4.2 异常处理
- 4.3 拦截器
- - 4.3.1 一个拦截器的执行
- 4.3.2 多个拦截器的执行
- - SpringMVC 执行流程（理解）

第一章 SpringMVC概述 1.1 SpringMVC简介

SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门是做web开发的。理解是servlet的一个升级

web开发底层是servlet ，框架是在servlet基础上面加入一些功能，让你做web开发方便。

SpringMVC就是一个Spring。 Spring是容器，ioc能够管理对象，使用, @Component, @Repository, @Service, @Controller
SpringMVC能够创建对象，放入到容器中（SpringMVC容器）， springmvc容器中放的是控制器对象，

我们要做的是使用@Contorller创建控制器对象，把对象放入到springmvc容器中，把创建的对象作为控制器使用
这个控制器对象能接收用户的请求，显示处理结果，就当做是一个servlet使用。

使用@Controller注解创建的是一个普通类的对象，不是Servlet。 springmvc赋予了控制器对象一些额外的功能。

web开发底层是servlet， springmvc中有一个对象是Servlet ： DispatherServlet(中央调度器)
DispatherServlet: 负责接收用户的所有请求，用户把请求给了DispatherServlet，之后DispatherServlet把请求转发给
我们的Controller对象，最后是Controller对象处理请求。

index.jsp-----DispatherServlet(Servlet)----转发，分配给—Controller对象（@Controller注解创建的对象）
main.jsp MainController
addUser.jsp UserController

1.2 SpringMVC优点

1.基于MVC架构。功能明确，解耦合。
2.轻量、简单、易学。
3.作为Spring框架的一部分，能够使用IoC、AOP，能够方便的整合其他框架。
4.Spring强化注解的使用。方便灵活。

1.3 第一个SpringMVC程序

springmvc执行过程源代码分析
1. tomcat启动，创建容器的过程
   通过load-on-start标签指定的1，创建DisaptcherServlet对象， 
   DisaptcherServlet它的父类是继承HttpServlet的， 它是一个serlvet， 在被创建时，会执行init（）方法。
   在init（）方法中
   //创建容器，读取配置文件
    WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
    //把容器对象放入到ServletContext中
    getServletContext().setAttribute(key, ctx);

  上面创建容器作用： 创建@controller注解所在的类的对象， 创建MyController对象，
   这个对象放入到 springmvc的容器中， 容器是map ， 类似 map.put("myController",MyController对象)


2.请求的处理过程
  1）执行servlet的service()
       protected void service(HttpServletRequest request, HttpServletResponse response)

       protected void doService(HttpServletRequest request, HttpServletResponse response)


       DispatcherServlet.doDispatch(request, response){

          调用MyController的.doSome()方法
      }

   doDispatch：springmvc中DispatcherServlet的核心方法， 所有的请求都在这个方法中完成的。

1.pom.xml的配置(添加依赖)
spring-webmvc依赖，添加后间接添加Spring依赖

2.注册中央调度器
在web.xml中注册一个servlet：DispatcherServlet，是HttpServlet的子类，称为中央调度器，也被称作前端控制器（front controller）。
通常情况下可以设置contextConfigLocation这个初始化参数来修改这一默认规则，在指定目录下寻找配置文件。
自定义配置文件路径为classpath:springmvc.xml，就在resources目录下创建此文件，以后1.3.6进行配置。





        //创建容器，读取配置文件
        webApplicationcontext ctx = new ClassPath×mlApplicationContext ("springmvc.xml");
        //把容器对象放入到servletcontext中
        getservletcontext( ) .setAttribute(key,ctx);
     }

-->

    springmvc
    org.springframework.web.servlet.DispatcherServlet

    
        contextConfigLocation
        classpath:springmvc.xml
    
    
    1


    springmvc
    *.do

3.创建请求页面
index.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


    第一个springmvc项目
    发生some.do的请求 
    发生other.do的请求

4.创建处理器
在类上添加@Controller注解,这个类就成了控制器、处理器，称之为后端控制器：banck controller
在类中的方法上添加@RequestMapping注解。使用@RequestMapping修饰的方法叫做处理器方法或控制器方法，用来处理请求，相当于sevlet中的service方法。

返回值：ModelAndView
Model:显示给用户的数据，
View：视图，如jsp等

package com.smb.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;


@Controller
public class MyController {
    

    
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){
        //处理some.do请求了。相当于service调用处理完成了。
        ModelAndView mv = new ModelAndView();
        //添加数据 框架在请求的最后把数据放入到request作用域。
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        //指定视图，指定视图的完整路径
        //框架对视图执行的forward操作,request.getRequestDispather ("/show.jsp") . forward(..)
        //mv.setViewName("/show.jsp");

        //mv.setViewName("/WEB-INF/view/show.jsp");
        //mv.setViewName("/WEB-INF/view/other.jsp");

        //当配置了视图解析器后，可以使用逻辑名称(文件名），指定视图
        //框架会使用视图解析器的前缀＋逻辑名称＋后缀组成完成路径，这里就是字符连接操作
        // /WEB-INF/view/ + show + .jsp
        mv.setViewName("show");
        //返回mv
        return mv;
    }

    @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }
}

5.声明组件扫描器
springmvc.xml配置文件

6.定义目标页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


    /WEB-INF/view/show.jsp从request作用域获取数据


    msg数据：${msg}


    fun数据：${fun}

7.创建视图解析器
在当前项目中存在一个问题：用户可以通过地址栏直接访问show.jsp。
为了保护show.jsp的访问权限，可以将它放在WEB-INF目录或子目录下（WEB-INF）对用户来说是不可见的。
这样修改控制器中ModelAndView的ViewName到show。jsp的实际路径就可以解决这个问题。
SpringMVC可以简化setViewName参数冗长的字符串，通过配置视图解析器来实现。

例如，将show.jsp放在WEB-INF/view下：

配置视图解析器（springmvc.xml):

在控制器的doSome方法中，mv.setViewName(“/show.jsp”);写成mv.setViewName(“show”);

第二章 SpringMV注解式开发 2.1 @RequestMapping定义请求规则

@RequestMapping在控制器类上面的使用：
其value属性是此类中每个方法对应的请求路径（也就是 @RequestMapping注解的value属性值）的开头公共部分。

method属性指定请求方法
属性值是枚举类型RequestMethod，常用值RequestMethod.GET和RequestMethod.POST
当未指定请求方式时，无论哪种请求都会成功；
当请求方式与指定方式不匹配时，报错：405 Request method is not supported。

@Controller
@RequestMapping(value = "/user")
public class MyController {
    

    //指定some.do使用get请求方式
    @RequestMapping(value = "/some.do",method = RequestMethod.GET)
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;
    }

    //指定other.do使用post请求方式
    @RequestMapping(value = "/other.do",method = RequestMethod.POST)
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }
}

2.2 处理器方法的参数

方法1.在控制器方法中添加形式参数HttpServletRequest、HttpServletResponse、HttpSession。
方法2.逐个接收请求参数：控制器方法中添加与参数名相同的形式参数即可。此参数可以直接使用。
注意：这种方式要求接受的参数（字符串）可以转化成形式参数类型，否则会报状态码为400的错误。
例如如果一个代表年龄参数没有值，则交给服务器的是一个空字符串"",此时就无法转化成int类型。
当请求参数名与处理器方法的形参名不同时，无法接收到参数。此时使用@RequestParam注解解决这一问题。此注解添加在控制器方法的形参参数类型前，并给出value属性的值为此形参对应的请求参数名（字符串类型），例如请求参数是username，形参名是name：public ModelAndView doSome(@RequestParam(“username” String name, Integer age)){…}
@RequestParam注解还有一个属性required，其默认值为true，这样如果发送请求时为携带参数，就会报状态码为400的错误。可以手动设为false，表示发送的请求可以不携带此参数。
注意不携带此参数不等同于携带此参数但没有值。例如在表单中，即使没有填写某项参数就提交了，但请求依然会携带这个参数（只要此标签有name属性），只是值为空字符串而已。
方法3：使用对象接收参数：创建一个java类，其中包含与请求参数同名的属性，并进行封装。然后将控制器方法的形参换成此类型。在方法内部使用getter获取参数。
在请求发送到控制器时，框架会自动调用控制器方法参数类型的无参构造器，并使用setter赋值。

package com.smb.controller;

import com.smb.vo.Student;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Controller
public class MyController {

    

    @RequestMapping(value = "/receivceproperty.do")
    public ModelAndView doSome(String name,Integer age){
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

    


    
    @RequestMapping(value = "/receivcePara.do")
    public ModelAndView receivceParam(@RequestParam(value = "rname",required = false) String name,
                                      @RequestParam(value = "rage",required = false) Integer age){
        System.out.println("name="+name+","+"age="+age);
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

    
    @RequestMapping(value = "/receivceObject.do")
    public ModelAndView receivceObject(Student myStudent){
        System.out.println("name="+myStudent.getName()+","+"age="+myStudent.getAge());
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",myStudent.getName());
        mv.addObject("myage",myStudent.getAge());
        mv.addObject("mystudent",myStudent);
        mv.setViewName("show");
        return mv;
    }

}

解决请求参数包含中文的乱码问题。
get请求方式没有乱码，post请求方式有乱码。
web.xml中设置过滤器



    characterEncodingFilter
    org.springframework.web.filter.CharacterEncodingFilter
    
    
        encoding
        utf-8
    
    
    
        forceRequestEncoding
        true
    
    
    
        forceResponseEncoding
        true
    



    characterEncodingFilter
   
        System.out.println("name=" + name + "," + "age=" + age);
        request.setAttribute("myname", name);
        request.setAttribute("myage", age);

        //show :逻辑视图名称,项目中配置了视图解析器
        // 框架对视图执行forward转发操作
        return "show";
    }

    //处理器方法返回string ,表示完整视图路径，此时不能配置视图解析器
    @RequestMapping(value = "/returnString-view2.do")
    public String doReturnView2(HttpServletRequest request, String name, Integer age) {
        System.out.println("name=" + name + "," + "age=" + age);
        request.setAttribute("myname", name);
        request.setAttribute("myage", age);

        //show :逻辑视图名称,项目中不能配置视图解析器
        // 框架对视图执行forward转发操作
        return "WEB-INF/view/show.jsp";
    }
}

2.3.3 返回void（了解）

不能表示数据，也不能表示视图。
一般的使用场景：处理AJAX请求。
通过HttpServletResponse输出数据。
1.创建项目，添加jackson依赖：


  com.fasterxml.jackson.core
  jackson-core
  2.9.0


  com.fasterxml.jackson.core
  jackson-databind
  2.9.0
 
2.创建页面发送ajax请求： 
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title
    
    


    


 
3.在控制器中处理并响应请求 
//处理器方法返回void ,响应ajax请求
//手工实现ajax，json数据:代码有重复的 1.java对象转为json 2.通过HttpServle tResponse输出json数据
@RequestMapping(value = "/returnVoid-ajax.do")
public void doReturnVoidAjax(HttpServletResponse response, String name, Integer age) throws IOException {
    System.out.println("name=" + name + "," + "age=" + age);
    //处理ajax，使用json做数据的格式
    // service调用完成了，使用student表示处理结果
    Student student = new Student();
    student.setName(name);
    student.setAge(age);

    String json = "";
    //把结果的对象转为json格式的数据
    if (student != null) {
        ObjectMapper om = new ObjectMapper();
        json = om.writeValueAsString(student);
        System.out.println("student转换的json===" + json);
    }

    //输出数据,响应ajax的请求
    response.setContentType("application/json;charset=utf-8");
    PrintWriter out = response.getWriter();
    out.print(json);
    out.flush();
    out.close();
}
 
2.3.4 返回Object 
在上面2.3.3的示例中，控制器方法的第二、三部分 代码（将结果对象转化为json格式的数据和输出数据）在许多方法中重复使用。只不过需要转化的数据类型不同。为了减少代码复用，这一部分由框架完成：
 1.添加jackson依赖。
 2.添加注解驱动。（约束文件的地址是以mvc结尾）  
这一步的目的是完成数据类型的转换，例如2.3.3中的Object转换成json使用的是MappingJackson2HttpMessageConvener类。还有其他七个类，它们都实现了MessageConvener接口，由于不同的数据格式转换。
 3.在控制器方法中添加注解@ResponseBody，将数据通过response对象返回。 
返回值类型也可以是一个List集合，这样框架会自动将结果数据转化成json数组。顺序与List添加元素顺序相同。
 当返回值类型是String的控制器方法添加了ResponseBody注解，此字符串不会作为视图处理，而是结果数据。如果包含中文，会出现乱码，在RequestMapping中添加属性produces=“text/plain;charset=utf-8” 
@Controller
public class MyController {
    

    @RequestMapping(value = "/returnStudentJson.do")
    @ResponseBody
    public Student doStudentJsonObject(String name, Integer age)  {
        //service调用完成了，使用student表示处理结果
        Student student = new Student();
        student.setName("lisi");
        student.setAge(20);
        return student;
    }

    
    @RequestMapping(value = "/returnStudentJsonArray.do")
    @ResponseBody
    public List doStudentJsonObjectArray(String name, Integer age)  {
        List list=new ArrayList<>();
        //service调用完成了，使用student表示处理结果
        Student student1 = new Student();
        student1.setName("lisi");
        student1.setAge(20);
        Student student2 = new Student();
        student2.setName("zhangsan");
        student2.setAge(21);
        list.add(student2);
        list.add(student1);
        return list;
    }
    

    @RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
    @ResponseBody
    public String doStringData(String name,Integer age){
        return "Hello SpringMVC返回对象，表示数据";
    }
}
 
2.4 解读标签 
tomcat本身能处理静态资源的访问， 像html， 图片， js文件都是静态资源 

    springmvc
    org.springframework.web.servlet.DispatcherServlet
    
        contextConfigLocation
        classpath:springmvc.xml
    
    1


    springmvc

    

    
    / 表示静态资源和未映射的请求都给这个default处理

 
default这个servlet作用：
 The default servlet for all web applications, that serves static
 resources. It processes all requests that are not mapped to other
 servlets with servlet mappings (defined either here or in your own
 web.xml file). 
1.处理静态资源
 2.处理未映射到其它servlet的请求。 
在SpringMVC中，中央调度器处理各种请求，因此需要写各种url-patrern，如果只写/会很方便。但是会造成静态资源无法访问。 
在中央调度器的url-pattern使用 / ，如何解决静态资源无法访问的问题？
 方法一：
 在springmvc.xml配置文件中添加： 




 
其原理是创建DefaultServletHttpRequestHandler对象，类似于控制器，它能将静态资源请求转发给tomcat的defaultServlet。（requestDispatcher.forward）
 方法二：
 在springmvc.xml配置文件中添加： 
 
   
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        //显示转发
        mv.setViewName("forward:/WEB-INF/view/show.jsp");
        return mv;
    }
}
 
4.1.2 重定向 
**特点：**不与视图解析器一同使用。本质是两次访问，不能访问WEB-INF目录下的资源
 传参：
 由于是两次不同的请求，因此不能通过getAttribute获得参数。当我们向ModelAndView对象添加数据（addObject方法）以后，这些数据会在发送第二次请求时以get方式呈现在url后（?参数名=参数值&…）
 moduleAndView对象.setViewName(“redirect:转发目标完整路径”);
 //redirect是关键字 
* 框架对重定向的操作:
* 1.框架会把Model中的简单类型的数据,转为string使用,作为hello.jsp的get请求参数使用。
*      目的是在doRedirect.do和 hello.jsp两次请求之间传递数据
* 2.在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
*      ${param.myname}
*
* 3.重定向不能访问/wEB-INF资源

@RequestMapping(value = "/doRedirect.do")
public ModelAndView doOther(String name,Integer age){
   ModelAndView mv = new ModelAndView();
   mv.addObject("myname",name);
   mv.addObject("myage",age);
   //重定向
   mv.setViewName("redirect:/show.jsp");
   return mv;
}

show.jsp
myname数据：${param.myname}


myage数据：${param.myage}
取参数数据：<%=request.getParameter("myname")%>
 
4.2 异常处理 
SpringMVC处理异常使用的是AOP的思想，其目的是将异常处理的代码与业务代码分开，达到解耦合的目的。
 1.创建自定义的异常
 自定义的异常类需要继承java.lang.Exception，并至少给出无参构造器和带有String参数的构造器。 
public class MyUserException extends Exception{

    public MyUserException() {
    }

    public MyUserException(String message) {
        super(message);
    }
}
 
2.在Controller中向上抛出这些异常 
@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doOther(String name,Integer age) throws MyUserException {
        ModelAndView mv = new ModelAndView();
        //根据请求参数抛出异常
        if(!"zs".equals(name)){
            throw new NameException("姓名不正确！！！");
        }
        if(age==null||age>80){
            throw new AgeException("年龄不正确！！！");
        }
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        //重定向
        mv.setViewName("show");
        return mv;
    }
}
 
3.创建异常处理的切面类
 在类前添加注解：@controllerAdvice
 在类中给出异常处理的切面方法。这些方法的定义规则与第二章中控制器方法的定义规则相同，还可以添加一个形参Exception表示要处理的异常对象。在方法前添加注解：@ExceptionHandler 其value属性类型是Class，表示要处理的异常类型（value=异常类名.class）。如果没有value属性，则此方法用来处理未指定的异常类型。 
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常

    
    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception exception){
        //处理NameException的异常
        
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","姓名必须是zs，其他用户不能访问");
        mv.addObject("ex",exception);
        mv.setViewName("nameError");
        return mv;
    }
}
 
4.在springmvc配置文件中添加标签扫描器与注解驱动： 
 
 
 
 
4.3 拦截器 
4.3.1 一个拦截器的执行 
拦截器：
1）拦截器是springmvc中的一种，需要实现HandlerInterceptor接口。
2）拦截器和过滤器类似，功能方向侧重点不同。 过滤器是用来过滤器请求参数，设置编码字符集等工作。
    拦截器是拦截用户的请求，做请求判断处理的。
3）拦截器是全局的，可以对多个Controller做拦截。 
   一个项目中可以有0个或多个拦截器， 他们在一起拦截用户的请求。
	拦截器常用在：用户登录处理，权限检查， 记录日志。

拦截器的使用步骤：
 1.定义类实现HandlerInterceptor接口
 2.在springmvc配置文件中，声明拦截器， 让框架知道拦截器的存在。

拦截器的执行时间：
  1）在请求处理之前， 也就是controller类中的方法执行之前先被拦截。
  2）在控制器方法执行之后也会执行拦截器。
  3）在请求处理完成后也会执行拦截器。


拦截器：看做是多个Controller中公用的功能，集中到拦截器统一处理。使用的aop的思想
 
1.定义类实现HandlerInterceptor接口
 MyInterceptor类 
package com.smb.handler;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;

//拦截器类:拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {
    private long btime=0;
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime=System.currentTimeMillis();
        System.out.println("拦截器的MyInterceptor的preHanded()");
        return true;
    }

    

    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("拦截器的MyInterceptor的postHandle()");
        //对原来的dosome执行结果,需要调整。
        if (mv != null) {
            mv.addObject("mydate",new Date());
            mv.setViewName("other");
        }

    }

    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("拦截器的MyInterceptor的afterCompletion()");

        long etime=System.currentTimeMillis();
        System.out.println("计算从preHandle到请求处理完成的时间:"+(etime-btime));
    }
}

 
2.在springmvc配置文件中，声明拦截器 


    
        
        
        
        
    

 
4.3.2 多个拦截器的执行 
多个拦截器：
第一个拦截器preHandle=true , 第二个拦截器preHandle=true 

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
=====执行MyController中的doSome方法=====
22222-拦截器的MyInterceptor的postHandle()
111111-拦截器的MyInterceptor的postHandle()
22222-拦截器的MyInterceptor的afterCompletion()
111111-拦截器的MyInterceptor的afterCompletion()

---------------------------------------------------
第一个拦截器preHandle=true , 第二个拦截器preHandle=false

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
111111-拦截器的MyInterceptor的afterCompletion()

----------------------------------------------------------
第一个拦截器preHandle=false , 第二个拦截器preHandle=true|false

111111-拦截器的MyInterceptor的preHandle()
 

 拦截器和过滤器的区别 
1.过滤器是servlet中的对象， 拦截器是框架中的对象
 2.过滤器实现Filter接口的对象， 拦截器是实现HandlerInterceptor
 3.过滤器是用来设置request，response的参数，属性的，侧重对数据过滤的。
 拦截器是用来验证请求的，能截断请求。
 4.过滤器是在拦截器之前先执行的。
 5.过滤器是tomcat服务器创建的对象
 拦截器是springmvc容器中创建的对象
 6.过滤器是一个执行时间点。
 拦截器有三个执行时间点
 7.过滤器可以处理jsp，js，html等等
 拦截器是侧重拦截对Controller的对象。 如果你的请求不能被DispatcherServlet接收， 这个请求不会执行拦截器内容
 8.拦截器拦截普通类方法执行，过滤器过滤servlet请求响应 
SpringMVC 执行流程（理解）

SpringMVC

/WEB-INF/view/show.jsp从request作用域获取数据

msg数据：${msg}

fun数据：${fun}

myname数据：${param.myname}

myage数据：${param.myage}

取参数数据：<%=request.getParameter("myname")%>

Java相关栏目本月热门文章