【学习笔记】SpringMVC

发布于：2021年7月15日

字数：2.9k字

时长：14分钟

SpringMVC概述

SpringMVC是种基于Java的实现MVc设计模型的请求驱动类型的轻量级Web框架,属于Spring FrameWork的后续产品,已经融合在 Spring Web Flow中。

SpringMvC已经成为目前最主流的MVC框架之一,并且随着 Spring30的发布,全面超越 Struts2,成为最优秀的MVC框架。它通过一套注解,让一个简单的Java类成为处理请求的控制器,而无须实现任何接口。同时它还支持RESTful编程风格的请求。

SpringMVC快速开发步骤

导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.8.RELEASE</version>
</dependency>

配置web.xml

<!-- springMVC前端控制器 -->
<servlet>
    <servlet-name>DispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 配置xml地址 -->
    <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-mvc.xml</param-value>
     </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>DispatcherServlet</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

编写controller

@Controller
public class UserController {
    // 使用RequestMapping映射controller地址
    @RequestMapping("/myController")
    public String save() {
        System.out.println("Controller save running");
        // return要跳转的视图页面
        return "success.jsp";
    }
}

在resources下新增spring-mvc.xmld的spring config文件

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  http://www.springframework.org/schema/context/spring-context.xsd">

<!-- controller的组件扫描 -->
<context:component-scan base-package="com.myspring.controller"/>

SpringMVC组件解析

@RequestMapping

用于建立请求URL和处理请求方法之间的对应关系

位置

类上,请求URL的第一级访问目录。此处不写的话,就相当于应用的根目录
方法上,请求URL的第二级访问目录,与类上的使用@ ReqquestMapping标主的级目录起组成访问虚拟路径
return 后跟的路径：不加”/“，则从相对路径查询，否则从web路径下查询。

属性

value：用于指定请求的URL。它和path属性的作用是一样的
method：用于指定请求的方式
params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和vaue必须和配置的一模一样

MVC命名空间引入

<!-- 命名空间 -->
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
<!-- 约束地址 -->
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> http://www.springframework.org/schema/mvc  http://www.springframework.org/schema/mvc/spring-mvc.xsd">

组件扫描

1	<context:component-scan base-package="com.myspring.controller"/>

XML配置

return重定义与请求转发

1 2	return "forward:/success.jsp"; return "redirect:/success.jsp";

内部资源（视图）解析器

在spring-mvc.xml中配置如下

<!-- 内部资源解析器 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 配置前缀 -->
    <property name="prefix" value="/jsp/"/>
    <!-- 配置后缀 -->
    <property name="suffix" value=".jsp"/>
</bean>

