spring-mvc笔记

最新推荐文章于 2024-05-03 20:39:53 发布

吃土大魔王

最新推荐文章于 2024-05-03 20:39:53 发布

阅读量123

点赞数

文章标签： springmvc

原文链接：https://blog.csdn.net/weixin_40350981/article/details/109645897

版权

第一章：SpringMVC概述

1.1SpringMVC简述

SpringMVC也叫 spring web mvc .是spring的一部分，是在spring3.0后发布的

1.2SpringMVC优点

SpringMVC:基于spring的一个框架，实际上就是spring的一个模块，专门是做web开发的，理解为servlet的升级。web开发底层是servlet，框架是在servlet基础上面加入一些功能，让开发更方便。

SpringMVC就是一个spring。spring是容器，ioc能够管理对象，
使用< bean>，@Component，@Repository，@Service，@Controller 标签

SpringMVC能够创建对象，放入到容器中（springmvc容器），SpringMVC容器中放的是控制器对象

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

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

index,jsp不能直接给@Controller,因为它不是servlet

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

index.jsp —> DispatcherServlet（servlet） ----> 转发，分配给Controller对象（@Controller 注解创建的对象）

DispatcherServlet接受请求，传给Controller处理，再把结果传回给DispatcherServlet，再传给用户，Controller是MVC创建的

readme.txt

ch01-hello-springmvc:第一个springmvc项目。
需求:用户在页面发起一个请求，请求交给springmvc的控制器对象，
       并显示请求的处理结果（在结果页面显示一个欢迎语句）。

实现步骤:
1.新建web maven工程
2.加入依赖
  spring-webmvc依赖，间接把spring的依赖都加入到项目
  jsp,servlet依赖

3.重点：在web.xml中注册springmvc框架的核心对象DispatcherServlet
    1)DispatcherServlet叫做中央调度器，是一个servlet，它的父类是继承HttpServlet
    2)DispatcherServlet也叫坐前端控制器（front controller）
    3)DispatcherServlet负责接受用户提交的请求，调用其他的控制器对象，
                        并把请求的处理结果显示给用户

4.创建一个发起请求的页面 index.jsp

5.创建控制器类
1）在类的上面加入@Controller注解，创建对象，并放入到springmvc容器中
2）在类中的方法上面加入@RequestMapping注解。

6.创建一个作为结果的jsp，显示请求的处理结果。

7.创建springmvc的配置文件（spring的配置文件一样）
1）声明组件扫描器，指定@Controller注解所在的包名
2)声明视图解析器，帮助处理视图的。

新建一个WEB-INF中的web.xml文件，模板自带的版本是2.3的太低，要先删掉原本的，新建一个叫1web.xml用4.0版本，然后再改名回去（直接新建web.xml文件版本改不了成4.0）

classpath是resource路径下，servlet-name是springmvc配置文件的名字。

tomcat启动，创建DispatcherServlet对象，同时创建springmvc容器对象，读取springmvc配置文件，
这里配置文件的根地址 classpath = springmvc.xml

springmvc请求的处理流程

1）发起some.do
2）tomcat(web.xml--url-pattern知道 *.do的请求给DispatcherServlet)
3）DispatcherServlet（根据springmvc.xml配置知道 some.do---doSome()）
4）DispatcherServlet把some.do转发个MyController.doSome()方法
5）框架执行doSome（）把得到ModelAndView进行处理，转发到show.jsp

上面的过程简化的方式
some.do---DispatcherServlet---MyController

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的核心方法，所有的请求都在这个方法中完成的。

补充：springMVC 中的 M-model，V-view，C-controller

1.5 SpringMVC执行流程

springmvc内部请求的处理流程：也就是springmvc接收请求，到处理完成的过程

1.用户发起请求some.do
2.DispatcherServlet接收请求some.do，把请求转交给处理器映射器
处理器映射器：springmvc框架中的一种对象，框架把实现了HandlerMapper接口的类都叫做映射器（多个）

处理器映射器作用：根据请求，从springmvc容器对象中获取处理器对象（MyController controller = ctx.getBean("some.do")）
框架把找到的处理器对象放到一个叫做处理器执行链（HandlerExecutionChain）的类保存

HandlerExecutionChain: 类中保存着
1).处理器对象（MyController）;
2).项目中的所有的拦截器List<HandlerInterceptor> interceptorList

3.DispatcherServlet把2中的HandlerExecutionChain中的处理器对象交给了处理器适配器对象（多个）
处理器适配器：springmvc框架中的对象，需要实现HandlerAdapter接口。
处理器适配器作用：执行处理器方法（调用MyController.dosome() 得到返回值ModelAndView）

4.DispatcherServlet把3中获取的ModelAndView交给了视图解析器对象。
视图解析器：springmvc框架中的对象，使用前缀，后缀。并创建View对象。
View是一个接口，表示视图的，在框架中jsp，html不是string表示，而是使用View和他的实现类表示视图.

InternalResourceView:视图类，表示jsp文件，视图解析器会创建InternalResourceView类对象。
这个对象的里面，有一个属性url=/WEB-INF/view/show.jsp

5.DispatcherServlet把4步骤中创建的view对象获取到，调用view类自己的方法，把Model数据放入到request作用域。
执行对象视图的forw。请求接受。

创建好web项目后，在pom.xml中加入servlet和springmvc依赖

    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>

