SpringMVC一文详解

最新推荐文章于 2024-07-26 00:55:46 发布

柳落青

最新推荐文章于 2024-07-26 00:55:46 发布

阅读量392

点赞数

分类专栏： Spring及SpringMVC 文章标签： spring mysql java spring boot 后端

本文链接：https://blog.csdn.net/S0001100/article/details/108029499

版权

Spring及SpringMVC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringMVC详解

一：SpringMVC概述
二：SpringMVC注解式开发
三：SSM整合开发
- - **实现步骤：**
四：Spring核心技术

一：SpringMVC概述

1.SpringMVC：是基于spring的一个框架，实际上就是spring的一个模块，专门做web开发的。

可以理解为是servlet的一个升级。web开发底层是servlet，框架是在servlet基础上加入一些功能，让你做web开发方便。

SpringMVC就是一个Spring，Spring是容器，通过ioc能够管理对象，使用，或者注解的方式，

@Repository，@Component，@Service，@Controller。SpringMVC能够创建对象，放到容器中（SpringMVC容器），SpringMVC容器中放的是控制器对象。

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

使用@Controller注解创建的是一个普通类的对象，不是Servlet。但是SpringMVC赋予了控制器对象一些额外的功能。能够像Servlet一样接收请求，处理结果。

web开发底层是servlet，springMVC中有一个对象是servlet：DispatcherServlet()：叫做中央调度器

DispatcherServlet：负责接收用户的所有请求，用户把请求给了DispatcherServlet，之后DispatcherServlet把请求转发给我们Controller对象，最后是Controller对象处理请求。

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

1）第一个springMVC项目

需求：用户在页面发起一个请求，请求交给springMVC的控制器对象，
并显示请求处理结果（在结果页面显示一个欢迎语句）。

实现步骤：
1.新建web maven工程

2.加入依赖
spring-webmvc依赖，间接的把spring的依赖都加入到项目。
jsp，servlet依赖。

pom.xml：

<!--spring-mvc依赖，其中包括spring依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.5.RELEASE</version>
</dependency>

<!--servlet依赖-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

<!--jsp依赖-->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.1</version>
    <scope>provided</scope>
</dependency>

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

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/dispatcher-servlet.xml]
    -->
    <servlet>
        <servlet-name>dispatcher</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>dispatcher</servlet-name>
        <!--
            使用框架的时候，url-pattern可以使用两种值
                1.使用扩展名方式，语法：*.xxxx，xxxx是自定义的扩展名，常用的方式 *.do *.action *.mvc等等

                2.使用斜杠"/"

	意思是：只要是.do结尾的，都交给中央调度器处理
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

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

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

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

/**
 * @Controller 创建控制器对象，对象放在springmvc的容器中
 *  位置：在类的上面
 *  和spring中讲的@Service，@Component一样
 *   
 *   能处理亲请求的都是控制器（处理器）：myController能处理请求，叫做后端控制器(back controller)
 */
@Controller
public class MyController {

    /*
        处理用户提交的请求，springMVC中使用方法来处理的。
            方法是自定义的，可以有多种返回值，多种参数，方法名称自定义。
     */

    /**
     * 准备使用doSome方法处理some.do的请求
     * @RequestMapping 请求映射，作用是把一个请求地址和一个方法绑定在一起。
     *                  一个请求指定一个方法处理
     *            属性：1.value 是一个String，表示请求的uri地址的(some.do)。
     *                    value的值必须是唯一的，不能重复。在使用时，推荐地址以"/"开头
     *            位置：1.在方法的上面，常用的。
     *                  2.在类上面
     *
     *            说明：使用RequestMapping修饰的方法叫做处理器方法或者控制器方法。
     *            使用@RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet，doPost
     *
     *      返回值：ModelAndView  表示本次请求的处理结果
     *          Model：数据，请求处理完成后，要显示给用户的数据
     *          View：视图，比如jsp等等。
     * @return
     */
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        System.out.println("doSome方法执行了");
        //在这里就可以处理some.do的请求了。
        ModelAndView mv = new ModelAndView();
        //添加数据，框架在请求的最后把数据放入到request作用域中。
        //相当于request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg","欢迎使用springmvc做web开发");

        //指定视图
        //框架对视图执行的forward操作，相当于是		request.getRequestDispather("/show.jsp").forward(..);
        //当配置了视图解析器后，可以使用逻辑名称(文件名)，指定视图。
        //框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完整的路径，这里就是字符串连接操作。
        ///WEB-INF/view/ + show + .jsp
        mv.setViewName("show");

        //返回mv
        return mv;
    }
}

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>msg数据：${msg}</h3>
</body>
</html>

7.创建spring的配置文件（spring配置文件一样）
1）声明组件扫描器，指定@Controller注解所在的包名

<!--声明组件扫描器-->
<context:component-scan base-package="com.sss.controller"/>

2）声明视图解析器：帮助处理视图的。防止恶意访问。

    <!--声明 springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

2）SpringMVC请求处理流程

1）用户发起请求some.do

2）tomcat(web.xml–url-pattern知道 *.do的请求是给DispatcherServlet(中央调度器))

3）DispatcherServlet根据springmvc.xml配置文件，知道dome.do—>doSome()方法

4）DispatcherServlet(中央调度器)把some.do转发给MyController.doSome()方法。

5）框架执行doSome()方法，把得到的ModelAndView进行处理，转发到show.jsp