2. 编写controller

   ```java
   // return "/jsp/success.jsp";
   return "success" //效果与上述相同

SpringMVC数据响应

页面跳转

返回字符串

1	return "/jsp/success.jsp";

返回ModelAndview对象

在controller中编写如下

// 第一种
@RequestMapping("/myController1")
public ModelAndView save2() {
    ModelAndView modelAndView = new ModelAndView();
    // 设置视图
    modelAndView.setViewName("success");
    // 设置模型
    modelAndView.addObject("username", "qqq");
    return modelAndView;
}
// 第二种
@RequestMapping("/myController2")
public ModelAndView save3(ModelAndView modelAndView) {
    modelAndView.setViewName("success");
    modelAndView.addObject("username", "qqq");
    return modelAndView;
}
// 第三种
@RequestMapping("/myController3")
public ModelAndView save4(Model model) {
    model.setAttribute("username", "qqq");
    return "success";
}
// 第四种
@RequestMapping("/myController4")
public String save4(HttpServletRequest request) {
    request.setAttribute("username", "qqq");
    return "success";
}

回写数据

返回字符串（@ResponseBody）

// 第一种
@RequestMapping("/myController1")
public void save1(HttpServletResponse resp) throws IOException {
    resp.getWriter().print("hello!!!");
}
// 第二种,使用ResponseBody，用于区分页面跳转
@RequestMapping("/myController2")
@ResponseBody
public String save2() {
    return "hello!!!";
}

返回JSON格式字符串

添加依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.11.2</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.2</version>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.11.2</version>
</dependency>

转换为JSON

@RequestMapping("/myController")
@ResponseBody
public String save() throws Exception {
    // 获得bean
    User user = new User();
    user.setName("张三");
    user.setAge(18);
    // 转换为JSON
    String userJson = new ObjectMapper().writeValueAsString(user);
    return userJson;
}

返回Spring自动转换Bean->JSON

配置spring-mvc.xml

<!-- 处理器映射器 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
 <property name="messageConverters">
     <list>
         <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
     </list>
 </property>
</bean>

或者使用mvc注解驱动如下配置：

xmlns:mvc="http://www.springframework.org/schema/mvc"

http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd

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

编写controller

// 第二种,使用ResponseBody，用于区分页面跳转
@RequestMapping("/myController")
@ResponseBody
public User save() throws Exception {
    User user = new User();
    user.setName("张三");
    user.setAge(18);
    return user;
}

SpringMVC请求

获取请求参数

获取基本类型参数

@RequestMapping("/myController")
@ResponseBody
public void save(String username, int age) {
    // 使用形参接收数据，注意此处参数名与表单中input的name值对应
    System.out.println(username);
    System.out.println(age);
}

获取Bean类型参数

@RequestMapping("/myController")
@ResponseBody
public void save(User user) {
    // 实际上是使用了Bean对象里的set方法，所以要让参数的名字与set方法名对应，否则接收不到
    System.out.println(user);
}

获取数据类型参数

@RequestMapping("/myController")
@ResponseBody
public void save(String[] strs) {
    System.out.println(Arrays.toString(strs));
}

获取集合类型参数

前端传输数据

<script src="${pageContext.request.contextPath}/js/jquery-1.7.2.min.js"></script>
<script>
    var userList = new Array();
    userList.push({name: "张三", age: 10});
    userList.push({name: "李四", age: 20});
    $.ajax({
        type: "POST",
        url: "${pageContext.request.contextPath}/test/myController",
        data: JSON.stringify(userList),
        contentType: "application/json;charset=utf-8"
    })
</script>

controller获得数据

@RequestMapping("/myController")
@ResponseBody
public void save(@RequestBody List<User> userList) {
    // 注意 @RequestBody List<User> userList
    System.out.println(userList);
}

静态资源访问权限开放

spring-mvc.xml中配置如下

<!-- 开放资源访问，设置可访问地址 -->
<mvc:resources mapping="/js/**" location="/js/"/>
<!-- 该标签表示当spring找不到时交由原始容器(tomcat)寻找 -->
<mvc:default-servlet-handler/>

全局编码过滤（防止中文乱码）

<!-- 全局编码过滤 -->
<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>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

参数绑定注解@RequestParam

value: 与请求参数名称
required: 此在指定的请求参数是否必须包括,默认是true,提交时如果没有此参数则报错
defaultvalue: 当没有指定请求参数时,则使用指定的默认值赋值

@RequestMapping("/myController")
@ResponseBody
public void save(@RequestParam(value="name", required=false，defaultvalue="000") String username) {
    // 将获得的参数name映射为所需要的username
    System.out.println(username);
}

获得Restfil风格参数

Restful是一种软件架构风格、设计风格,而不是标准,只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件,基于这个风格设计的软件可以更简洁,更有层次,更易于实现缓存机制等。

Restful风格的请求是使用“”ur+请求方式”表示次请求目的的,HTP协议里面四个表示操作方式的动词如下：

GET: 用于获取资源

POST: 用于新建资源

PUT: 用于更新资源

DELETE: 用于删除资源

@RequestMapping("/myController/{name}")
// 使用占位符{}
@ResponseBody
public void save(@PathVariable("name") String username) {
    System.out.println(username);
}

自定义类型转换器

黑马程序员最全SSM框架教程|Spring+SpringMVC+MyBatis全覆盖_SSM整合_哔哩哔哩_bilibili

获得请求头@RequestHeader

文件上传

导入依赖

dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.6</version>
</dependency>

<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>

在spring-mvc.xml中配置文件上传解析器

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 上传文件的编码类型 -->
    <property name="defaultEncoding" value="UTF-8"/>
    <!-- 上传文件总大小 -->
    <property name="maxUploadSize" value="5242800"/>
    <!-- 上传单个文件的大小 -->
    <property name="maxUploadSizePerFile" value="5242800"/>
</bean>

编写controller

@RequestMapping("/myController")
@ResponseBody
public void save(MultipartFile uploadedFile) throws Exception {
    uploadedFile.transferTo(new File("C:\\Users\\卢荟\\Desktop\\" + uploadedFile.getOriginalFilename()));
}

@RequestMapping("/myController")
@ResponseBody
public void save(MultipartFile[] files) throws Exception {
    for (MultipartFile file : files) {
        file.transferTo(new File("C:\\Users\\卢荟\\Desktop\\" + file.getOriginalFilename()));
    }
}

## SpringMVC拦截器interceptor

> Spring Mvc的拦截器类似于 Servlet开发中的过滤器 Filter,用于对处理器进行预处理和后处理。
>
> 将拦截器按一定的顺序联结成条链,这条链称为拦截器链( interceptor Chain)。在访问被拦截的方法或字段时,拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

### 开发步骤

1. 编写interceptor

   ```java
   public class MyInterceptor implements HandlerInterceptor {
       // 在目标方法执行之前执行
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           System.out.println("preHandle");
           String param = request.getParameter("param");
           if ("yes".equals(param)) {
               return true;
           } else {
               request.getRequestDispatcher("/index.jsp").forward(request, response);
               return false;
           }
       }
   
       // 在目标方法执行之后，试图返回之前执行
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           System.out.println("postHandle");
           // 可以对model进行修改
           modelAndView.addObject("name", "newName");
       }
   
       // 在流程执行完毕之后执行
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           System.out.println("afterCompletion");
       }
   }

在spring-mvc.xml中配置interceptor

<mvc:interceptors>
    <!-- 对应执行顺序 -->
    <mvc:interceptor>
        <!-- 对哪些资源执行拦截操作 -->
        <mvc:mapping path="/**"/>
        <!-- 对应interceptor -->
        <bean class="com.myspring.interceptor.MyInterceptor"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <!-- 对哪些资源执行拦截操作 -->
        <mvc:mapping path="/**"/>
        <!-- 对应interceptor -->
        <bean class="com.myspring.interceptor.MyInterceptor2"/>
    </mvc:interceptor>
</mvc:interceptors>

方法说明

SpringMVC异常处理

简单异常处理器

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    <!-- 默认错误视图 -->
    <property name="defaultErrorView" value="error1"/>
    <property name="exceptionMappings">
        <map>
            <!-- key:异常类型 value:错误视图 -->
            <entry key="java.lang.ClassCastException" value="error2"/>
            <entry key="java.io.IOException" value="error3"/>
        </map>
    </property>
</bean>