发送some.do请求的页面 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个springmvc项目</p>
    <p><a href="some.do">发起some.do的请求</a> </p>
    <p><a href="other.do">发起other.do的请求</a></p>
</body>
</html>

核心配置文件 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!--声明，注册springmvc的核心对象DispatcherServlet
        需要在tomcat服务器启动后，创建DispatcherServlet对象的实例
        为什么要创建DispatcherServlet对象的实例呢？
        因为DispatcherServlet在他的创建过程中，会同时创建springmvc容器对象，
        读取springmvc的配置文件，把这个配置文件中的对象都创建好，当用户发起
        请求时就可以直接使用对象了。

        servlet的初始化会执行init（）方法。DispatcherServlet在init（）中{
            //创建容器，读取配置文件
            webApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
            //把容器对象放入到ServletContext中
            getServletContext().setAttribute(key,ctx);
        }

        启动tomcat报错，读取这个文件 /WEB-INF/springmvc-servlet.xml(/WEB-INF/myweb-servlet.xml)
        springmvc创建容器对象时，读取的配置文件默认是/WEB-INF/<servlet-name>-servlet.xml.
    -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>


        <!--在tomcat启动后，创建Servlet对象
            load-on-startup：表示tomcat启动后创建对象的顺序。它的值是整数，数值越小，
                             tomcat创建对象的时间越早。大于等于0的整数.
        -->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <!--
            使用框架的时候，url-pattern可以使用两种值
            1.使用扩展名方式，语法*，xxxx,xxxx是自定义的扩展名。常用的方式*.do,*.action,*.mvc等等
                http://localhost:8080/myweb/some.do
            2.使用斜杠"/"

        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

定义目标页面

在webapp目录下新建一个子目录jsp，在其中新建一个jsp页面show.jsp。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp从request作用域获取数据</h3><br/>
    <h3>msg数据:${msg}</h3><br/>
    <h3>fun数据:${fun}</h3>
</body>
</html>

springmvc.xml

在springmvc.xml中注册组件扫描器和配置视图解析器

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.bjpowernode.controller"/>
    <!--注册视图解析器：帮助我们处理视图的路径和扩展名。生成视图对象-->
    <!--注册内部资源视图解析器InternalResourceViewResolver-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀:表示视图所在的路径-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀:表示视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

创建控制器类 MyController.java

@RequestMapping的value是一个String数组，一个方法可以放多个请求

现在处理增删改查只要4个方法了，一个方法对应多个，不像servlet对应一个请求

/**
 *@Controller:创建处理器对象，对象放在springmvc容器中。
 * 位置：在类的上面
 * 和spring中讲的@service，@Component
 *
 * 能处理请求的都是控制器(处理器):MyController能处理请求，
 *                          叫做后端控制器(back controller)
 ***/
@Controller
public class MyController {
    /**
     * 准备使用doSome方法处理some.do请求。
     *
     * @RequestMapping:请求映射，作用是把一个请求地址和一个方法绑定在一起。 一个请求指定一个方法处理。
     * 属性:1.value 是一个String,表示请求的url地址的（some.do）。
     * value的值必须是唯一的，不能重复。在使用时，推荐地址以“/”
     * <p>
     * 位置：1.在方法的上面，常用的。
     * 2.在类的上面
     * 说明:使用RequestMapping修饰的方法叫做处理器方法或者控制器方法.
     * 使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中doGet,doPost
     * <p>
     * 返回值：ModelAndView
     * Model：数据，请求处理完成后，要显示给用户的数据
     * view：视图，比如jsp等等
     */
    @RequestMapping(value = {"/some.do","/first.do"} )
    public ModelAndView doSome(){  //doGet()--service请求处理
        //处理some.do清求了。相当于service调用处理完成了。
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域.
        //reques.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun", "执行的是doSome方法");

        //指定视图，指定视图的完整路径
        //框架对视图执行的forward操作,reques.getRequestDispather("/show.jsp").forward(...)
        //当配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
        //框架会使用视图解析器的前缀+逻辑名称+后缀组成完整路径，这里就是字符连接操作
        //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;
    }
}

对应的 show.jsp和other.jsp

把show.jsp和other.jsp放在WEB-INF中，因为这个目录用户无法访问，不能通过直接输入http://localhost:8080/ch01_hello_springmvc/some.do来访问

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <h3>other.jsp从request作用域获取数据</h3><br/>
    <h3>msg数据:${msg}</h3><br/>
    <h3>fun数据:${fun}</h3>
</head>
<body>

</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp从request作用域获取数据</h3><br/>
    <h3>msg数据:${msg}</h3><br/>
    <h3>fun数据:${fun}</h3>
</body>
</html>

第二章SpringMVC注解式开发

ch03-recevieparam:接受请求的参数
接受请求参数，使用的处理器方法的形参
1)HttpSercletRequest
2)HttpServletResponse
3)HttpSession
4)用户提交的数据

接受用户提交的参数:
1.逐个接受
2.对象接受


注意：
在提交请求参数时，get请求方式中文没有乱码。
使用post方式提交请求，中文有乱码，需要使用过滤器处理乱码问题

过滤器可以自定义，也可以使用框架中提供的过滤器 CharacterEncodingFilter

模块名称表示当前controller属于哪个功能