3）spring执行过程源码分析

1.tomcat启动，创建容器的过程

通过load-on-start标签指定的1，创建DisaptcherServlet对象。

DisaptcherServlet它的父类是继承HttpServlet的，它是一个servlet，在被创建时，会执行init()方法。

在init()方法中会执行：

//创建容器，读取配置文件
WebApplicationContext ctx = new ClassPathXmlApplicationContext("springmvc.xml");
//把容器对象放入到ServletContext中
getServletContext().setAttribute(key,ctx);

上面创建容器的作用：创建@Controller注解所在的类的对象，也就是创建MyController对象。

这个对象放入到springmvc的容器中，容器是map，类似map.put(“myControll，er”,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的核心方法，所有的请求都在这个方法中完成的。

4）SpringMVC的执行流程

流程图：

在这里插入图片描述

执行流程简单分析：

（1）浏览器提交请求到中央调度器

（2）中央调度器直接将请求转给处理器映射器。

（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链(HandlerExecutionChain)后返回给中央调度器。

HandlerExecutionChain：类中保存着：1.处理器对象(MyController) 2.项目中所有的拦截器List

（4）中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。

（5）处理器适配器调用执行处理器。

（6）处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中，并将其返回给

处理器适配器。

（7）处理器适配器直接将结果返回给中央调度器。

（8）中央调度器调用视图解析器，将 ModelAndView 中的视图名称封装为视图对象。

（9）视图解析器将封装了的视图对象返回给中央调度器

（10）中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。

（11）中央调度器响应浏览器。

二：SpringMVC注解式开发

1）@RequestMapping 定义请求规则

指定模块名称

多个相关功能对应一个控制器类

/**
 * @RequestMapping
 *  value：所有请求地址的公共部分，叫做模块名称
 *  位置：放在类上面
 */
@RequestMapping(value = "/test")
@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(){
        ModelAndView mv = new ModelAndView();
        //添加数据
        mv.addObject("msg","欢迎使用springmvc做web开发");
        //指定视图
        mv.setViewName("show");
        return mv;
    }

    @RequestMapping(value = "/other.do")
    public ModelAndView doOther(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发!!!");
        mv.setViewName("show");
        return mv;
    }
}

2）method属性

对于@RequestMapping，其有一个属性 method，用于对被注解方法所处理请求的提交

方式进行限制，即只有满足该 method 属性指定的提交方式的请求，才会执行该被注解方法。

Method 属性的取值为 RequestMethod 枚举常量。常用的为 RequestMethod.GET 与

RequestMethod.POST，分别表示提交方式的匹配规则为 GET 与 POST 提交。

@RequestMapping(value = "/test")
@Controller
public class MyController {
    /**
     * @RequestMapping 请求映射
     *      属性：method，表示请求的方式，它的值是RequestMethod类枚举值
     *          例如表示get请求方式，RequestMethod.GET，post方式，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.setViewName("show");
        return mv;
    }
}

以上处理器方法只能处理 POST 方式提交的请求。客户端浏览器常用的请求方式，及其

提交方式有以下几种：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ag9ChO9w-1597502002544)(E:\桌面\总结知识点及案例及帮助文档\Snipaste_2020-08-01_12-54-20.png)]

3）处理器方法的参数

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

员可在方法内直接使用。

➢ HttpServletRequest

➢ HttpServletResponse

➢ HttpSession

➢ 请求中所携带的请求参数（用户提交的参数）

1）逐个参数接收

@RequestMapping(value = "/test")
@Controller
public class MyController {
    /**
     * 逐个接收请求参数：
     *      要求：处理器方法的形参名和请求参数中参数名相同，同名的请求参数赋值给同名的形参
     *
     * 框架接收请求参数
     *    1.使用request对象接收请求参数
     *      String strName = request.getParameter("myname");
     *      String strAge = request.getParameter("myage");
     *    2.springmvc框架通过DispatcherServlet 调用 MyControlle的doSome()
     *      调用方法时，按名称对应，把接收的参数赋值给形参
     *      doSome(strName,Integer.valueOf(strAge));
     *      框架会提供类型转换的功能，能把String转为int,long,float,double类型。
     */
    @RequestMapping(value = "/some.do",method = RequestMethod.POST)
    public ModelAndView doSome(String name,Integer age){
        ModelAndView mv = new ModelAndView();
        //添加数据
        mv.addObject("myname",name);
        mv.addObject("myage",age);
        System.out.println(name);
        System.out.println(age);
        //指定视图
        mv.setViewName("show");
        return mv;
    }
}

2）校正请求参数名@RequestParam

/**
 * 请求参数名和处理器方法的形参名不一样
 * @RequestParm 解决请求中参数名和形参名不一样的问题。
 *  属性：1.value 请求中的参数名称
 *        2.required 是一个布尔类型，默认是true
 *              true：表示请求中必须包含此参数。如果没有参数，直接报错400
 *              false：表示请求中没有包含此参数，也不会报错。
 *  位置：在处理方法的形参定义的前面
 */
@RequestMapping(value = "/other.do",method = RequestMethod.POST)
public ModelAndView doOther(@RequestParam(value = "rname")String name,
                            @RequestParam(value = "rage") Integer age){
    ModelAndView mv = new ModelAndView();
    //添加数据
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    //指定视图
    mv.setViewName("show");
    return mv;
}

3）对象接收参数

