前言：最近在做公司项目的过程中，发现学过的SpringMVC的知识忘记了，于是看了之前看的视频的笔记，并结合自己的理解写下了这篇博客，希望能加深自己的印象以及帮助的诸位小伙伴儿们🤞🤞
如果有什么需要改进的地方还请大佬斧正😁
小威在此先感谢诸佬了👏👏

🏠个人主页：小威要向诸佬学习呀
🧑个人简介：大家好，我是小威，一个想要与大家共同进步的男人😉😉
目前状况🎉：目前大二，在一家满意的公司实习👏👏

🎁如果大佬在准备面试，找工作，刷算法，可以使用我找实习前用的刷题神器哦刷题神器点这里哟
💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，我亲爱的大佬😘

牛客部分使用反馈，个人感觉还不错，帮我找到了心仪的公司，希望各位伙伴儿们通过它也能提高不少🥂🥂🥂

以下正文开始

SpringMVC介绍

SpringMVC 是一种基于 Java 的实现 MVC 设计模型的请求驱动类型的轻量级 Web 框架，跟Spring，Mybatis框架并称为ssm。Spring MVC是由Spring官方提供的基于MVC设计理念的web框架也是基于Servlet封装的用于实现MVC控制的框架，实现前端和服务端的交互。
为什么叫MVC呢，这是因为，M是模型（Model）：模型数据，主要处理业务逻辑；视图（View）：呈现模型，主要用与用户进行交互；控制器（Controller）：负责接收并处理请求，响应客户端。

SpringMVC特点

上面介绍了SpringMVC的概念，接下来介绍它的特点：

• SpringMVC遵守了MVC分层思想，上面提到有Model，View，Controller三层结构。
• 采用了松耦合、插件式结构；相比较于我们封装的BaseServlet以及其他的一些MVC框架来说更灵活、更具扩展性
• SpringMVC是基于Spring的扩展、提供了一套完善的MVC注解，如RequestMapping，RequestBody，ResponseBody等，后面会讲到。
• SpringMVC在数据绑定、视图解析都提供了多种处理方式，可灵活配置
• SpringMVC对RESTful URL设计方法提供了良好的支持，支持Restful风格。

因此，综上而言，SpringMVC的本质工作就是：
1.接收并解析请求
2.处理请求
3.数据渲染、响应请求

SpringMVC框架部署

首先创建一个Web工程，在Web工程中添加以下依赖：

<properties>
    <spring.version>5.2.13.RELEASEspring.version>
properties>

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>${spring.version}version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-aspectsartifactId>
        <version>${spring.version}version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-jdbcartifactId>
        <version>${spring.version}version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-testartifactId>
        <version>${spring.version}version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-webartifactId>
        <version>${spring.version}version>
    dependency>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-webmvcartifactId>
        <version>${spring.version}version>
    dependency>

dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

接下来创建的SpringMVC配置文件，在resources目录下创建名为spring-servlet.xml的文件

<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:aop="http://www.springframework.org/schema/aop"
       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
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
	
    <context:annotation-config/>
    <context:component-scan base-package="com.mvc"/>

    
    <mvc:annotation-driven/>

beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

然后在web.xml中配置SpringMVC的前端控制器：
SpringMVC提供了一个名为DispatcherServlet的类（SpringMVC前端控制器），用于拦截用户请求交由SpringMVC处理。