/*
* @RequestMapping
* 	value:所有请求的公共部分，叫做模块名称
*   位置：在类的上面
* */

@Controller
@RequestMapping("/user")
//或者@RequestMapping("/test")
public class MyController {

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

    }
}

理解为在该方法在 user或者test模块下

method 属性指定请求方式

@Controller
@RequestMapping("/test")
public class MyController {
    /*
    * @RequestMapping(value = "",method = )
    * 	属性：method 表示请求的方式，它的值是RequestMethod类枚举值
    *
    * 	get请求方式， method = RequestMethod.GET
    * 	post请求方式，method = RequestMethod.POST
    * 
    * */

    //指定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;
    }

对应的index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>第一个springmvc项目</p>
    <p><a href="test/some.do">发起some.do的get请求</a></p>
    <br/>

    <form action="test/other.do" method="post">
        <input type="submit" value="post请求other.do">
    </form>

<%--    <p><a href="user/other.do">发起other.do请求</a></p>--%>
</body>
</html>

处理器方法的参数

处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可以在方法中直接使用。

1	HttpServletRequest		 请求
2	HttpServletResponse		 应答
3	HttpSession				会话
4	请求中所携带的请求参数

前三类参数使用方式

@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(HttpServletRequest request,
                               HttpServletResponse response,
                               HttpSession session){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发" + request.getParameter("name"));
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;
    }

一.逐个参数接收

1.接收用户提交的参数：处理器（控制器）方法的形参名和请求中的参数必须一致

@Controller
public class MyController {
    /*
    * 逐个接收请求参数：
     *   要求：处理器（控制器）方法的形参名和请求中的参数必须一致
     *         同名的请求参数赋值给同名的参数
     *     * 框架接收请求参数：
    * 1 使用request对象接收请求参数
    *   String strName = request.getParameter("name");
    *   String strAge = request.getParameter("age");
    * 2 springmvc框架通过dispatcherServlet 调用MyController的doSome方法
    *   调用方法时，按名称对应，把接收的参数赋值给形参 doSome(strName,Integer.valueOf(strAge))
    *   框架会提供类型转换的功能，把String转换为 int ，long ，float ，double等
    * */
    @RequestMapping(value ="/receiveproper.do")
    public ModelAndView doSome(String name,int age){
        System.out.println("dosome方法的，name=" + name + ", age=" + age);
        //处理some.do清求了。相当于service调用处理完成了。
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage", age);
        mv.setViewName("show");
        return mv;
    }

对应的index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>提交参数给Controller</p>
    <form action="receiveproper.do" method="post">
        姓名:<input type="text" name="name"><br/>
        年龄:<input type="text" name="age"><br/>
        <input type="submit" value="提交参数">
    </form>

</body>
</html>

注意：在提交请求参数的时候，get请求方式中文没有乱码；post请求方式中文有乱码，需要使用过滤器处理乱码问题。

get方式的参数放在了请求头上面所以是由tomcat来解码，tomcat的默认解码方式为UTF-8

post方式的参数放在了请求体中，由request来解码，解码方式默认为ISO-8859-1，解码中文会乱码

//在web.xml配置过滤器
<!--注册声明过滤器，解决post请求乱码的问题-->
<filter>
    <filter-name>characterEncodingFilter</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>

    <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
    <init-param>
        <param-name>forceRequestEncoding</param-name>
        <param-value>true</param-value>
    </init-param>

    <!--强制应答对象（HttpServletResponse）-->
    <init-param>
        <param-name>forceResponseEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <!--
    /*  : 表示强制所有的请求先通过过滤器处理
    -->
    <url-pattern>/rl-pattern>
</filter-mapping>

2.请求参数名和处理器方法的形参名不一样，使用 @RequestParam 注解

有一个问题，当不通过首页传入参数，直接加载网址：http://localhost:8080/03_recevieparam/ receiveparam.do，将会报400的错，说明请求端输入有问题，如下图

400错误是发生在客户端的，发请求的过程中，发请求的这个参数和你的controller不对应（直接访问地址没有传任何参数）

@RequestParam中的required = false属性可以不传值，（默认为true，这时@RequestParam必须传值，此时不能直接访问地址）

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <p>提交参数给Controller</p>
    <form action="receiveproper.do" method="post">
        姓名:<input type="text" name="name"><br/>
        年龄:<input type="text" name="age"><br/>
        <input type="submit" value="提交参数">
    </form>

    <br/>
    <p>请求参数名和处理器方法的形参名不一样</p>
    <form action="receiveparam.do" method="post">
        姓名:<input type="text" name="rname"><br/>
        年龄:<input type="text" name="rage"><br/>
        <input type="submit" value="提交参数">
    </form>
</body>
</html>

MyController.JAVA

/*
    * 请求中参数名和处理器方法的形参名不一样
    * @RequestParam:逐个接受请求参数中，解决请求中参数名形参名不一样的问题
    *       属性：1.value 请求中的参数名称
    *            2.required 是一个boolean，默认是true
    *               true:表示请求中必须包含此参数
    *               用来保证某些参数必须有
    *       位置：在处理器方法的形参定义的前面
    * */
    @RequestMapping(value = "/receiveparam.do")
    public ModelAndView recevieParam(@RequestParam(value = "rname") String name,
                                     @RequestParam(value = "rage") Integer age) {
        System.out.println("dosome方法的，name=" + name + ", age=" + age);
        ModelAndView mv = new ModelAndView();
        mv.addObject("myname", name);
        mv.addObject("myage", age);
        mv.setViewName("show");
        return mv;
    }

二.对象参数接收：

适合接受多个参数

将处理器方法的参数定义为一个对象，对象的属性名要求和请求中参数名一致

先在vo包下定义一个Student 类

//保存请求参数值的普通类
public class Student {
    //属性值要和请求参数值一样
    private String name;
    private int age;
    