/**
 * 处理器方法形参是java对象，要求这个对象的属性名和请求中参数名一样的。
 * 框架会创建形参的java对象，给属性赋值，请求中的参数是name，框架会调用setName()
 */
@RequestMapping(value = "/three.do",method = RequestMethod.POST)
public ModelAndView doThree(Student myStudent){
    ModelAndView mv = new ModelAndView();
    //添加数据
    mv.addObject("myname",myStudent.getName());
    mv.addObject("myage",myStudent.getAge());
    //指定视图
    mv.setViewName("show");
    return mv;
}

4）过滤器解决post方式乱码

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

使用框架提供的过滤器：

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）使用encoding编码的值-->
  <init-param>
    <param-name>forceResponseEncoding</param-name>
    <param-value>true</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>characterEncodingFilter</filter-name>
  <!--
    /*：表示强制所有的请求，先通过过滤器处理。
  -->
  <url-pattern>/*</url-pattern>
</filter-mapping>

5）处理器方法的返回值

使用@Controller 注解的处理器的处理器方法，其返回值常用的有四种类型：

➢ 第一种：ModelAndView

➢ 第二种：String

➢ 第三种：无返回值 void

➢ 第四种：返回自定义类型(Object)对象

1）ModelAndView作为返回值：

有数据和视图，对视图执行forward

…

2）String作为返回值：

表示视图，可以是逻辑名称，也可以是完整视图路径，需要配置视图解析器

注意：如果是完整视图路径，不可以配置视图解析器。

/**
 * 处理方法返回String--表示逻辑视图名称，需要配置视图解析器
 */
@RequestMapping(value = "/returenString-view.do",method = RequestMethod.POST)
public String doSome(String name,Integer age){
    System.out.println(name);
    System.out.println(age);
    //show ：逻辑视图名称，项目中配置了视图解析器。
    //框架对视图执行的是forward转发操作。
    return "show";
}

springMVC配置文件中：设置视图解析器

<!--声明 springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀：视图文件的路径-->
    <property name="prefix" value="/WEB-INF/view/"/>
    <!--后缀：视图文件的扩展名-->
    <property name="suffix" value=".jsp"/>
</bean>

3）返回void:

不能表示数据，也不能表示视图。

在处理ajax的时候，可以使用void返回值。通过HttpServletResponse输出数据，响应ajax请求。
ajax请求服务器端返回的就是数据，和视图无关

控制器方法：

/**
 * 处理方法返回void，处理ajax请求
 */
@RequestMapping(value = "/returenVoid-ajax.do")
public void doSome2(String name, Integer age, HttpServletResponse response) throws IOException {
    //处理ajax，使用json做数据的格式
    //就当service调用完后了，使用Student表示处理结果
    Student student = new Student();
    student.setName(name);
    student.setAge(age);

    String json = "{}";
    //将java对象转为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 pw = response.getWriter();
    pw.print(json);
    pw.flush();
    pw.close();
}

ajax：

<script type="text/javascript">
    /*入口*/
    $(function () {
        $("#bth").click(function () {
            $.ajax({
                url:"test/returenVoid-ajax.do",
                data:{
                    name:"zhangsan",
                    age:"20"
                },
                dataType:"json",
                success:function (resp) {
                    //resp从服务器返回的是json格式的字符串，{"name":"zhangsan","age":20}
                    //jquery会把字符串转为json对象，赋值给resp形参。
                    alert(resp.name + resp.age);
                }
            })
        })
    })
</script>

处理json数据需要用到jackson依赖：

<!--jackson依赖，处理JSON的-->
<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>

4）返回对象 Object

处理器方法也可以返回 Object 对象。这个 Object 可以是 Integer，String，自定义对象，

Map，List 等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出

现的。

返回对象，需要使用@ResponseBody 注解，将转换后的 JSON 数据放入到响应体中

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

    现在做ajax，注意使用json的数据格式，实现步骤：
        1.加入处理json的工具库的依赖，springMVC默认使用的是jackson。
        2.在springMVC配置文件中加入<mvc:annotation-driven> 注解驱动。
        3.在处理器方法的上面加入@ResponseBody注解

  springMVC处理器方法返回Object，可以转换为json输出到浏览器，响应Ajax的内部原理
    1.<mvc:annotation-driven/> 注解驱动。
        注解驱动实现的功能是 完成Java对象到json xml text 二进制等数据格式的转换
        
        <mvc:annotation-driven/>在加入到springmvc配置文件后，会自动创建HttpMessageConcerter接口	的7个实现类对象，包括 MappingJackson2HttpMessageConverter （使用jackson工具库中的		
   ObjectMapper实现Java对象转换为json字符串）
        
        HttpMessageConverter接口：消息转换器。
        功能：定义了java转为json，xml等数据格式的方法，这个接口有很多的实现类。
            这个实现类完成 java对象到json java对象到xml java对象到二进制数据的转换。
            
     2.@ResposeBody注解
       放在处理器的上面，通过HttpServletResponse输出数据，来响应Ajax请求的。
          相当于：   PrintWriter pw = response.getWriter();
                    pw.print(json);
                    pw.flush();
                    pw.close();

    /**
     * 处理器方法返回一个Student，通过框架转为json，响应ajax请求
     *  @ResponseBody
     *      作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
     *      位置在方法的定义上面，和其他注解没有顺序的先后关系。
     *
     *  返回对象框架的处理流程：
     *      1.框架会把返回的Stduen类型，调用框架中的ArrayList<HttpMessageConverter>集合中每个类的canWrite()
     *          来检查那个HttpMessageConverter(消息转换器)接口的实现类能处理Student类型的数据。
     *      2.框架会调用实现类的write()，MappingJackson2HttpMessageConverter的write()方法，
     *          把张三同学的Student对象转为json，调用jackson的ObjectMapper实现转为json。
     *      3.框架会调用@ResponseBody把结果数据输出到浏览器，ajax请求处理完成。
     */
