SpringMVC复习总结

置顶 HairLossException

已于 2022-03-14 08:08:08 修改

阅读量1k

点赞数 2

分类专栏： Spring框架专题笔记文章标签： java spring intellij-idea mvc SSM

于 2022-03-13 20:06:12 首次发布

本文链接：https://blog.csdn.net/m0_60117382/article/details/123457988

版权

Spring框架专题笔记专栏收录该内容

16 篇文章 2 订阅

订阅专栏

本文详细介绍了SpringMVC的创建过程，从创建mavenweb项目到配置web.xml、处理器、视图解析器，再到处理中文乱码问题和接收请求参数。此外，还讲解了SpringMVC的执行流程，如何使用@RequestMapping注解，以及处理器方法的参数接收和返回值处理。最后，讨论了静态资源处理、转发和重定向、异常处理和拦截器的定义与执行顺序，以及拦截器与过滤器的区别。

摘要由CSDN通过智能技术生成

素材来自

SpringMVC简介

SpringMVC 也叫 Spring web mvc。作为 Spring 框架一部分,能够使用Spring 的 IoC 和 Aop。SpringMVC 强化注解的使用,在控制器、Service、Dao 都可以使用注解,方便灵活。

创建带注解的SpringMVC程序

1、创建maven web项目
在这里插入图片描述
2、创建资源文件夹
java → 右键 → Mark Directory as → Sources Root
resources → 右键 → Mark Directory as → Resources Root

3、在pom.xml文件中添加依赖和插件

<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>

<build>
	<plugins>
	<!-- 编码和编译和JDK版本 -->
		<plugin>
			<artifactId>maven-compiler-plugin</artifactId>
			<version>3.1</version>
			<configuration>
				<source>1.8</source>
				<target>1.8</target>
			</configuration>
		</plugin>
	</plugins>
</build>

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">
  <!-- 注册中央调度器 -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <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>dispatcherServlet</servlet-name>
    <!--
       url-pattern 作用: 把一些请求交给指定的servlet处理,使用中央调度器（DispatcherServlet）
       1. 使用扩展名方式, 格式 *.xxx ,  xxx是自定义的扩展名。
          例如  *.do , *.action, *.mvc 等等. 不能使用*.jsp
          http://localhost:8080/myweb/some.do
          
       2. 使用斜杠 "/"
    -->
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
</web-app>

5、创建处理器

@Controller //表示当前类为处理器
public class MyController {
    @RequestMapping(value = "/some.do") //请求映射：把指定的请求交给方法处理
    public ModelAndView doSome(){
        System.out.println("处理some.do请求");
        ModelAndView mv = new ModelAndView();
        mv.addObject("message","使用注解的SpringMVC程序"); //addObject()方法用于向其Model中添加数据,其底层为一个 HashMap
        mv.addObject("hello","你好SpringMVC");//Model中的数据存储在request作用域中
        mv.setViewName("show");//SpringMVC默认采用转发的方式跳转到视图,本次请求结束模型中的数据被销毁。
        return mv;
    }
}

6、在resources目录下创建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"
       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.why.controller"/>

    <!-- 配置视图解析器:帮助我们处理视图的路径和扩展名 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 前缀：表示视图所在的路径 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 后缀：表示视图文件的扩展名 -->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

7、在WEB-INF目录下创建jsp文件夹,在jsp文件夹中创建show.jsp文件

<body>
    <h2>message数据：${message}</h2>
    <h2>hello数据：${hello}</h2>
</body>

8、项目部署
在这里插入图片描述

SpringMVC的执行流程

在这里插入图片描述
（1）浏览器提交请求到中央调度器
（2）中央调度器直接将请求转给处理器映射器。
（3）处理器映射器会根据请求,找到处理该请求的处理器,并将其封装为处理器执行链后返回给中央调度器。
（4）中央调度器根据处理器执行链中的处理器,找到能够执行该处理器的处理器适配器。
（5）处理器适配器调用执行处理器。
（6）处理器将处理结果及要跳转的视图封装到一个对象 ModelAndView 中,并将其返回给处理器适配器。
（7）处理器适配器直接将结果返回给中央调度器。
（8）中央调度器调用视图解析器,将 ModelAndView 中的视图名称封装为视图对象。
（9）视图解析器将封装了的视图对象返回给中央调度器
（10）中央调度器调用视图对象,让其自己进行渲染,即进行数据填充,形成响应对象。
（11）中央调度器响应浏览器。