<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_3_1.xsd"
         version="3.1">

    <servlet>
        <servlet-name>SpringMVCservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:spring-servlet.xmlparam-value> //添加配置文件的路径
        init-param>
        <load-on-startup>1load-on-startup> //初始化
    servlet>
    <servlet-mapping>
        <servlet-name>SpringMVCservlet-name>
        <url-pattern>/*url-pattern> 
    servlet-mapping>

web-app>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

SpringMVC框架使用

首先创建一个控制器的类，在SpringMVC中，我们把接收用户请求、处理用户请求的类称之为Controlelr（控制器）
我们创建一个控制器：

• 创建一个名为com.mvc.controllers的包（包需要在Spring注解扫描的范围内）

• 创建一个类（无需做任何的继承和实现）

• 在类上添加@Controller注解声明此类为SpringMVC的控制器

• 在类上添加@RequestMapping("访问路径")声明此控制器类的请求url（可以省略）

@Controller
@RequestMapping("/book")
public class BookController {

}
1
2
3
4
5

在控制器类中定义处理请求的方法

• 在一个控制器类中可以定于多个方法处理不同的请求
• 在每个方法上添加@RequestMapping("访问路径")用于声明当前方法请求的url

@Controller
@RequestMapping("/book")
public class BookController {

    @RequestMapping("/add")
    public void addBook(){
        System.out.println("---book add");
    }

    @RequestMapping("/list")
    public void listBooks(){
        System.out.println("---book list");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

接下来部署静态资源：
静态资源是指项目中的HTML、css、js、图片、字体等

/* 和 / 的区别

• /* 拦截所有的HTTP请求，包括.jsp的请求，都做为控制器类的请求路径来处理
• / 拦截所有的HTTP请求，但不包括.jsp的请求，不会放行静态资源的请求（html/css/js/图片）

静态资源放行配置

• 在springMVC的配置文件，添加如下静态资源放行的配置

<!--配置静态资源放行-->
<mvc:resources mapping="/css/**" location="/css/"/>
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:resources mapping="/imgs/**" location="/imgs/"/>
<mvc:resources mapping="/pages/**" location="/pages/"/>
1
2
3
4
5

前端提交数据到控制器
输入框需要提供name属性，SpringMVC控制器是通过name属性取值的

<body>
    <h3>添加图书h3>
    <form action="book/add" method="post">
        <p>图书名称:<input type="text"/>p>
        <p>图书作者:<input type="text"/>p>
        <p>图书价格:<input type="text"/>p>
        <p><input type="submit" value="提交"/>p>
    form>
body>
1
2
3
4
5
6
7
8
9

URL提交

<a href="book/add?bookName=Java">URL提交a>
1

AJAX提交：请求行、请求头、请求体都可以用来传值

<input type="button" value="ajax提交" id="btn1"/>
<script type="text/javascript" src="js/jquery-3.4.1.min.js">script>
<script type="text/javascript">
    $("#btn1").click(function(){
        var obj = {};
        obj.bookName = "Java";
        obj.bookAuthor="张三";
        obj.bookPrice = 3.33;

        $.ajax({
            url:"book/add",
            type:"post",
            headers:{

            },
            contentType:"application/json",
            data:obj,
            success:function(res){
                console.log(res);
            }
        });
    });
script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

控制器接收前端提交的数据

@RequestParam 接收请求行传值

• 表单提交
• URL提交
• $.ajax()请求的url传值
• $.post()/$.get()中的{}传值

**@RequestParam**注解用于接收请求行传递的数据

• 前端提交数据

<form action="book/add" method="post">
    <p>图书名称:<input type="text" name="name"/>p>
    <p>图书作者:<input type="text" name="author"/>p>
    <p>图书价格:<input type="text" name="price"/>p>
    <p><input type="submit" value="提交"/>p>
form>
1
2
3
4
5
6

控制器接收数据

/*接收请求行数据*/
@RequestMapping("/add")
public void addBook(@RequestParam("name") String a,
                    @RequestParam("author") String b,
                    @RequestParam("price") double c){
    System.out.println("---book add");
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
}
1
2
3
4
5
6
7
8
9
10

注意如果控制器方法中接收数据的参数名与请求行传值的key一致，则@RequestParam注解可省略

@RequestMapping("/add")
public void addBook(String name,String author, double price){
    System.out.println("---book add");
    System.out.println(name);
    System.out.println(author);
    System.out.println(price);
}
1
2
3
4
5
6
7

前端：

<input type="button" value="ajax提交" id="btn1"/>
    <script type="text/javascript" src="js/jquery-3.4.1.min.js">script>
    <script type="text/javascript">
        $("#btn1").click(function(){
            $.ajax({
                url:"book/list",
                type:"post",
                headers:{
                    token:"wahahaawahaha"
                },
                success:function(res){
                    console.log(res);
                }
            });
        });
    script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

控制器

@RequestMapping("/list")
public void listBooks(@RequestHeader("token") String token){
    System.out.println("---book list");
}

1
2
3
4
5

ajax封装请求体数据

$.ajax({
    ...,
    contentType:"application/json",
    data:obj,,
    ...
})
1
2
3
4
5
6

**@RequestBody**注解用于接收请求行头传递的数据

前端：

<input type="button" value="ajax提交" id="btn1"/>
    <script type="text/javascript" src="js/jquery-3.4.1.min.js">script>
    <script type="text/javascript">
        $("#btn1").click(function(){
            var obj = {};
            obj.bookName = "Python";
            obj.bookAuthor="杰哥";
            obj.bookPrice = 2.22;

            var s = JSON.stringify(obj); //将对象转换成JSON格式
      
            $.ajax({
                url:"book/update",
                type:"post",
                contentType:"application/json",
                data:s,   //如果data的值为json格式字符串，contentType必须设置为"application/json"
                success:function(res){
                    console.log(res);
                }
            });
        });
    script>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

@RquestBody 将前端请求体提交的JSON格式数据转换成Java对象，依赖jackson包

导入jackson依赖：