@RequestMapping(value = "/returenStudent-ajax.do")
@ResponseBody
public Student doStudentJsonObejce(String name, Integer age, HttpServletResponse response) {
    System.out.println("returenStudent-ajax.do");
    //调用service，获取请求结果数据，studen对象就表示处理结果数据
    Student student = new Student();
    student.setName(name);
    student.setAge(age);
    return student; //会被框架转为json
}

5）返回List集合

控制器：

/**
 * 处理器方法返回List<Student>
 *    处理流程和上面返回json数据是一样的
 */
@RequestMapping(value = "/returenStudentArray-ajax.do")
@ResponseBody
public List<Student> doStudentJsonObejceArray(String name, Integer age) {
    List<Student> list = new ArrayList<>();
    //调用service，获取请求结果数据，studen对象就表示处理结果数据
    Student student = new Student();
    student.setName("张三");
    student.setAge(23);
    list.add(student);

    student = new Student();
    student.setName("李四");
    student.setAge(20);
    list.add(student);

    return list; //会被框架转为json对象数组
}

jsp：

<script type="text/javascript">
    /*入口*/
    $(function () {
        $("#bth").click(function () {
            $.ajax({
                url:"test/returenStudentArray-ajax.do",
                data:{
                    name:"张三",
                    age:"20"
                },
                dataType:"json",
                success:function (resp) {
                //[{"name":"张三","age":23},{"name":"李四","age":20}] resp现在是json对象数组
                    //循环输出
                    $.each(resp,function (i,n) {
                        alert(n.name+"   "+n.age);
                    })
                }
            })
        })
    })
</script>

6）返回值是字符串

若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若

返回的字符串中带有中文字符，则接收方页面将会出现乱码。此时需要使用

@RequestMapping 的 produces 属性指定字符集。

produces，产品，结果，即该属性用于设置输出结果类型

/**
 * 处理器方法返回的是String，String表示数据的，不是视图
 * 区分返回值String是数据，还是视图，看有没有@ResponseBody注解
 *  如果有@ResponseBody注解，返回的是数据，反之就是视图
 *
 *  默认使用"text/plain;charset=ISO-8859-1"作为ConType，导致中文有乱码
 * 解决方案：
 *  使用 @RequestMapping 的 produces 属性指定字符集。
 *          produces，产品，结果，即该属性用于设置输出结果类型。"text/plain;charset=utf-8"
 */
@RequestMapping(value = "/returenString-ajax.do",produces = "text/plain;charset=utf-8")
@ResponseBody
public String doString(String name, Integer age) {


    return "Hello SpringMVC 李四"; //会被框架转为json
}

<script type="text/javascript">
    /*入口*/
    $(function () {
        $("#bth").click(function () {
            $.ajax({
                url:"test/returenString-ajax.do",
                data:{
                    name:"张三",
                    age:"20"
                },
                dataType:"text",
                success:function (resp) {
                    alert("返回的是文本数据"+resp);
                }
            })
        })
    })
</script>

6）解读<url-pattern/>

保持的值为 *.do，扩展名方式，图片会正常显示。

将的值修改为 / ，则图片将无法显示。

1）处理静态资源的方式：

web.xml文件：

<!--声明，注册springmvc的核心对象DispatcherServlet(中央调度器)-->
<servlet>
  <servlet-name>dispatcher</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>
  <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
  <servlet-name>dispatcher</servlet-name>
  <!--
    使用框架的时候，url-pattern可以使用两种值
        1.使用扩展名方式，语法：*.xxxx，xxxx是自定义的扩展名，常用的方式 *.do *.action *.mvc等等

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

           动态资源some.do是可以访问的，因为程序中有MyController控制器对象，能处理some.do的请求。

      意思是：只要是.do结尾的，都交给中央调度器处理
  -->
  <url-pattern>/</url-pattern>
</servlet-mapping>

springMVC配置文件：第一种处理静态资源的方式

<!--
    第一种处理静态资源的方式：
        需要在springMVC配置文件中加入<mvc:default-servlet-handler>
        原理是：加入这个标签后，框架会创建控制器对象DefaultServletHttpRequestHandler
                （类似于我们自己创建的MyController）
                DefaultServletHttpRequestHandler这个对象可以把接收到的请求转发给 tomcat的
                default这个servlet。
-->
<mvc:default-servlet-handler/>

springMVC配置文件：第二种处理静态资源的方式：(常用)