@RequestMapping

通过@RequestMapping 注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上,也可以注解在类上,但意义是不同的。value 属性值常以“/”开始

@Controller
@RequestMapping("/test") //定义在类上表示模块的名称（将相同部分的URI抽取到这）
public class MyController {
    @RequestMapping(value = "/some.do",method = RequestMethod.POST) //定义在方法上 属性method：请求的方式
    public ModelAndView doSome(){...}
}

处理器方法中的参数

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

HttpServletRequest
HttpServletResponse
HttpSession
请求中所携带的请求参数

逐个接收参数

只要保证请求参数名与控制器方法的参数名相同即可(顺序无所谓)

<body>
<form action="/mvc/some.do" method="post">
    姓名：<input type="text" name="username"><br>
    年龄：<input type="text" name="userage"><br>
    <input type="submit" value="提交">
</form>
</body>

@Controller
public class MyController {
    @RequestMapping(value = "/some.do",method = RequestMethod.POST) 
    //参数名必须和请求中参数名保持一致
    public ModelAndView doSome(Integer userage,String username){
        ModelAndView mv = new ModelAndView();
        mv.addObject("name",username); 
        mv.addObject("age",userage);
        mv.setViewName("show");
        return mv;
    }
}

参数最好使用包装类型。例如Integer,能接收空值情况,接收的是null
框架可以使用String到int,long,float,double等类型转换。
post请求中有乱码的问题,使用字符集过滤器。

请求参数中文乱码问题

对于前面所接收的请求参数,若含有中文,则会出现中文乱码问题。Spring 对于请求参数中的中文乱码问题,给出了专门的字符集过滤器：CharacterEncodingFilter 类

 <!--在web.xml 声明过滤器-->
 <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>
    <init-param>
      <!--强制请求（request）对象使用encoding的编码方式-->
      <param-name>forceRequestEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
    <init-param>
      <!--强制应答（response）对象使用encoding的编码方式-->
      <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>

请求中参数名和形参名不同使用@RequestParam

	/**
	 * @RequestParam : 解决名称不一样的问题
	 * 属性： value 请求中的参数名称
	 *       required : boolean类型的,默认是true
	 *      	true：请求中必须有此参数,没有报错。
	 *          false：请求中可以没有此参数。
	 * 位置： 在形参定义的前面
	 */
	@RequestMapping(value = "/some.do",method = RequestMethod.POST) 
    public ModelAndView doSome(@RequestParam("username") String name,
                               @RequestParam("userage") Integer age){
        ModelAndView mv = new ModelAndView();
        mv.addObject("name",name);
        mv.addObject("age",age);
        mv.setViewName("show");
        return mv;
    }

对象接收

将处理器方法的参数定义为一个对象,只要保证请求参数名与这个对象的属性同名即可