    public Student() { System.out.println("---------Student的无参构造方法--------"); }
    public String getName() {return name;}
    public void setName(String name) {System.out.println("setName= "+name);this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {System.out.println("setAge= "+age);this.age = age;}
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

主页index.jsp

    <br/>
    <p>使用java对象接受请求参数</p>
    <form action="receiveobject.do" method="post">
        姓名:<input type="text" name="name"><br/>
        年龄:<input type="text" name="age"><br/>
        <input type="submit" value="提交参数">
    </form>

处理器方法

   /*处理器方法形参是java对象，这个对象的属性名和请求中参数名一样的
    * 框架会创建形参的Java对象，给属性赋值。请求中的参数是name,框架会调用setName()
    * */

    @RequestMapping(value = "/receiveobject.do")
    public ModelAndView recevieObject(Student myStudent) {
        System.out.println("recevieObject方法的，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;
    }
}

处理器方法返回值

ModelAndView 返回值

若处理器方法处理完后，需要跳转到其他资源，且又要在跳转的资源间传递数据，此时处理器方法返回 ModelAndView 比较好。当然，若要返回 ModelAndView，则处理器方法中需要定义 ModelAndView对象。

返回值 String ，表示逻辑视图名称或完整视图路径

只想返回视图

ch04-return:处理器方法的返回值表示请求的处理结果
1.ModelAndView:有数据和视图，对视图执行forward.
2.String：表示视图，可以逻辑名称，也可以是完整视图路径
3.void:不能表示数据，也不能表示视图。
   在处理ajax的时候，可以使用void返回值。通过HttpServletResponse输出数据.响应ajax请求.
   ajax请求服务器端返回的就是数据，和视图无关。

@Controller
public class MyController {
/**
 * 处理器方法返回string--表示逻辑视图名称，需要配置视图解析器
 */
    @RequestMapping(value ="/returnString-view.do")
    public String doReturnView(HttpServletRequest request,String name,Integer age){
        System.out.println("doReturnView方法的，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("===doReturnView2====，name=" + name + ", age=" + age);
        request.setAttribute("myname", name);
        request.setAttribute("myage", age);
        // 完整视图名称，项目中不能配置视图解析器
        // 框架对视图执行forward转发操作
        ///WEB-INF/jsp/WEB-INF/view/show.jsp.jsp
        return "/WEB-INF/view/show.jsp";
    }
}

返回值 void ，了解

p24和p25学完ajax和jquery

返回值 object 对象

object：例如String，Integer，Map，List，Student 等等都是对象，对象有属性，属性就是数据。所以返回 object 表示数据，和视图无关。可以使用对象表示的数据，响应ajax请求。

现在做 ajax，主要使用 json的数据格式。
面试：springmvc开发中，返回值是object类型，如何转换为 json ？实现步骤：

1	加入处理json的工具库的依赖，springmvc默认使用的jackson

	pom.xml 加入jackson依赖

	<!--jackson依赖-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.0</version>
    </dependency>

2	在springmvc配置文件之间加入 <mvc:annotation-driven> 注解驱动
    
    主配置文件 springmvc.xml 加入：
    
    <!--@ResponseBody注解驱动-->
    <mvc:annotation-driven/>
    
3	在处理器方法的上面加上 @ResponseBody

3	在处理器方法的上面加上 @ResponseBody
    
控制器方法 MyController.java

//处理器方法返回一个Student，通过框架转为json，响应ajax请求
//@ResponseBody 作用：把处理器方法返回对象转为json后，通过HttpServletResponse输出给浏览器
@ResponseBody
@RequestMapping(value = "returnStudentJson.do")
public Student doStudentJsonObject(String name,Integer age){

    Student student = new Student();
    student.setName("lisi");
    student.setAge(10);
    return student; //会被框架转为json
}

当返回值是多个参数（用的比较普遍），返回类型改为List集合，其他不变

@RequestMapping(value ="returnStudentJsonArray.do" )
@ResponseBody
public List<Student> doStudentJsonObjectArray(String name,Integer age){

    List<Student> list = new ArrayList<>();
    Student student = new Student();
    student.setName("wangwu");
    student.setAge(22);
    list.add(student);

    student = new Student();
    student.setName("tianmao");
    student.setAge(10);
    list.add(student);

    return list;
}

前端页面 index.jsp ，返回 json 格式为：[{“name”:“wangwu”,“age”:22},{“name”:“tianmao”,“age”:10}]

<head>
    <title>Title</title>
    <script type="text/javascript" src="js/jquery-3.5.1.js"></script>
    <script type="text/javascript">
        $(function () {
            $("button").click(function () {
                // alert("button click");
               $.ajax({
                   
                   // url:"returnVoid-ajax.do",
                   // url:"returnStudentJson.do",
                   url:"returnStudentJsonArray.do",
                   
                   data:{
                       name:"zhangsan",
                       age:20
                   },
                   type:"post",
                   dataType:"json",
                   success:function(resp) {

                       // alert(resp.name+"   "+resp.age);

                       //[{"name":"wangwu","age":22},{"name":"tianmao","age":10}]
                       $.each(resp,function (i,n) {
                            alert(n.name+"  "+n.age);
                       })
                   }
               })
            })
        })
    </script>
</head>

处理器方法返回的是 String，表示数据，不是视图

/*
* 处理器方法返回的是String，String表示数据的，不是视图。
* 区分返回值类型String是数据，还是视图，看看有没有@ResponseBody注解
* 如果有@ResponseBody注解，返回String就是数据，反之就是视图
* */


@ResponseBody
public String doStringData(String name,Integer age){
    return "返回对象，表示数据";
}

springmvc 处理器方法返回 object，可以转为 json输出到浏览器，响应 ajax 的内部原理

1 	<mvc:annotation-driven> 注解驱动
	注解驱动实现的功能是：完成java对象到 json，xml，test，二进制等数据格式的转换
	HttpMessageConverter接口：消息转换器
	功能：定义了java转json，xml等数据格式的方法。这个接口有很多实现类
		这些实现类完成了java对象到json，Java对象到xml，Java对象到二进制数据的转换

2	HttpMessageConverter接口的两个方法是：控制器类把结果输出给浏览器时使用的
		boolean canWrite(Class<?> var1, @Nullable MediaType var2);
		void write(T var1, @Nullable MediaType var2, HttpOutputMessage var3)
	
    	1) canWrite：检查处理器方法返回值，能不能转为var2的数据格式
    	2) write：把处理器方法的返回值对象，调用jackson中的ObjectMapper转为json字符串

3	ResponseBody 注解
    放在处理器方法的上面，通过HttpServletResponse输出结果，响应ajax请求

解读中央调度器 < url-pattern/ >

1 .do

在没有特殊要求的情况下，springmvc 的中央调度器 DispatcherServlet 的< url-pattern/ >常使用后缀匹配方式，如写为 *.do 或者 *.action ， *.mvc 等

2 /

可以写为 / ，因为DispatcherServlet会将向静态资源的获取请求，例如 .css .js .jpg .png 等资源的获取请求，作为是一个普通的Controller请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的，所以在这种情况下，所有的静态资源获取请求也均会报404错误。

发起的请求是由哪些服务器处理的：

http: //localhost:8080/05_url_pattern/index.jsp		tomcat
http: //localhost:8080/05_url_pattern/images/1.jpg	  tomcat
http: //localhost:8080/05_url_pattern/html/test.html	tomcat
http: //localhost:8080/05_url_pattern/some.do	springmvc框架（DispatcherServlet）

tomcat的web.xml文件有一个 servlet 名称为 default，在服务器启动时创建。如下：

<servlet>
    <servlet-name>default</servlet-name> 
    <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
    <init-param>
        <param-name>debug</param-name>
        <param-value>0</param-value>
    </init-param>
    <init-param>
        <param-name>listings</param-name>
        <param-value>false</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>/</url-pattern>	// "/" 表示静态资源和未映射的请求都给这个default处理
</servlet-mapping>

这个名叫 default 的 servlet 作用：
1 处理静态资源
2 处理未映射到其它servlet的请求

使用 ” / “ 后，无法访问静态资源，可以访问动态资源

// web.xml
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <!--
   		使用框架的时候，url-pattern可以使用两种方式
    1.使用扩展名方式，语法 *.xxxx , xxxx时自定义扩展名。常用的方式 *.do, *.action, *.mvc等等
        http://localhost:8080/myweb/some.do
        http://localhost:8080?myweb/other.do