<!--
    第二种处理静态资源的方式：
        在springMVC配置文件中加入：<mvc:resources mapping="" location=""/>
        加入以后，框架会创建ResourceHttpRequesHandler这个处理器对象
        让这个对象处理静态资源的访问，不依赖tomcat服务器（常用）
        mapping：访问静态资源的uri地址，使用通配符 **
        location：静态资源在项目中的目录位置。
        /img/**：表示 img/p1.jpg等等。可以表示一级目录或者多级目录。
-->
<mvc:resources mapping="/img/**" location="/img/"/>
<mvc:resources mapping="/js/**" location="/js/"/>

2）一条配置处理所有的静态资源

新建一个static目录，把所有的静态资源放进去。

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

3）相对路径和绝对路径

在jsp和html中使用的地址，都是在前端页面中的地址，都是相对地址

地址分类：

1.绝对地址，带有协议名称的是绝对地址，http://www.baidu.com，ftp://202.122.23.1

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

3.参考地址

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

访问的是：http://localhost:8080/ch06_path/index.jsp

路径：http://localhost:8080/ch06_path/

资源：index.jsp

在index.jsp发起 test/some.do请求，访问地址变为：http://localhost:8080/ch06_path/test/some.do

当你的地址没有斜杠开头，例如：test/some.do，当你点击这个连接时，访问地址是当前页面的地址，加上你连接的地址。http://localhost:8080/ch06_path/ + user/some.do

访问地址不加"/" 也会有一定的错误，解决方案：

1.加入${pageContext.request.contextPath}

2.在头部加入一个base标签，是html语言中的标签，表示当前页面中访问地址的基地址。

你的页面中所有，没有 ”/“ 开头的地址，都是以base标签中的地址为参考地址。

使用base中的地址 + test/some.do 组成访问地址

静态获取基地址：

<head>
    <title>Title</title>
    <base href="http://localhost:8080/ch06_path/"/>
</head>

动态获取基地址：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>Title</title>
    <base href="<%=basePath%>"/>
</head>

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

访问的是：http://localhost:8080/ch06_path/index.jsp

路径：http://localhost:8080/ch06_path/

资源：index.jsp

在index.jsp发起 /test/some.do请求，访问地址变为：http://localhost:8080/test/some.do

此时你的参考地址就是你的服务器地址：http://localhost:8080

在使用 ”/“ 的时候，可以使用：EL表达式解决这个问题。

pageContext.request.contextPath：代表的是项目名称。

<a href="${pageContext.request.contextPath}/test/some.do">发起some.do请求</a>

三：SSM整合开发

ssm：SpringMVC + Spring + MyBatis

SpringMVC：视图层，界面层，负责接收请求，显示处理结果的。
Spring：业务层，管理service，dao，工具类对象的。
MyBatis：持久层，用来访问数据库的。

用户发起请求–springMVC接收请求–Spring中的service对象处理业务–MyBatis处理数据

ssm整合也叫ssi（IBatis也就是myBatis的前身），整合中有容器。
1.第二个容器SpringMVC容器，管理Controller控制器对象的。
2.第二个容器Spring容器，管理service,dao工具类对象的。
我们要做的是把使用的对象交给合适的容器创建管理，把Controller还有web开发的相关对象，
交给springmvc容器，这些web用的对象写在springmvc配置文件中。

SpringMVC容器和Spring容器是有关系的，关系已经确定好了。
SpringMVC容器是Spring容器的子容器，类似于java中的继承。
子可以访问父的内容，在子容器中的Controller可以访问父容器中的service对象，
就可以实现Controller使用service对象。

实现步骤：
0.使用springdb库中的student表。
1.新建maven项目
2.加入依赖
springmvc，spring，mybatis三个框架的依赖，jackson依赖，MySQL驱动，druid连接池
jsp，servlet依赖
3.写web.xml文件
1）注册DispatcherServlet（中央调度器）目的，1.创建springmvc容器对象，才能创建Controller类的对象
2.创建的是Servlet，才能接收用户的请求。
2）注册spring的监听器：ContextLoaderListener，目的：创建spring容器，才能创建service，dao等对象。
3）注册字符集过滤器，解决post请求乱码的问题。

4.创建包，Controller包，service包，dao，实体类

5.写springmvc，spring，myBatis，数据库，配置文件

6.写代码，dao接口和mapper文件，service和实体类

7.写jsp文件。

实现步骤：

1）加入依赖：pom.xml

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

<!--spring-mvc依赖，其中包括spring依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<!--servlet依赖-->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>4.0.1</version>
  <scope>provided</scope>
</dependency>

<!--jsp依赖-->
<dependency>
  <groupId>javax.servlet.jsp</groupId>
  <artifactId>jsp-api</artifactId>
  <version>2.1</version>
  <scope>provided</scope>
</dependency>

<!--myBatis依赖-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.5</version>
</dependency>

<!--mybatis和spring集成的依赖-->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.1</version>
</dependency>

<!--mySql驱动-->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.49</version>
</dependency>

<!--spring依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<!--做spring事务用到的-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<!--为了使用监听器对象，加入依赖-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

<!--阿里公司的数据库的连接池-->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.12</version>
</dependency>

<!--jackson依赖，处理JSON的-->
<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）定义包，组织程序的结构

entity，dao，controller，service

3）编写配置文件：

jdbc.properteis

jdbc.url=jdbc:mysql://localhost:3306/springdb
jdbc.user=root
jdbc.password=999

applicationContext配置文件：spring配置文件：

<?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.sss.service"/>

    <!--引入数据库配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--声明数据源DataSource，连接数据库-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库信息-->
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <!--最大连接数-->
        <property name="maxActive" value="20"/>
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory的-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池赋给了dataSource属性-->
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis主配置文件的位置-->
        <property name="configLocation" value="classpath:myBatis.xml"/>
    </bean>

    <!--创建dao对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--指定包名，得到每个接口的dao对象-->
        <property name="basePackage" value="com.sss.dao"/>
    </bean>
</beans>

springMVC配置文件:

<?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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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 http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--声明组件扫描器-->
    <context:component-scan base-package="com.sss.controller"/>

    <!--声明 springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--创建MVC注解驱动，注意有重复的，别加错了，结尾是mvc的才是正确-->
    <mvc:annotation-driven/>

    <!--处理静态资源-->
    <mvc:resources mapping="/static/**" location="/static/"/>
</beans>

MyBatis配置文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--settings：控制myBatis全局行为-->
    <!--<settings>
        &lt;!&ndash;设置myBatis输出日志&ndash;&gt;
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>-->

    <!-- sql mapper（sql映射文件）的位置-->
    <mappers>
        <package name="com.sss.dao"/>
    </mappers>
</configuration>

4）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">

    <!--声明注册DispatcherServlet（中央调度器）-->
    <servlet>
        <servlet-name>dispatcher</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>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--使用斜杠"/"，必须在springmvc配置文件中处理静态资源-->
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


    <!--注册监听器ContextLoaderListener-->
    <context-param>
        <!--contextConfigLocation：表示配置文件的路径-->
        <param-name>contextConfigLocation</param-name>
        <!--自定义配置文件的路径-->
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>
            org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

    <!--注册字符集过滤器，解决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）使用encoding编码的值-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <!--
          /*：表示强制所有的请求，先通过过滤器处理。
        -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

5）处理器定义（controller）

@Controller
public class StudentController {
    @Autowired
    private StudentService studentService;

    /**注册学生信息*/
    @RequestMapping(value = "/stuAdd")
    public ModelAndView stuInsert(Student student){
        ModelAndView am = new ModelAndView();
        int count = studentService.stuInsert(student);
        if (count > 0){
            am.addObject("msg","注册成功！");
            am.setViewName("sucsess");
        }else {
            am.addObject("msg","注册失败！");
            am.setViewName("fail");
        }
        return am;
    }

    /**响应ajax，输出数据，查询方法*/
    @RequestMapping(value = "/stuSelect")
    @ResponseBody
    public List<Student> stuSele(){
        List<Student> students = studentService.stuList();
        for (Student student: students){
            System.out.println(student);
        }
        return students;
    }
}