<dependency>
    <groupId>com.fasterxml.jackson.coregroupId>
    <artifactId>jackson-databindartifactId>
    <version>2.12.1version>
dependency>
1
2
3
4
5

控制器

@RequestMapping("/update")
public void update(@RequestBody Book book){
    System.out.println("---book update");
    System.out.println(book);
}
1
2
3
4
5

控制器响应前端请求

控制器响应同步请求

同步请求：form、超链接

处理同步请求的方法的返回类型定义为String或者ModelAndView，以实现页面的跳转

• 返回类型为String

  转发

  @RequestMapping("/add")
  public String addBook(String name, String author, double price){
      System.out.println("---book add");
      return "/tips.jsp";
  }
  1
  2
  3
  4
  5

  重定向

  @RequestMapping("/add")
  public String addBook(String name, String author, double price){
      System.out.println("---book add");
      return "redirect:/tips.jsp";
  }
  1
  2
  3
  4
  5

• 返回类型为 ModelAndView

  转发

  @RequestMapping("/add")
  public ModelAndView addBook(String name, String author, double price){
      System.out.println("---book add");
      ModelAndView modelAndView = new ModelAndView("/tips.jsp");
      return modelAndView;
  }
  1
  2
  3
  4
  5
  6

  重定向

  @RequestMapping("/add")
  public ModelAndView addBook(String name, String author, double price){
      System.out.println("---book add");
      ModelAndView modelAndView = new ModelAndView("redirect:/tips.jsp");
      return modelAndView;
  }
  1
  2
  3
  4
  5
  6

控制器响应异步请求

异步请求：ajax请求

使用response中的输出流进行响应

• 控制器方法的返回类型为void
• 控制器方法添加 HttpServletResponse response参数
• 在方法中通过response获取输出流，使用流响应ajax请求

@RequestMapping("/update")
public void update(@RequestBody Book book, HttpServletResponse response) throws IOException {
    System.out.println("---book update");
    System.out.println(book);

    //使用ObjectMapper将对象转换成JSON格式字符串
    String s = new ObjectMapper().writeValueAsString(book);
    response.setCharacterEncoding("utf-8");
    response.setContentType("application/json");
    PrintWriter out = response.getWriter();
    out.println(s);
    out.flush();
    out.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

直接在控制器方法返回响应的对象

• 控制器方法的返回类型设置为响应给ajax请求的对象类型
• 在控制器方法前添加@ResponseBody注解，将返回的对象转换成JSON响应给ajax请求
• 如果一个控制器类中的所有方法都是响应ajax请求，则可以直接在控制器类前添加@ResponseBody注解

@RequestMapping("/update")
@ResponseBody
public List<Book> update() {
    System.out.println("---book update");
    List<Book> books = new ArrayList<Book>();
    books.add(new Book(1,"Java","老张",2.22));
    books.add(new Book(2,"C++","老李",3.22));
    return books;
}
1
2
3
4
5
6
7
8
9

控制器响应同步请求的数据传递

对于同步请求的转发响应，我们可以传递参数到转发的页面

• 返回类型为String:

  //1.在控制器方法中定义一个Model类型的参数
  //2.在return页面之前，向model中添加键值对，添加的键值对就会被传递到转发的页面
  @RequestMapping("/add")
  public String addBook(String name, String author, double price,Model model){
      model.addAttribute("key1","value1");
      model.addAttribute("book",new Book(1,"Java","老张",2.22));
      return "/tips.jsp";
  }
  
  //除了使用Model对象传值外，还可以直接使用HttpServletRequest对象
  @RequestMapping("/add")
  public String addBook(String name, String author, double price,HttpServletRequest request){
      request.setAttribute("key1","value1");
      request.setAttribute("book",new Book(1,"Java","老张",2.22));
      return "/tips.jsp";
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16

• 返回类型为ModelAndView:

  @RequestMapping("/add2")
  public ModelAndView addBook2(String name, String author, double price){
  
      ModelAndView modelAndView = new ModelAndView("/tips.jsp");
      modelAndView.addObject("key1","value1");
      modelAndView.addObject("book",new Book(1,"Java","老张",2.22));
      return modelAndView;
  }
  1
  2
  3
  4
  5
  6
  7
  8

文章到这里就结束了，以后还会记录一些其他的知识，喜欢的大佬可以多多支持哦😉😉。
如果有什么疑问的地方请指出，诸佬们一起讨论🍻🍻

最后再次给大家安利一波牛客，牛客真的很不错的软件，点击刷题神器
注册牛客，快来和博主一起刷题吧嘿嘿嘿👏
同时祝伙伴儿找到理想的工作及猛猛地提升算法能力哦😏

再次感谢各位小伙伴儿们的支持🤞