public class User {
    private String username; //属性名必须和请求参数名相同
    private Integer userage;
    //setter and getter 这些方法必须写

@RequestMapping(value = "/some.do",method = RequestMethod.POST) 
    public ModelAndView doSome(User user){
        ModelAndView mv = new ModelAndView();
        mv.addObject("name",user.getUsername()); 
        mv.addObject("age",user.getUserage());
        mv.setViewName("show");
        return mv;
    }

处理器方法的返回值

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

ModelAndView
String
无返回值 void
返回自定义类型对象 Object

ModelAndView

若处理器方法处理完后,需要跳转到其它资源,且又要在跳转的资源间传递数据,此时处理器方法返回 ModelAndView 比较好

String

处理器方法返回的字符串可以指定逻辑视图名,通过视图解析器解析可以将其转换为物理视图地址

@RequestMapping(value ="/return-string-view.do")
public String doReturnStringView1(HttpServletRequest request){
        System.out.println("执行了MyController的doReturnStringView1方法");
        //返回结果,forward,转发到show.jsp
        //逻辑名称,需要配置视图解析器
        return "show";
}

@RequestMapping(value ="/return-string-view2.do")
public String doReturnStringView2(HttpServletRequest request) {
    System.out.println("执行了MyController的doReturnStringView2方法");
    //使用完整视图路径就不能使用视图解析器
    return "/WEB-INF/view/show.jsp";
}

void

没有数据和视图, 可以使用HttpServletResponse对象输出数据。若处理器对请求处理后,无需跳转到其它任何资源,此时可以让处理器方法返回 void。例如,对于 AJAX 的异步请求的响应。

Object

处理器方法也可以返回 Object 对象用来响应ajax请求。这个 Object 可以是 Integer,String,自定义对象,Map,List 等。但返回的对象不是作为逻辑视图出现的,而是作为直接在页面显示的数据出现的。返回对象,需要使用@ResponseBody 注解,将转换后的 JSON 数据放入到响应体中

由于返回 Object 数据,一般都是将数据转化为了 JSON 对象后传递给浏览器页面的。而这个由 Object 转换为 JSON,是由 Jackson 工具完成的。所以需要导入 Jackson 的相关 Jar 包。

	<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>

<body>
<button>发起Ajax请求</button>

<script type="text/javascript" src="js/jquery-3.4.1.min.js"></script>
<script type="text/javascript">
    $(function (){
        $("button").click(function (){
            $.ajax({
                url:"userJson.do",
                data:{
                    username:"张三",
                    userage:"20"
                },
                type:"post",
                dataType:"json",
                success:function (resp) {
                    alert(resp.username+"----"+resp.userage);
                }
            })
        })
    })
</script>
</body>

@RequestMapping("/userJson.do")
    @ResponseBody //这个注解的作用就是把user转换后的json通过HttpServletResponse对象输出给浏览器。
    public User doAjaxJson(String username,Integer userage){
        User user = new User();
        user.setUsername(username);
        user.setUserage(userage+10);
        return user;
    }

将 Object 数据转化为 JSON 数据,需要由消息转换器HttpMessageConverter 完成。而转换器的开启需要由<mvc:annotation-driven/>来完成。HttpMessageConverter是接口。作用是
1）实现请求的数据转为java对象
2）把控制器方法返回的对象转为json,xml,text,二进制等不同格式的数据

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

框架会根据控制器方法的返回类型, 自动查找使用的实现类。默认情况下： springmvc使用了HttpMessageConveter接口的4个实现类。包括了StringHttpMessageConverter. 加入这个标签后, springmvc项目启动后,会创建HttpMessageConveter接口的7个实现类对象,包括StringHttpMessageConverter 和 MappingJackson2HttpMessageConverter

MappingJackson2HttpMessageConverter ：用jackson工具库的ObjectMapper把java对象转为json数据格式
StringHttpMessageConverter ：把字符串类型的数据,进行格式转换和编码

静态资源处理

当web.xml中DispatcherServlet的url-pattern改为/时。因为 DispatcherServlet 会将向静态资源的获取请求,例如.css、.js、.jpg、.png 等资源的获取请求,当作是一个普通的 Controller 请求。中央调度器会调用处理器映射器为其查找相应的处理器。当然也是找不到的,所以在这种情况下,所有的静态资源获取请求也均会报 404 错误。
在这里插入图片描述
中央调度器设置了“/” , 动态资源能访问,静态资源不能访问。需要处理静态资源的访问工作。

第一种方式处理静态资源

在springmvc的配置文件加入 mvc:default-servlet-handler标签, springmvc框架会在项目运行时,加入DefaultServletHttpRequestHandler对象,让这个对象处理静态资源的访问。它会像一个检查员,
对进入 DispatcherServlet 的 URL 进行筛查,如果发现是静态资源的请求,就将该请求转由 Web 应用服务器默认的 Servlet 处理。

<!--声明注解驱动
    default-servlet-handler和@RequestMapping使用有冲突-->
<mvc:annotation-driven />

<!--声明静态资源的第一种处理方式
    创建DefaultServletHttpRequestHandler处理静态资源。
    DefaultServletHttpRequestHandler把接收的静态资源的地址,转发给了tomcat的default
    优点：
      解决方式简单
    缺点：
      依赖tomcat服务器提供的能力。-->
<mvc:default-servlet-handler />

第二种静态资源的处理方式

在 Spring3.0 版本后,Spring 定义了专门用于处理静态资源访问请求的处理器 ResourceHttpRequestHandler。并且添加了<mvc:resources/>标签,专门用于解决静态资源无法访问问题。在springmvc配置文件中加入一个 mvc:resources标签, 框架会创建ResourceHttpRequestHandler控制器对象, 使用这个对象处理静态资源的访问。不依赖tomcat服务器(推荐使用)