6）定义视图

首页：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    String basePath = request.getScheme() + "://" +
            request.getServerName() + ":" + request.getServerPort() +
            request.getContextPath() + "/";
%>
<html>
<head>
    <title>Title</title>
    <base href="<%=basePath%>"/>
</head>
<body>
    <center>
        <h3>SSM整合开发-实现Student表的操作</h3>
        <a href="stuSelect.jsp">查询学生信息</a>
        <a href="stuSelect">查询学生信息2</a>
        <br/>
        <a href="stuInsert.jsp">注册学生信息</a>
    </center>
</body>
</html>

注册界面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<center>
    <form method="post" action="stuAdd">
        姓名：<input type="text" name="name">
        <br/>
        年龄：<input type="text" name="age">
        <br/>
        <input type="submit" value="注册">
    </form>
</center>
</body>
</html>

四：Spring核心技术

1）请求转发和重定向

注意，对于请求转发的页面，可以是WEB-INF中页面；而重定向的页面，是不能为WEB-INF

中页的。因为重定向相当于用户再次发出一次请求，而用户是不能直接访问 WEB-INF 中资

源的。

1）请求转发（forward）

处理器方法返回 ModelAndView 时，需在 setViewName()指定的视图前添加 forward:，且

此时的视图不再与视图解析器一同工作，这样可以在配置了解析器时指定不同位置的视图。

**视图页面必须写出相对于项目根的路径。**forward 操作不需要视图解析器。

处理器方法返回 String,在视图路径前面加入 forward: 视图完整路径。

/**
 * 处理器方法返回ModelAndView，实现转发forward
 *  语法：setViewName("forward:视图文件完整路径");
 *  forward特点：不和视图解析器一同使用，就当项目中没有视图解析器。
 */
@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age){
    ModelAndView mv = new ModelAndView();
    //添加数据
    mv.addObject("msg","欢迎使用springmvc做web开发");
    //指定视图
    //加forward，是显示转发
    //mv.setViewName("forward:/WEB-INF/view/show.jsp");
    mv.setViewName("forward:/hello.jsp");
    return mv;
}

2）重定向（redirect）

 /**
     * 处理器方法返回ModelAndView，实现重定向redirect
     *  语法：setViewName("redirect:视图完整路径");不能使用逻辑视图名称。
     *  redirect特点：不和视图解析器一同使用，就当项目中没有视图解析器。
     *
     *  框架对重定向的操作：
     *      1.框架会把Model中的简单类型的数据，转为String使用，作为hello.jsp的get请求参数使用。
     *          并显示在地址栏，目的是在other.do 和 hello.jsp 两次请求之间传递数据。
     *      2.在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
     *          ${param.myname}
     */
@RequestMapping(value = "/other.do")
public ModelAndView doOther(String name,Integer age){
    ModelAndView mv = new ModelAndView();
    mv.addObject("msg","欢迎使用springmvc做web开发!!!");
    
    //重定向不能访问受保护的WEB-INF目录下的资源
    //mv.setViewName("redirect:/WEB-INF/view/show.jsp");

    //重定向
    mv.setViewName("redirect:/hello.jsp");
    return mv;
}