    2.使用斜杠 "/"
        当你的项目使用了 / ，它会替换 tomcat 中的 default.
        导致所有的静态资源都给DispatcherServlet处理，默认情况下DispatcherServlet没有处理静态资源的能力,
        没有控制器对象能处理静态资源的访问,所以静态资源（html，js，图片，css）都是404

        动态资源some.do可以访问，原因时我们程序中有MyController控制器对象，能处理some.do请求
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

让静态资源可以访问的两种方式

1 使用 < mvc:default-servlet-handler > 和 < mvc:annotation-driven/ >

声明了<mvc:default-servlet-handler />后，springmvc框架会在容器中创建DefaultServletHttpRequestHandler处理器对象。

// springmvc.xml

<!--@ResponseBody注解驱动-->
<mvc:annotation-driven/>

<!--第一种处理静态资源的方式：<mvc:default-servlet-handler/>

    需要在springmvc配置文件加入 <mvc:default-servlet-handler>
    原理是：加入这个标签后，框架会创建控制器对象（类似自己创建的MyController）,
    这个对象可以把接收到的请求转发给tomcat的名字叫default的servlet
-->
<mvc:default-servlet-handler/>

2 使用 < mvc:resources /> 需要掌握

在 spring3.0 版本后，spring定义了专门用来处理静态资源访问请求的处理器 ResourceHttpRequestHandler。并且添加了< mvc:resources />标签，专门用于解决资源无法访问问题。需要在springmvc配置文件中添加如下形式的配置：


   //springmvc.xml