    <!--声明静态资源的第二种处理方式
        mapping: 访问静态资源的uri地址, 可以使用通配符（**）。
                  ** : 表示任意的目录和目录和资源名称
        location: 静态资源在项目中的位置, 不要使用/WEB-INF目录 -->
    <mvc:resources mapping="/image/**" location="/image/" />
    <mvc:resources mapping="/js/**" location="/js/" />

    <!--一句话设置静态资源-->
    <!--<mvc:resources mapping="/static/**" location="/static/" />-->

转发和重定向

SpringMVC 框架把原来 Servlet 中的请求转发和重定向操作进行了封装。现在可以使用简单的方式实现转发和重定向。

forward:表示转发,实现request.getRequestDispatcher(“xx.jsp”).forward()
redirect:表示重定向,实现 response.sendRedirect(“xxx.jsp”)

mv.setViewName("forward:/hello.jsp");
mv.setViewName("redirect:/other.jsp");

异常处理

框架使用的是集中的异常处理。把各个Controller中抛出的异常集中到一个地方处理。处理异常的叫做异常处理器。框架中使用两个注解完成异常的集中处理。这样每个controller不用单独处理异常了。注解是：

@ExceptionHandler : 放在方法的上面,表示此方法可以处理某个类型的异常。当异常发生时,执行这个方法。
@ControllerAdvice: 放在类的上面, 表示这个类中有异常的处理方法。相当于aop中的@Aspect.
@ControllerAdvice看做是控制器增强, 就是给Controller类增加异常(切面)的处理功能。

@ControllerAdvice //控制器增强 控制器发生异常可以在当前类中找到@ExceptionHandler
public class GlobalExceptionResolver{
    @ExceptionHandler(value = ArithmeticException.class) // 定义异常处理方法
    public ModelAndView doException(Exception ex){
        ModelAndView mv = new ModelAndView();
        mv.addObject("tips","处理异常");
        mv.addObject("ex",ex);
        mv.setViewName("error");
        return mv;
    }
    
    @ExceptionHandler(value = NullPointerException.class)
    public ModelAndView doNullxception(Exception ex){...}
    