<h3>name数据：${param.myname}</h3>
<h3>age数据：${param.myage}</h3>
<h3>取参数数据：<%=request.getParameter("myage")%></h3>

2）异常处理

springMVC框架采用的是统一，全局的异常处理。

把controller中所有的异常处理都集中到一个地方，采用的aop的思想。把业务逻辑和异常处理代码分开，解耦合。

使用两个注解：

1）@ExceptionHandler

使用注解@ExceptionHandler 可以将一个方法指定为异常处理方法。该注解只有一个可

选属性 value，为一个 Class<?>数组，用于指定该注解的方法所要处理的异常类，即所要匹

配的异常。

而被注解的方法，其返回值可以是 ModelAndView、String，或 void，方法名随意，方法

参数可以是 Exception 及其子类对象、HttpServletRequest、HttpServletResponse 等。系统会

自动为这些方法参数赋值。

对于异常处理注解的用法，也可以直接将异常处理方法注解于 Controller 之中。

2）@ControllerAdvice

3）异常处理步骤：

新建maven项目，配置web.xml，pom.xml省略

1.新建一个自定义异常类，MyUserException，再定义它的子类NameException，AgeException

2.在controller中抛出NameExcepetion，AgeException

3.创建一个普通类，作为全局异常处理类。
1）在类的上面加入@ControllerAdvice
2）在类中定义方法，方法的上面加入@ExceptionHandler

4.创建处理异常的视图页面

5.创建springmvc的配置文件
1）组件扫描器，扫描@Controller注解
2）组件扫描器，扫描@ControllerAdvice所在的包
3）声明注解驱动

自定义异常类：

//父异常类
public class MyUserExcepetion extends Exception {
    public MyUserExcepetion() {
        super();
    }

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

controller中抛出异常：

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

    @RequestMapping(value = "/some.do")
    public ModelAndView doSome(String name,Integer age) throws MyUserExcepetion {
        ModelAndView mv = new ModelAndView();

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

        if (age == null || age > 80){
            throw new AgeException("年龄比较大了");
        }

        //添加数据
        mv.addObject("myName",name);
        mv.addObject("myAge",age);
        //指定视图
        mv.setViewName("show");
        return mv;
    }
}

定义异常响应页面：

<h2>nameError.jsp</h2>
<h3>提示信息：${msg}</h3>
<h3>系统异常消息：${exception.message}</h3>

定义全局异常处理类：

/**
 * @ControllerAdvice 控制器增强（也就是说给控制器类增加功能，增加的是异常处理功能）
 *      位置：在类的上面
 *      特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件中声明组件扫描器。
 *          指定@ControllerAdvice所在的包名。
 */
@ControllerAdvice
public class GlobalExcepetionHandler {
    //定义方法，处理发生的异常
    /**
     * 处理异常的方法和控制器方法的定义一样，可以有多个参数，可以有ModelAndView，String
     *  void，对象类型的返回值
     *
     *  形参：Exception 表示Controller中抛出的异常对象。
     *      通过形参可以获取发生的异常信息。
     *
     *  @ExceptionHandler (异常的class)：表示异常的类型，当发生此类型异常时，
     *      由当前方法处理。
     *
     *      位置：方法的上面
     */
    @ExceptionHandler(value = NameExcepetion.class)
    public ModelAndView doNameExcepetion(Exception ex){
        //处理NameException的异常
        /*
            异常发生处理逻辑：
                1.需要把异常记录下来，记录到数据库，或者是日志文件。
                    记录异常发生的时间，那个方法发生的，还有异常的错误内容。
                2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
                3.给用户友好的提示
         */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","姓名必须是张三！");
        mv.addObject("exception",ex);
        mv.setViewName("nameError");
        return mv;
    }

    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeExcepetion(Exception ex){
        //处理NameException的异常
        /*
            异常发生处理逻辑：
                1.需要把异常记录下来，记录到数据库，或者是日志文件。
                    记录异常发生的时间，那个方法发生的，还有异常的错误内容。
                2.发送通知，把异常的信息通过邮件，短信，微信发送给相关人员。
                3.给用户友好的提示
         */
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","您的年龄不能大于80！");
        mv.addObject("exception",ex);
        mv.setViewName("nameError");
        return mv;
    }

    /**
     * 处理其他异常，NameException，AgeException以外，不知类型的异常。
     *       @ExceptionHandler 后边不加value
     */
    @ExceptionHandler
    public ModelAndView doOtherExcepetion(Exception ex){
        //处理其他异常
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","出现异常！");
        mv.addObject("exception",ex);
        mv.setViewName("defaultError");
        return mv;
    }
}

定义SpringMVC配置文件：

<!--声明组件扫描器-->
<context:component-scan base-package="com.sss.controller"/>

<!--声明 springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--前缀：视图文件的路径-->
    <property name="prefix" value="/WEB-INF/view/"/>
    <!--后缀：视图文件的扩展名-->
    <property name="suffix" value=".jsp"/>
</bean>

<!--处理异常需要的两步
        1.声明组件扫描器
        2.声明注解驱动
-->
<context:component-scan base-package="com.sss.handler"/>
<mvc:annotation-driven/>

3）拦截器

1）一个拦截器的执行