	<!--第二种处理静态资源的方式
        mvc：resources加入后框架会创建 ResourceHttpRequestHandler这个处理器对象
        让这个对象处理静态资源的访问，不依赖tomcat服务器。
        mapping:访问静态资源的uri地址，使用通配符 **
        location:静态资源在你的项目中的目录位置
	-->
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/html/**" location="/html/" />
    <mvc:resources mapping="/js/**" location="/js/" />

为了方便，一般把静态资源统一放在 static 文件夹下

所以一个标签语句就可以指定多个静态资源的访问路径（重点）：

<mvc:resources mapping="/static/**" location="/static/" />

地址分类

1 绝对地址：带有协议名称的，例如：http://www/baidu.com

2 相对地址，没有协议开头的，例如：user/some.do，/user/some.do
相对地址不能独立使用，必须有一个参考地址。通过参考地址+相对地址本身才能指定资源

3 参考地址

在你的页面中，访问地址不加 " / "

访问地址：http: //localhost:8080/06_path/index.jsp
路径：http: //localhost:8080/06_path/
资源：index.jsp

在index.jsp发起 user/some.do请求，访问地址变为http: //localhost:8080/06_path/test/some.do
在你的地址没有斜杠开头，例如：user/some.do，当你点击链接时，访问地址就是当前页面加上链接的地址
http: //localhost:8080/06_path/ + user/some.do

在你的页面中，访问地址加 " / "

访问地址：http: //localhost:8080/06_path/index.jsp
路径：http: //localhost:8080/06_path/
资源：index.jsp

点击 /user/some.do，访问地址变为：http: //localhost:8080/test/some.do
参考地址是你的服务器地址，也就是http: //localhost:8080

如果你的资源不能访问，加上：${pageContext.request.contextPath}，修改如下

//index.jsp
<body>
    <p>第一个springmvc项目</p>
    <p><a href="/test/some.do">发起/test/some.do的get请求</a></p>
    <br/>
</body>

//修改为
<body>
    <p>第一个springmvc项目</p>
    <p><a href="${pageContext.request.contextPath}/test/some.do">发起test/some.do的get请求</a></p>
    <br/>
</body>

则在网页访问：http: //localhost:8080/06_path/index.jsp 时，网页源码如下

此时点击请求，动态获取项目地址（06_path），页面正确显示如下：

前端的斜杠代表访问到端口号，后端的斜杠代表访问到工程名（也就是项目名下)

不加斜杠，就会相对地址栏路径加资源路径得到访问路径，请求转发可能会出错，有两种解决方案

1.${pageContext.request.contextPath}，在jsp页面中资源路径前加上这个

2.使用base便签，使参考地址改为base标签的地址，动态获取

SpringMVC核心技术

请求转发和重定向

ch08-forard-redirect:转发和重定向


springmvc框架把原来的servlet中的请求转发和重定向进行了封装，现在可以使用简单方式实现了。
    
forward：表示转发，实现request.getRequestDispatcher("xx.jsp").forward()
redirect：表示重定向，实现response.sendRedirect("xxx.jsp")

forward：表示转发

forward的主要用法可以转发到视图解析器以外的视图界面
redirect：表示重定向
forward和redirect都是关键字，有一个共同的特点不和视图解析器一同工作

当处理器对请求处理完毕后，向其他资源跳转时，有两种跳转方式：请求转发与重定向。而根据所要跳转的资源类型，又分为两类：跳转到页面与跳转到其他处理器。
注意，对于请求转发的页面，可以是 WEB-INF 中的页面；而重定向的页面，是不能为 WEB-INF中的页面。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资源的。

扩展：
forward和redirect他们都可以访问视图文件，比如某个jsp ，html
forward:/hello.jsp forward:/main.html

forward和redirect他们都可以访问其它的controller
forward:/some.do , redirect:/other.do

处理器方法可以返回ModelAndView, String , void 都可以使用forward，redirect

1、forward，请求转发

处理器方法返回 ModelAndView，实现转发 forward操作
语法：setViewName("forward:视图文件完整路径")
forward特点：不和视图解析器一同使用，就当项目中没有视图解析器

对应控制器

Controller
public class MyController {

    @RequestMapping(value = "/doForward.do")
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","-----欢迎使用spring mvc做web开发------" );
        mv.addObject("fun","执行的是doSome方法");

        //=====================重点===========================
        
        //使用视图解析器
        //mv.setViewName("show");
        
        //显式转发
        mv.setViewName("forward:WEB-INF/view/show.jsp");
        
        //=====================重点===========================
        
        return mv;
    }
}

2、redirect 重定向

处理器方法返回ModelAndView，实现转发redirect操作
语法：setViewName("redirect:视图文件完整路径")
redirect特点：不和视图解析器一同使用，就当作项目中没有视图解析器

<br/>

框架对重定向的操作：
1、框架会把model中的简单类型的数据，转为String使用，作为hello.jsp的get请求参数使用
   目的是在 doRedirect.do 和 hello.jsp 两次请求之间传递参数
       
2、在目标hello.jsp可以使用参数集合对象 $(param) 获取请求参数值，格式为：$(param.name)
       
3、重定向不能访问WEB-INF资源

对应控制器

@RequestMapping(value = "/doRedirect.do")
public ModelAndView doWithRedirect(String name,Integer age){
    ModelAndView mv = new ModelAndView();
    //数据放入到 request 作用域
    mv.addObject("name",name);
    mv.addObject("age",age);

     //=====================重点===========================
    
    //重定向
    mv.setViewName("redirect:hello.jsp");
    //http://localhost:8080/08_forward/hello.jsp?name=zhangsan&age=11
    
     //=====================重点===========================
    
    return mv;
}

hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp</h3><br/>
    <h3>name数据:${name}</h3>
    <h3>age数据:${age}</h3>
</body>
</html>

输入参数如下图

结果如下图

虽然网址上传递了参数，但name和age取不到参数，因为重定向是两次请求，参数在第一次请求的作用域里面，无法直接传递到第二个作用域。此时修改hello.jsp，直接访问第一次请求作用域里面的参数。

修改后的hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>show.jsp</h3><br/>
    <h3>name数据:${param.name}</h3>
    <h3>age数据:${param.age}</h3>
	
    <!--使用request对象中的getParameter方法，可以访问到第一次request作用域-->
    <h3>取参数数据：<%=request.getParameter("name")%></h3>
</body>
</html>

成功取到参数，如下图

异常处理

springmvc框架采用的是统一，全局的异常处理。把controller中的所有异常处理都集中到一个地方，采用的是aop思想，把业务逻辑和异常处理代码分开。也叫解耦（ou）合。
使用两个注解：1、ExceptionHandler 2、ControllerAdvice

ch09-exception-handler:异常处理

异常处理步骤：
1.新建maven web项目
2.加入依赖
3.新建一个自定义异常类 MyUserException,再定义它的子类NameException,AgeException
4.在controller抛出NameException,AgeException
5.创建一个普通类，作为全局异常处理类
    1）在类的上面加入@ControllerAdvice
    2)在类中定义方法，方法的上面加入@ExceptionHandler
6.创建处理异常的视图页面
7.创建springmvc的配置文件
1）组件扫描器，扫描@Controller注解
2）组件扫描器，扫描@ControllerAdvice所在的包名
3）声明注解驱动

项目结构如下

springmvc.xml，加入组件扫描器和注解驱动

    <!--处理需要的两步-->
    <context:component-scan base-package="com.bjpowernode.handler"/>
    <mvc:annotation-driven/>

MyController.java，控制器方法，向 MyUserException 抛出异常

/**
 * @RequestMapping:
 *    value ： 所有请求地址的公共部分，叫做模块名称
 *    位置： 放在类的上面
 */
@Controller
public class MyController {

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age) throws MyUserException {
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        //  try {

            //根据请求参数抛出异常
            if (!"zs".equals(name)) {
                throw new NameException("姓名不正确！！！");
            }

            if (age == null || age > 80) {
                throw new AgeException("年龄比较大！！！");
            }
        // }catch (Exception e){
        //    e.printStackTrace();
        //  }

        mv.addObject("myname",name);
        mv.addObject("myage",age);
        mv.setViewName("show");
        return mv;
    }

}

自定义异常类 MyUserException.java，继承 Exception

public class MyUserException extends Exception{
    public MyUserException() {
        super();
    }