 	@ExceptionHandler //处理上面两个异常以外的其他异常
    public ModelAndView doOtherException(Exception ex){...}
}

拦截器

SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的,它的主要作用是拦截指定的用户请求,并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类,并且也找到了要执行该处理器类的处理器适配器,在处理器适配器执行处理器之
前”

定义拦截器

public class MyInterceptor implements HandlerInterceptor {
    /**
     *  preHandle: 预先处理请求的方法。
     *  参数：
     *     Object handler：被拦截的控制器对象（MyController）
     *  返回值：boolean
     *   true：请求是正确的,可以被controller处理的
     *   false：请求不能被处理,控制器方法不会执行,请求到此截止。
     * 特点：
     *  1. 预处理方法他的执行时间：在控制器方法之前先执行的。
     *  2. 可以对请求做处理,可以做登录的检查,权限的判断,统计数据等等。
     *  3. 决定请求是否执行。
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行MyInterceptor拦截器预先处理请求的方法");
        return true;
    }

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


    /**
     * afterCompletion: 最后执行的方法
     * 参数：
     *   Object handler：被拦截的控制器对象（MyController）
     *   Exception ex：异常对象
     * 特点：
     *  1.在请求处理完成后执行的,
     *     请求处理完成的标志是 视图处理完成,对视图执行forward操作后。
     *  2.可以做程序最后要做的工作, 释放内存, 清理临时变量。
     *  3.方法的执行条件：
     *     1）当前的拦截器他的preHandle()方法必须执行。
     *     2）preHandle()必须返回true。
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("执行MyInterceptor拦截器最后执行的方法");
    }
}

声明拦截器

在springMVC的配置文件中声明

<!--声明拦截器-->
<mvc:interceptors>
    <!--声明第一个拦截器-->
    <mvc:interceptor>
        <!--指定拦截器的拦截地址
            path：拦截的uri地址,使用 ** 通配符-->
        <mvc:mapping path="/**"/>
        <!--指定使用的拦截器-->
        <bean class="com.why.interceptor.MyInterceptor"/>
    </mvc:interceptor>
</mvc:interceptors>

多个拦截器

使用两个拦截器, 主要看拦截器的执行顺序,以及按个方法控制请求的执行
1）两个拦截器,第一个preHandle=true, 第二个拦截器preHandle=true

=====MyInterceptor111111拦截器的preHandle====
=====MyInterceptor222222拦截器的preHandle====
执行了MyController的doSome方法
=====MyInterceptor222222拦截器的postHandle====
=====MyInterceptor111111拦截器的postHandle====
=====MyInterceptor222222拦截器的afterCompletion====
=====MyInterceptor111111拦截器的afterCompletion====

请求的执行顺序：
用户some.do—拦截器1的preHandle----拦截器2preHandle—控制器doSome—拦截器2postHandle—拦截器1的postHandle—拦截器2的afterCompletion—拦截器1的afterCompletion。

2）两个拦截器,第一个preHandle=true, 第二个拦截器preHandle=false

=====MyInterceptor111111拦截器的preHandle====
=====MyInterceptor222222拦截器的preHandle====
=====MyInterceptor111111拦截器的afterCompletion====

3）两个拦截器,第一个preHandle=false, 第二个拦截器preHandle=true|false

=====MyInterceptor111111拦截器的preHandle====

当有多个拦截器时,形成拦截器链。拦截器链的执行顺序,与其注册顺序一致。需要再次强调一点的是,当某一个拦截器的 preHandle()方法返回 true并被执行到时,会向一个专门的方法栈中放入该拦截器的 afterCompletion()方法。（当某个拦截器的preHandle()返回true时它的afterCompletion()一定会被执行）

拦截器和过滤器的区别

拦截器是springmvc框架中的对象。过滤器是servlet中的对象。
拦截器对象是框架容器创建的, 过滤器对象是tomcat创建的对象。
拦截器是侧重对请求做判断的,处理的, 可以截断请求。过滤器是侧重对request,response对象的属性,参数设置值的。例如request.setCharacterEncoding(“utf-8”)
拦截器的他执行时间有三个, 控制器方法之前, 之后, 请求完成后。过滤器是在请求之前和响应之前。
拦截器是拦截对controller,动态资源请求的。过滤器可以过滤所有请求动态的和静态的。
拦截器和过滤器一起执行的, 先执行的过滤器,后面是中央调度器 , 后面才是拦截器, 再后面是控制器方法
拦截器是基于java的反射机制的,而过滤器是基于函数回调。

在这里插入图片描述

HairLossException

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC复习总结

文章目录SpringMVC简介创建带注解的SpringMVC程序SpringMVC简介SpringMVC 也叫 Spring web mvc。作为 Spring 框架一部分,能够使用Spring 的 IoC 和 Aop。SpringMVC 强化注解的使用,在控制器、Service、Dao 都可以使用注解,方便灵活。创建带注解的SpringMVC程序1、创建maven web项目...
复制链接

扫一扫