1）拦截器概述

SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定Java 框架 SpringMVC

的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要

执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在

处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央

调度器。

拦截器：

1）是SpringMVC中的一种，需要实现HandlerInterceptor接口。

2）拦截器和过滤器类似，功能方向侧重点不同。

过滤器是用来过滤请求参数，设置编码字符集等工作的。

拦截器是拦截用户的请求，对请求做判断处理的。

3）拦截器是全局的，可以多个Controller做拦截。

一个项目中可以有0个或者多个拦截器，他们在一起拦截用户的请求。

拦截器常用在：用户的登录处理，权限的检查，记录日志。

2）拦截器的使用步骤

1.定义类实现HandlerInterceptor接口，并重写接口中的三个方法。

public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //计算得业务逻辑，根据计算结果，返回true或者false。
        System.out.println("拦截器的preHandle方法");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request,HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截的postHandle方法");
    }

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

2.在springMVC配置文件中，声明拦截器，让框架知道拦截器的存在。

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

3）拦截器的执行时间

1）在请求处理之前，也就是Controller类中的方法执行之前先被拦截。

2）在控制器方法执行之后，也会执行拦截器。

3）在请求处理完成后，也会执行拦截器。

4）拦截器的三个方法

public class MyInterceptor implements HandlerInterceptor {
    /**
     * preHandle叫做预处理方法
     *  重要：是整个项目的入口，门户。preHandle返回true，请求可以被处理。
     *        preHandle返回false，请求到此方法为止。
     *  参数：
     *      Object handler : 被拦截的控制器对象。
     *  返回值：boolean
     *      true：表示请求是通过了拦截器的验证，可以执行处理器方法。
     *      false：请求没有通过拦截器的验证，请求到达拦截器就截止了。请求失败
     *  特点：
     *      1.在控制器方法(MyController)之前先执行的。
     *          用户的请求首先到达此方法
     *      2.在这个方法中可以获取请求的信息，验证请求是否符合要求。
     *          可以验证用户是否登录，验证用户是否有权限访问某个链接地址（url）。
     *          如果验证失败，可以截断请求，请求不能被处理。
     *          如果验证成功，可以放行请求，此时控制器方法才能执行。
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器的preHandle方法");
        return true;
    }

    /**
     * postHandle：后处理方法
     *  参数：
     *   Object handler : 被拦截的控制器对象。
     *   ModelAndView modelAndView：处理器方法的返回值
     *  特点：
     *      1.在处理器方法之后执行的
     *      2.能够获取到处理器方法的返回值ModelAndView，可以修改ModelAndView中的
     *          数据和视图，可以影响到最后的执行结果。
     *      3.主要是对原来的执行结果，做二次修正。
     */
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截的postHandle方法");
    }

    /**
     * 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("拦截器的afterCompletion方法");
    }
}

5）拦截器的执行顺序

在这里插入图片描述

2）多个拦截器的请求

1）多个拦截器的使用步骤

再定义一个拦截器：

public class MyInterceptor2 implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器的preHandle方法-22222");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截的postHandle方法-22222");
        //对原先的doSome执行结果，进行修改
        if(modelAndView != null){
            //修改数据
            modelAndView.addObject("myDate",new Date());
            //修改视图
            modelAndView.setViewName("other");
        }
    }

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

springMVC配置文件声明第二个拦截器：

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

    <!--声明第二个拦截器-->
    <mvc:interceptor>
        <mvc:mapping path="/**"/>
        <bean class="com.sss.Interceptor.MyInterceptor2"/>
    </mvc:interceptor>
</mvc:interceptors>

2）多个拦截器的执行顺序

在这里插入图片描述

从图中可以看出，只要有一个 preHandle()方法返回 false，则上部的执行链将被断开，

其后续的处理器方法与 postHandle()方法将无法执行。但，无论执行链执行情况怎样，只要

方法栈中有方法，即执行链中只要有 preHandle()方法返回 true，就会执行方法栈中的

afterCompletion()方法。最终都会给出响应。

3）拦截器和过滤器的区别

1.过滤器是servlet规范中的对象，拦截器是框架中的对象

2.过滤器是实现Filter接口的对象，拦截器是实现HandlerInterceptor

3.过滤器是用来设置request，response的参数，属性的，侧重于数据过滤的。

拦截器是用来验证请求的，能截断请求。

4.过滤器是在拦截器之前先执行的。

5.过滤器是tomcat服务器创建的对象，拦截器是springMVC容器创建的对象

6.过滤器有一个执行时间点，拦截器有三个执行时间点。

7.过滤器可以处理jsp，js，html等等。

拦截器是侧重于对Controller的对象，如果你的请求不能被DispatcherServlet接收，这个请求不会执行拦截器的内容等。

8.拦截器拦截普通类方法执行，过滤器过滤servlet请求响应。

柳落青

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringMVC一文详解

SpringMVC详解一：SpringMVC概述1）第一个springMVC项目2）SpringMVC请求处理流程3）spring执行过程源码分析4）SpringMVC的执行流程二：SpringMVC注解式开发1）@RequestMapping 定义请求规则2）method属性3）处理器方法的参数1）逐个参数接收2）**校正请求参数名**@RequestParam3）对象接收参数4）过滤器解决post方式乱码5）处理器方法的返回值1）ModelAndView作为返回值：2）String作为返回值：3）返回v
复制链接

扫一扫