    public MyUserException(String message) {
        super(message);
    }
}

子类 NameException.java

//表示当用户的姓名有异常，抛出NameException
public class NameException extends MyUserException{
    public NameException() {
        super();
    }

    public NameException(String message) {
        super(message);
    }
}

子类AgeException.java

//当年龄有问题时，抛出的异常
public class AgeException extends MyUserException{
    public AgeException() {
        super();
    }

    public AgeException(String message) {
        super(message);
    }
}

下面创建一个GlobalExceptionHandler.java，作为全局异常处理类

1、@ControllerAdvice

控制器增强 (可以理解为：增加控制器功能)，放在类上面
    
特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明 组件扫描器
指定 @ControllerAdvice 所在的全局异常处理类包名

2、@ExceptionHandler

@ExceptionHandler(异常的class)：表示异常的类型，当发生此类型的异常时，由当前方法处理。放在方法上面

处理异常的方法和控制器方法的定义一样，可以有多个参数，可以有ModelAndView，String，void，对象类型的返回值
形参：Exception，表示Controller中抛出的异常对象，通过形参可以获取发送的异常信息

GlobalExceptionHandler.java

/**
 * @ControllerAdvice :控制器增强（也就是说给控制器类增加功能--异常处理功能）
 *            位置：在类的上面。
 *    特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器.
 *    指定@ControllerAdvice所在的包名
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常
    /*
    * 处理异常的方法和控制器方法的定义一样，可以有多个参数，可以有ModelAndView,
    * String,void,对象类型的返回值
    *
    * 形参：Exception，表示controller中抛出的异常对象。
    * 通过形参可以获取发生的异常信息。
    *
    * @ExceptionHandler（异常的class）；表示异常的类型，当发生此类型异常时，
    * 由当前方法处理
    * */

    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception exception) {
        //处理NameException的异常。
        /*
         * 异常发生处理逻辑：
         * 1.需要把异常记录下来，记录到数据库，日志文件。
         *   记录日志发生的时间，哪个方法发生的，异常错误内容。
         * 2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
         * 3.给用户友好的提升。
         * */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "姓名必须是zs，其他用户不能访问");
        mv.addObject("ex", exception);
        mv.setViewName("nameError");
        return mv;
    }
    //处理AgeException
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception exception) {
        //处理AgeeException的异常。
        /*
         * 异常发生处理逻辑：
         * 1.需要把异常记录下来，记录到数据库，日志文件。
         *   记录日志发生的时间，哪个方法发生的，异常错误内容。
         * 2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
         * 3.给用户友好的提升。
         * */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "你的年龄不能大于80");
        mv.addObject("ex", exception);
        mv.setViewName("ageError");
        return mv;
    }

    //处理其他异常，NameException，AgeException以外，不知类型的异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception exception) {
        //处理其他异常。
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", "你的年龄不能大于80");
        mv.addObject("ex", exception);
        mv.setViewName("defaultError");
        return mv;
    }

}

拦截器

ctrl+alt+o可以合理的导入

拦截器说明：

拦截器是springmvc中的一种，需要实现HandlerInterceptor接口
拦截器和过滤器类似，功能方向侧重点不同。过滤器是用来过滤请求参数，设置编码字符集等。
拦截器是拦截用户的请求，可以对多个Controller做拦截。
拦截器是全局的，可以对多个Controller做拦截。
一个项目中可以有0个或多个拦截器，他们在一起拦截用户的请求。
拦截器常用在：用户登录处理，权限检查，记录日志。

拦截器的使用步骤：

1	定义普通类实现HandlerInterceptor接口，实现接口的三个方法
2	在springmvc文件中，声明拦截器，指定拦截请求的uri地址

拦截器的执行时间：

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

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

<!--声明拦截器：拦截器可以有0或多个-->
    <mvc:interceptors>
        <!--声明第一个拦截器-->
        <mvc:interceptor>
            <!--请求拦截的请求uri地址
                path：就是uri地址，可以使用通配符 **
                ** ：表示任意的字符，文件或者多级目录和目录中的文件。
                http://localhost:8080/myweb/user/listUser.do
                http://localhost:8080/myweb/student/addStudent.do
                -->
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.bjpowernode.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

创建一个MyInterceptor.java，作为拦截器类，继承自HandlerInterceptor，实现三个方法：preHandle，postHandle，afterCompletion

//拦截器类：；拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {
    private long btime = 0;
    /*
    * preHandle叫做预处理方法。
    *   重要：是整个项目的入口，门户。当preHandle返回true，请求可以被处理。
    *     preHandler控制请求是否执行
    *     proHandler返回false，请求到此方法就截止。
    *
    * 参数：
    *   object handler : 被拦截的控制器对象
    * 返回值boolean
    *   true：请求是通过了拦截器的验证，可以执行处理器方法。
    *         拦截器的MyInterceptor的preHandle（）
*             ====执行MyController中的doSome方法====
              拦截器的MyInterceptor的postHandle（）
              拦截器的MyInterceptor的afterCompletion（）
    *   false：请求没有通过拦截器的验证，请求到达拦截器就截止了。请求没有被处理。
    *          拦截器的MyInterceptor的preHandle（）
    *
    *   特点：
    *   1.方法在控制器方法（MyController的doSome)之前先执行的。
    *     用户的请求首先到底此方法
    *
    *   2.在这个方法中可以获取请求的信息，验证请求是否符合要求。
    *     可以验证用户是否登录，验证用户是否有权限访问某个连接地址（url）.
    *     如果验证失败，可以截断请求，请求不能被处理。
    *     如果验证成功，可以放行请求，此时控制器方法才能执行。
    */

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime = System.currentTimeMillis();
        System.out.println("拦截器的MyInterceptor的preHandle（）");
        //计算的业务逻辑，根据计算结果，返回true或者false
        //给浏览器一个返回结果
      //  request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    /*
       postHandle:后处理方法。
       参数：
        object handler：被拦截的处理器对象MyController
        ModelAndView modelAndView:处理器方法的返回值

        特点：
        1.在处理器方法之后执行的（MyController.doSome()）
        2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的数据和视图，可以影响到最后的执行结果。
        3.主要是对原来的执行结果做二次修正。
    */

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

    /*
        afterCompletion:最后执行的方法
        参数
            Object handler:被拦截器的处理器对象
            Exception ex:程序中发生的异常
        特点：
        1.在请求处理完成后执行的。框架中规定是当你的视图处理完成后，对视图执行了forward。就认为请求处理完成。
        2.一般做资源回收工作的，程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收。
     */
    @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));
    }
}

多个拦截器时

    <!--声明拦截器：拦截器可以有0或多个
        在框架中保存多个拦截器是ArrayList，
        按照声明的先后顺序放入到ArrayList
        -->
    <mvc:interceptors>
        <!--声明第一个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.bjpowernode.handler.MyInterceptor"/>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.bjpowernode.handler.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

第一个拦截器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()

当前拦截器的prehandler方法返回true，那么它的afterComletion方法一定会执行

拦截器和过滤器的区别

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

吃土大魔王

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
spring-mvc笔记

第一章：SpringMVC概述1.1SpringMVC简述SpringMVC也叫 spring web mvc .是spring的一部分，是在spring3.0后发布的1.2SpringMVC优点SpringMVC:基于spring的一个框架，实际上就是spring的一个模块，专门是做web开发的，理解为servlet的升级。web开发底层是servlet，框架是在servlet基础上面加入一些功能，让开发更方便。SpringMVC就是一个spring。spring是容器，i..
复制链接

扫一扫