SpringMVC学习笔记 - 第一章 - 工作流程、Bean加载控制、请求与响应（参数接收与内容返回）、RESTful

【前置内容】Spring 学习笔记全系列传送门：

SpingMVC 学习笔记全系列传送门：

目录

1、SpringMVC概述

  • SpringMVC是一种基于Java实现MVC模型的轻量级Web框架

  • 优点

    • 使用简单、开发便捷(相比于Servlet)
    • 灵活性强

  • SpringMVC主要负责的就是

    • controller如何接收请求和数据
    • 如何将请求和数据转发给业务层
    • 如何将响应数据转换成json发回到前端

  • 三层架构与MVC模式

    三层架构与MVC模式

    • 浏览器发送一个请求给后端服务器，后端服务器现在是使用Servlet来接收请求和数据

      如果所有的处理都交给Servlet来处理的话，所有的东西都耦合在一起，对后期的维护和扩展极为不利

    • 将后端服务器Servlet拆分成三层，分别是web、service和dao

      • web层主要由servlet来处理，负责页面请求和数据的收集以及响应结果给前端
      • service层主要负责业务逻辑的处理
      • dao层主要负责数据的增删改查操作

      servlet处理请求和数据的时候，存在的问题是一个servlet只能处理一个请求

    • 针对web层进行了优化，采用了MVC设计模式，将其设计为controller、view和Model

      • controller负责请求和数据的接收，接收后将其转发给service进行业务处理
      • service根据需要会调用dao对数据进行增删改查
      • dao把数据处理完后将结果交给service,service再交给controller
      • controller根据需求组装成Model和View,Model和View组合起来生成页面转发给前端浏览器
      • 这样做的好处就是controller可以处理多个请求，并对请求进行分发，执行不同的业务操作。

    三层架构与MVC模式传递

    • 随着互联网的发展，上面的模式因为是同步调用，性能慢慢的跟不是需求，所以异步调用慢慢的走到了前台，是现在比较流行的一种处理方式

      • 因为是异步调用，所以后端不需要返回view视图，将其去除
      • 前端如果通过异步调用的方式进行交互，后台就需要将返回的数据转换成json格式进行返回

2、SpringMVC入门案例

2.1 注意事项

  • SpringMVC是基于Spring的，在pom.xml只导入了spring-webmvcjar包的原因是它会自动依赖spring相关坐标
  • AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
  • AbstractDispatcherServletInitializer提供了三个接口方法供用户实现
    • createServletApplicationContext方法，创建Servlet容器时，加载SpringMVC对应的bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围
    • getServletMappings方法，设定SpringMVC对应的请求映射路径，即SpringMVC拦截哪些请求
    • createRootApplicationContext方法，如果创建Servlet容器时需要加载非SpringMVC对应的bean,使用当前方法进行，使用方式和createServletApplicationContext相同。
    • createServletApplicationContext用来加载SpringMVC环境
    • createRootApplicationContext用来加载Spring环境

2.2 案例制作

  1. 创建 Maven-webapp 项目，整理包结构

    image-20221228060317972

  2. 导入依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>priv.dandelion</groupId>
  <artifactId>01_quickstart</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>


  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <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.10.RELEASE</version>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.1</version>
        <configuration>
          <port>80</port>
          <path>/</path>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

  3. 创建 Controller

    // 定义Controller，声明为Spring的bean
@Controller
public class UserController {

    // 设置当前操作的访问路径
    @RequestMapping("/save")
    // 设置当前操作的返回值类型
    @ResponseBody
    public String save() {
        System.out.println("user----save");
        // 相应的内容直接返回
        return "{'hello':'springmvc'}";
    }
}

  4. 创建配置类

    // 创建SpringMVC的配置文件，加载controller对应的bean
@Configuration
@ComponentScan("priv.dandelion.controller")
public class SpringMvcConfig {
}

  5. 定义 Servlet 容器启动的配置类（代替 web.xml）

    // 定义一个servlet容器启动的配置类，在此处加载spring配置
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {

    // 加载SpringMVC容器配置
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        // 注册配置
        ctx.register(SpringMvcConfig.class);
        // tomcat服务器启动时就可以加载到SpringMvcConfig.class
        return ctx;
    }

    // 设置那些请求归属于SpringMVC处理
    @Override
    protected String[] getServletMappings() {
        // 将所有请求交给SpringMVC处理
        return new String[]{"/"};
    }

    // 加载Spring容器配置，此处暂时未用到
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

2.3 相关知识点

  • @Controller

    名称 @Controller
    类型 类注解
    位置 SpringMVC控制器类定义上方
    作用 设定SpringMVC的核心控制器bean

  • @RequestMapping

    名称 @RequestMapping
    类型 类注解或方法注解
    位置 SpringMVC控制器类或方法定义上方
    作用 设置当前控制器方法请求访问路径
    相关属性 value(默认)，请求访问路径

  • @ResponseBody

    名称 @ResponseBody
    类型 类注解或方法注解
    位置 SpringMVC控制器类或方法定义上方
    作用 设置当前控制器方法响应内容为当前返回值，无需解析

2.4 工作流程解析

包含关系：

  • Web容器
    • ServletContext
      • WebApplicationContext
        • UserController
          • /save -> save() 【SpringMVC 的映射并不是放在 bean 中管理的】

2.4.1 启动服务器初始化过程

  1. 服务器启动，执行 web 服务器配置类 ServletContainersInitConfig，初始化web容器

    • 功能类似于以前的web.xml

  2. 执行createServletApplicationContext方法，创建了WebApplicationContext对象（存在于 ServletContext 中）

    • 该方法加载SpringMVC的配置类SpringMvcConfig来初始化SpringMVC的容器

      // 加载SpringMVC容器配置
@Override
protected WebApplicationContext createServletApplicationContext() {
    AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
    // 注册配置
    ctx.register(SpringMvcConfig.class);
    // tomcat服务器启动时就可以加载到SpringMvcConfig.class
    return ctx;
}

  3. 加载SpringMvcConfig配置类，以在下一步加载所需的bean

    // 创建SpringMVC的配置文件，加载controller对应的bean
@Configuration
@ComponentScan("priv.dandelion.controller")
public class SpringMvcConfig {
}

  4. 执行@ComponentScan加载对应的bean

    扫描指定包及其子包下所有类上的注解，如Controller类上的@Controller注解

  5. 加载UserController，每个@RequestMapping的名称对应一个具体的方法

    • 此时就建立了 /save 和 save() 方法的对应关系

      // 定义Controller，声明为Spring的bean
@Controller
public class UserController {
                
    // 设置当前操作的访问路径
    @RequestMapping("/save")
    // 设置当前操作的返回值类型
    @ResponseBody
    public String save() {
        System.out.println("user----save");
        // 相应的内容直接返回
        return "{'hello':'springmvc'}";
    }
}

  6. 执行getServletMappings方法，设定SpringMVC拦截请求的路径规则

    • /代表所拦截请求的路径规则，只有被拦截后才能交给SpringMVC来处理请求/代表所拦截请求的路径规则，只有被拦截后才能交给SpringMVC来处理请求

      // 设置那些请求归属于SpringMVC处理
@Override
protected String[] getServletMappings() {
    // 将所有请求交给SpringMVC处理
    return new String[]{"/"};
}

2.4.2 单次请求过程

  1. 发送请求http://localhost/save

  2. web容器发现该请求满足SpringMVC拦截规则，将请求交给 SpringMVC 处理

  3. 解析请求路径 /save

  4. 由 /save 匹配执行对应的方法 save(）

    • 上面的第五步已经将请求路径和方法建立了对应关系，通过 /save 就能找到对应的save方法

  5. 执行 save()

  6. 检测到有 @ResponseBody 直接将 save() 方法的返回值作为响应体返回给请求方

2.5 bean 加载控制

2.5.1 问题分析

问题：

  • 哪些 bean 交给 SpringMVC 管理，哪些包交给 Spring 管理
  • 因为功能不同，如何避免 Spring 错误加载到 SpringMVC 的 bean

  • 包结构

    • config目录存入的是配置类，本篇和前面的内容已经写过的配置类有:

      • ServletContainersInitConfig
      • SpringConfig
      • SpringMvcConfig
      • JdbcConfig
      • MybatisConfig

    • controller 目录存放的是 SpringMVC 的 controller 类

    • service 目录存放的是 service 接口和实现类

    • dao 目录存放的是 dao/Mapper 接口

  • 管理

    • SpringMVC加载其相关bean
      • 表现层 bean（Controller）,也就是controller包下的类
    • Spring控制的bean
      • 业务 bean(Service)
      • 功能 bean(DataSource,SqlSessionFactoryBean,MapperScannerConfigurer等)

2.5.2 思路分析

加载Spring控制的bean的时候排除掉 SpringMVC 控制的 bean

  • 方式一:Spring加载的bean设定扫描范围为精准范围，例如service包、dao包等
  • 方式二:Spring加载的bean设定扫描范围为priv.dandelion，排除掉controller包中的bean
  • 方式三:不区分Spring与SpringMVC的环境，加载到同一个环境中[了解即可]

2.5.3 环境准备

  • 创建 Web 的 Maven 项目，删除 web.xml 配置文件

  • 依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>priv.dandelion</groupId>
    <artifactId>02_bean_load</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <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.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

  • 创建对应的配置类

    • 替代 web.xml 的 web 服务器配置类 ServletContainersInitConfig

      public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

    • SpringMVC 配置类

      @Configuration
@ComponentScan("priv.dandelion.controller")
public class SpringMvcConfig {
}

    • Spring 配置类

      @Configuration
@ComponentScan("priv.dandelion")
public class SpringConfig {
}

  • 实体类

    public class User {
    private Integer id;
    private String name;
    private Integer age;
    // Getter
    // Settrt
    // toString
}

  • Dao 接口

    public interface UserDao {
    @Insert("insert into tbl_user(name,age)values(#{name},#{age})")
    public void save(User user);
}

  • Service 实现类 （接口不表）

    @Service
public class UserServiceImpl implements UserService {
    public void save(User user) {
        System.out.println("user service ...");
    }
}

  • Controller

    @Controller
public class UserController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

2.5.4 设置 bean 加载控制

  • web服务器启动时加载配置类的相关配置

    • 标准方式

      • 方式
        • 修改 createRootApplicationContext() 方法中的内容
          • 与 createServletApplicationContext() 基本相同但是加载 SpringConfig.class
      • 说明
        • createServletApplicationContext() 加载的是 SpringMVC 环境配置
        • createRootApplicationContext() 加载的是 Spring 环境配置
      public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected WebApplicationContext createRootApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }
}

    • 简化方式

      说明：

      • AbstractDispatcherServletInitializer 类包含一个子类 AbstractAnnotationConfigDispatcherServletInitializer 可以简化配置
      • 方法名中包含 RootConfig 的是 Spring 的配置，包含 ServletConfig 的是对 SpringMVC 的配置，与标准方式中的相同
      public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

  • bean 加载控制方式

    • 方案一：修改Spring 配置类，精准扫描

      说明：

      • 此处使用了MyBatis技术且是自动代理，所以可以不扫Dao
      • 但是建议按照标准开发规则书写，通用性强
      @Configuration
@ComponentScan({"priv.dandelion.service","priv.dandelion.dao"})
public class SpringConfig {
}

    • 方案二

      说明：

      • 扫描所有的包

      • 但是使用过滤器进行排除

        • 过滤的类型是按注解过滤，过滤Controller注解

      使用到的属性：

      • excludeFilters属性：设置扫描加载bean时，排除的过滤规则

      • type属性：设置排除规则，当前使用按照bean定义时的注解类型进行排除

        • ANNOTATION：按照注解排除
        • ASSIGNABLE_TYPE:按照指定的类型过滤
        • ASPECTJ:按照Aspectj表达式排除，基本上不会用
        • REGEX:按照正则表达式排除
        • CUSTOM:按照自定义规则排除

        大家只需要知道第一种ANNOTATION即可

      • classes属性：设置排除的具体注解类，当前设置排除@Controller定义的bean

      @Configuration
@ComponentScan(
        value = "priv.dandelion",
        excludeFilters = @ComponentScan.Filter(
                type = FilterType.ANNOTATION,
                classes = Controller.class
        )
)
public class SpringConfig {
}

    • 方式三（不区分 Spring 与 SpringMVC 的环境）【此处不做详细说明】

2.5.5 相关知识点：@ComponentScan

名称 @ComponentScan
类型 类注解
位置 类定义上方
作用 设置spring配置类扫描路径，用于加载使用注解格式定义的bean
相关属性 excludeFilters:排除扫描路径中加载的bean,需要指定类别(type)和具体项(classes)
includeFilters:加载指定的bean，需要指定类别(type)和具体项(classes)

3、请求与相应

3.1 设置请求映射路径

本小节注意：

  • 当类上和方法上都添加了@RequestMapping注解，前端发送请求的时候，要和两个注解的value值相加匹配才能访问到。
  • @RequestMapping注解value属性前面加不加/都可以

3.1.1 环境准备

  • 依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>priv.dandelion</groupId>
    <artifactId>03_request_mapping</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <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.10.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

  • 配置类

    • Spring 配置类（此处未使用到）

      @Configuration
@ComponentScan(value = "priv.dandelion",
        excludeFilters = @ComponentScan.Filter(
                type = FilterType.ANNOTATION,
                classes = Controller.class
        )
)
public class SpringConfig {
}

    • SpringMVC 配置类

      @Configuration
@ComponentScan("priv.dandelion.controller")
public class SpringMvcConfig {
}

    • web服务器配置类 （简化配置）

      public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }
}

  • Controller

    • UserController

      @Controller
public class UserController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }

    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}

    • BookController

      @Controller
public class BookController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("book save ...");
        return "{'module':'book save'}";
    }
}

3.1.2 问题分析

  • 以上环境准备完成后，启动服务器时会报错

    [INFO] Initializing Servlet 'dispatcher'
[WARNING] Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping': Invocation of init method failed; nested exception is java.lang.IllegalStateException: Ambiguous mapping. Cannot map 'userController' method 
priv.dandelion.controller.UserController#save()
to { /save}: There is already 'bookController' bean method
priv.dandelion.controller.BookController#save() mapped.
[ERROR] Context initialization failed
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping': Invocation of init method failed; nested exception is java.lang.IllegalStateException: Ambiguous mapping. Cannot map 'userController' method 
priv.dandelion.controller.UserController#save()
to { /save}: There is already 'bookController' bean method
priv.dandelion.controller.BookController#save() mapped.
    at ...
    at ...
    ...

  • 从错误信息可知

    • UserController有一个save方法，访问路径为http://localhost/save
    • BookController也有一个save方法，访问路径为http://localhost/save
    • 当访问http://localhost/saved的时候，到底是访问 UserController 还是 BookController，就会出现冲突

  • 解决方案：为不同模块设置模块名作为请求路径前置

    • 对于Book模块的save,将其访问路径设置http://localhost/book/save
    • 对于User模块的save,将其访问路径设置http://localhost/user/save

3.1.3 设置映射路径

  • 方案一（耦合度高不推荐）：对每一个资源的 RequestMapping 进行修改

    • UserController

      @Controller
public class UserController {

    @RequestMapping("/user/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }

    @RequestMapping("/user/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}

    • BookController（不表）

  • 方案二：为 Controller 添加一个整体的 RequestMapping（称为请求路径前缀），其他不变

    • UserController

      @Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }

    @RequestMapping("/delete")
    @ResponseBody
    public String delete(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}

    • BookController（不表）

3.2 请求参数

3.2.1 环境准备

  • 依赖、配置类见 3.1.1

  • 实体类

    • Address

      public class Address {
    private String province;
    private String city;
    
    // Getter,Setter,toString不表
}

    • User

      public class User {
    private String name;
    private int age;

    // Getter,Setter,toString不表
}

  • Controller

    @Controller
public class UserController {

    @RequestMapping("/commonParam")
    @ResponseBody
    public String commonParam(){
        return "{'module':'commonParam'}";
    }
}

3.2.2 参数传递及中文乱码处理方案

Get请求与参数:

http://localhost/commonParam?name=dandelion&age=18

POST请求与参数:

  • 发送Post请求时，参数放在请求体中，若使用PostMan工具，参数需要写在Body模块中，发送表单数据时使用 x-www-from-urlencoded（form-data除了发送表单之外还可以发送文件）

  • GET请求

    • 接收参数

      @Controller
public class UserController {

    @RequestMapping("/commonParam")
    @ResponseBody
    public String commonParam(String name, int age){
        System.out.println("普通参数name："+ name);
        System.out.println("普通参数age："+ age);
        return "{'module':'commonParam'}";
    }
}

    • GET中文乱码：配置pom.xml

      Tomcat8.5以后的版本已经处理了中文乱码的问题，但是IDEA中的Tomcat插件目前只到Tomcat7，所以需要修改pom.xml来解决GET请求中文乱码问题

      <build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <version>2.1</version>
            <configuration>
                <port>80</port><!--tomcat端口号-->
                <path>/</path> <!--虚拟目录-->
                <uriEncoding>UTF-8</uriEncoding><!--访问路径编解码字符集-->
            </configuration>
        </plugin>
    </plugins>
</build>

  • POST请求

    • 接收参数

      POST请求接收参数代码与GET请求一致

    • POST中文乱码问题：设置过滤器

      • 在web服务器配置类 ServletContainersInitConfig 中重写 getServletFilters() 方法，创建所需的过滤器对象，并设置编码字符集为UTF-8

      • CharacterEncodingFilter 是在 spring-web 包中，所以用之前需要导入对应的 jar 包

        import org.springframework.web.filter.CharacterEncodingFilter;

      @Override
protected Filter[] getServletFilters() {
    CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
    characterEncodingFilter.setEncoding("UTF-8");
    return new Filter[]{characterEncodingFilter};
}

3.3 五种类型参数传递

3.3.1 普通参数

普通参数的基本使用已经实现过，详见 3.2.2 参数传递及中文乱码处理方案

  • 解决请求中的参数名称和 Controller 方法的参数不一致问题

    • 当出现请求中的参数名称和Controller中方法的参数名不匹配时，无法正常接收到参数
    • 使用 @RequestPaam() 注解修饰不一致的参数，为其指定需要匹配的请求参数
    @Controller
public class UserController {

    // `http://localhost/commonParam?username=dandelion&age=12`
    @RequestMapping("/commonParam")
    @ResponseBody
    public String commonParam(@RequestParam("username") String name, int age){
        System.out.println("普通参数name："+ name);
        System.out.println("普通参数age："+ age);
        return "{'module':'commonParam'}";
    }
}

3.3.2 POJO 数据类型

  • 直接使用一个实体类作为形参，框架会使用 setter 自动将数据进行写入
  • 实体类中的属性名称需要和请求参数的名称保持一致，否则接收不到
  • 若实体类中没有对应的 setter 可以和请求参数的参数名匹配，则默认零假空（未进行写入），可以使用该特性在实际开发中减少工作量

  • 实体类

    public class User {
    private String name;
    private int age;

    // Getter,Setter,toString不表
}

  • Controller

    @Controller
public class UserController {

    @RequestMapping("/pojoParam")
    @ResponseBody
    public String pojoParam(User user){
        System.out.println("POJO参数:"+ user);
        return "{'module':'pojoParam'}";
    }
}

3.3.3 嵌套 POJO 类型参数

对于嵌套的POJO类型，在进行参数传递时，也要使用嵌套的形式来书写请求参数名称

http://localhost/pojoParam?name=dandelion&age=12&address.province=hubei&address.city=wuhan

  • 实体类

    • User

      public class User {
    private String name;
    private int age;
    
    private Address address;

    // Getter,Setter,toString不表
}

    • Address

      public class Address {
    private String province;
    private String city;
    
    // Getter,Setter,toString不表
}

  • Controller

    Controller 部分代码与 3.3.3 嵌套 POJO 类型参数一致

3.3.4 数组类型参数

  • 请求参数为数组时，不同的数组元素使用相同的请求参数名称
  • 接收请求参数时，使用数组作为形参

  • 请求

    http://localhost/arrayParam?person=zhangsan&person=lisi&person=wangwu

  • 接收

    @Controller
public class UserController {

    @RequestMapping("/arrayParam")
    @ResponseBody
    public String arrayParam(String[] person){
        System.out.println("数组参数:"+ Arrays.toString(person));
        return "{'module':'arrayParam'}";
    }
}

3.3.5 集合类型参数

  • 请求

    与数组参数的请求方式相同

  • 接收

    • 错误案例

      以下代码段运行时会报错：NoSuchMethodException: java.util.List.<init>()，缺少构造，（内心：废话 List 接口哪来的构造）

      严重: Servlet.service() for servlet [dispatcher] in context with path [] threw exception [Request processing failed; nested exception is java.lang.IllegalStateException: No primary or default constructor found for interface java.util.List] with root cause
java.lang.NoSuchMethodException: java.util.List.<init>()

      @Controller
public class UserController {

    @RequestMapping("/listParam")
    @ResponseBody
    public String listParam(List<String> person){
        System.out.println("集合参数:"+ person);
        return "{'module':'listParam'}";
    }
}

    • 原因及解决方案

      • 问题原因

        SpringMVC 将 List 看做是一个 POJO 对象来处理，将其创建一个对象并准备把前端的数据封装到对象中，但是 List 是一个接口无法创建对象，所以报错。

      • 解决方案：使用@RequestParam注解

        • 集合保存普通参数：请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam 绑定参数关系
        • 显而易见，对于简单数据类型使用数组会比集合更简单些。
        @Controller
public class UserController {

    @RequestMapping("/listParam")
    @ResponseBody
    public String listParam(@RequestParam List<String> person){
        System.out.println("集合参数:"+ person);
        return "{'module':'listParam'}";
    }
}

3.3.6 相关知识点：@RequestParam

名称 @RequestParam
类型 形参注解
位置 SpringMVC控制器方法形参定义前面
作用 绑定请求参数与处理器方法形参间的关系
相关参数 required：是否为必传参数
defaultValue：参数默认值

3.4 JSON 数据传输参数

  • 参数放在请求体中，若使用 PostMan 工具，参数需要写在Body模块中，发送表单数据时使用 raw，并将数据格式修改为 JSON

3.4.1 JSON 数据传输参数分类与准备工作

  • 参数分类

    // json普通数组
["value1","value2","value3",...]
// json对象
 {"key1":"value1","key2":"value2",...}
// json对象数组
[{"key11":"value11",...},{"key21":"value21",...}]

  • 准备工作

    • 添加依赖

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

    • 开启SpringMVC注解驱动，用于开启 json 数据类型自动转换：@EnableWebMvc

      @Configuration
@ComponentScan("priv.dandelion.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

    • 参数前添加@RequestBody

      • 使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
      • 区别于 @RequestParam，本小节总结部分会进行说明
      • 区别于 @ResponseBody，书写要正确
      • 下文中展示

3.4.2 三种参数传输格式

3.4.2.1 json普通数组

  • JSON

    ["zhangsan","lisi","wangwu"]

  • 接收

    @RequestMapping("/listParamForJson")
@ResponseBody
// //使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
public String listParamForJson(@RequestBody List<String> person){
    System.out.println("list common(json)参数传递 list:" + person);
    return "{'module':'list common for json param'}";
}
3.4.2.2 json对象
  • 若 JSON 对象中的 key 与实体类中的 setter 名称（标准书写）不能匹配时，不执行 setter ，实体类中的数据不变（不进行其他操作时默认为零假空）
  • 同理，若不传递某一属性的值，实体类中的数据不变（不进行其他操作时默认为零假空）

  • JSON

    // 单个POJO
{
	"name":"dandelion",
	"age":12
}

// 嵌套POJO
{
	"name1":"dandelion",
	"age":12,
    "address":{
        "province":"provinceName",
        "city":"cityName"
    }
}

  • 实体类

    见 3.3.3

  • 接收

    @RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
    System.out.println("pojo(json)参数传递 user:"+user);
    return "{'module':'pojo for json param'}";
}
3.4.2.3 json对象数组

  • JSON

    [
    {"name":"dandelion","age":15,"address":{"province":"provinceName","city":"cityName"}},
    {"name":"dandelion000","age":12}
]

  • 接收

    @RequestMapping("/listPojoParamForJson")
@ResponseBody
public String listPojoParamForJson(@RequestBody List<User> list){
    System.out.println("list pojo(json)参数传递 list:"+list);
    return "{'module':'list pojo for json param'}";
}

3.4.3 相关知识点

  • 知识点1：@EnableWebMvc

    名称 @EnableWebMvc
    类型 配置类注解
    位置 SpringMVC配置类定义上方
    作用 开启SpringMVC多项辅助功能

  • 知识点2：@RequestBody

    • 整理

      名称 @RequestBody
      类型 形参注解
      位置 SpringMVC控制器方法形参定义前面
      作用 将请求中请求体所包含的数据传递给请求参数，此注解一个处理器方法只能使用一次

    • @RequestBody与@RequestParam区别

      • 区别

        • @RequestParam用于接收url地址传参，表单传参【application/x-www-form-urlencoded】
        • @RequestBody用于接收json数据【application/json】

      • 应用

        • 后期开发中，发送json格式数据为主，@RequestBody应用较广
        • 如果发送非json格式数据，选用@RequestParam接收请求参数

3.5 日期类型参数传递

  • 接收案例

    • 请求

      http://localhost/dataParam?date=2022/02/22

    • 接收

      @RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date, Date date1){
    System.out.println("参数传递 date:"+date);
    System.out.println("参数传递 date1:"+date1);
    return"{'module':'data param'}";
}

    • 结果

      • 发送请求后会发现该部分代码会报错，但若请求参数中只有date而没有date1时则正常接收

      • 报错信息：

        方法参数类型不匹配，在将 String 转换为 Date 时出现问题，转换失败

        [WARNING] Resolved [org.springframework.web.method.annotation.MethodArgumentTypeMismatchException: Failed to convert value of type 'java.lang.String' to required type 'java.util.Date'; nested exception is org.springframework.core.convert.ConversionFailedException: Failed to convert from type [java.lang.String] to type [java.util.Date] for value '2022-02-22'; nested exception is java.lang.IllegalArgumentException]

  • 解决方案（接收任意日期格式的方法）：使用 @DateTimeFormat 指定日期格式

    • 请求

      http://localhost/dataParam?date=2022/02/22&date1=22-02-2022&date2=2022-02-22 22:22:22

    • 接收

      @RequestMapping("/dataParam")
@ResponseBody
public String dataParam(Date date,
                        @DateTimeFormat(pattern = "dd-MM-yyyy") Date date1,
                        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date date2){
    System.out.println("参数传递 date:"+ date);
    System.out.println("参数传递 date1(dd-MM-yyyy):"+ date1);
    System.out.println("参数传递 date2(yyyy-MM-dd HH:mm:ss):"+ date2);
    return"{'module':'data param'}";
}

  • 相关知识点

    • @DateTimeFormat

      名称 @DateTimeFormat
      类型 形参注解
      位置 SpringMVC控制器方法形参前面
      作用 设定日期时间型数据格式
      相关属性 pattern：指定日期时间格式字符串

    • 内部实现原理

      SpringMVC中提供了很多类型转换接口和实现类，其中有 Converter 接口

      • Converter 接口

        • Converter所属的包为org.springframework.core.convert.converter

        • 框架中有提供很多对应Converter接口的实现类，用来实现不同数据类型之间的转换,如:

        • 请求参数年龄数据（String→Integer）

        • 日期格式转换（String → Date）

        /**
*	S: the source type
*	T: the target type
*/
public interface Converter<S, T> {
    @Nullable
    //该方法就是将从页面上接收的数据(S)转换成我们想要的数据类型(T)返回
    T convert(S source);
}

      • HttpMessageConverter 接口

        该接口是实现对象与 JSON 之间的转换工作，使用时在SpringMVC的配置类把@EnableWebMvc当做标配配置上去，不省略

3.6 响应

3.6.1 环境准备

  • 依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>priv.dandelion</groupId>
    <artifactId>05_response</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <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.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

  • 配置类

    • 服务器配置类

      public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        return new Filter[]{characterEncodingFilter};
    }
}

    • SpringMVC 配置类

      @Configuration
@ComponentScan("priv.dandelion.controller")
public class SpringMvcConfig {
}

  • 实体类

    public class User {
    private String name;
    private int age;
    //getter...setter...toString省略
}

  • webapp下创建页面 page.jsp

    <html>
<body>
<h2>Hello Spring MVC!</h2>
</body>
</html>

  • Controller

    @Controller
public class UserController {

}

3.6.2 响应页面（了解）

  • 注意此处不能使用@ResponseBody，否则会将返回值内容作为字符串返回给前端
  • 注意进行页面跳转时，返回值为页面名称，返回值类型为字符串
@RequestMapping("/toJumpPage")
public String toJumpPage() {
    System.out.println("跳转页面");
    return "page.jsp";
}

3.6.3 返回文本数据（了解）

  • 注意此处 @ResponseBody 注解就不能省略
  • 如果省略了会把response text当前页面名称去查找，如果没有回报404
@RequestMapping("/toText")
@ResponseBody
public String toText() {
    System.out.println("返回纯文本数据");
    return "response text";
}

3.6.4 响应 JSON 数据

准备工作：

  • 开启SpringMVC注解驱动，用于开启 json 数据类型自动转换：@EnableWebMvc

    @Configuration
@ComponentScan("priv.dandelion.controller")
@EnableWebMvc
public class SpringMvcConfig {
}
3.6.4.1 响应 POJO 对象
@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO() {
    System.out.println("返回JSON数据对象");
    User user = new User();
    user.setName("dandelion");
    user.setAge(12);
    return user;
}
3.6.4.2 响应 POJO 集合对象

此处返回的是POJO的集合，基本数据类型的集合同理

@RequestMapping("/toJsonList")
@ResponseBody
public List<User> toJsonList() {
    System.out.println("返回JSON数据对象");
    User user1 = new User();
    user1.setName("dandelion");
    user1.setAge(12);

    User user2 = new User();
    user2.setName("dandelion000");
    user2.setAge(15);

    List<User> users = new ArrayList<>();
    users.add(user1);
    users.add(user2);
    return users;
}
3.6.4.3 相关知识点：@ResponseBody

  • 整理

    名称 @ResponseBody
    类型 方法\类注解
    位置 SpringMVC控制器方法定义上方和控制类上
    作用 设置当前控制器返回值作为响应体,
    写在类上，该类的所有方法都有该注解功能
    相关属性 pattern：指定日期时间格式字符串

  • 说明

    • 该注解可以写在类上或者方法上

    • 写在类上就是该类下的所有方法都有@ReponseBody功能

    • 当方法上有@ReponseBody注解后

      • 方法的返回值为字符串，会将其作为文本内容直接响应给前端
      • 方法的返回值为对象，会将对象转换成JSON响应给前端

    • 此处又使用到了类型转换，内部还是通过Converter接口的实现类完成的，所以Converter除了前面所说的功能外，它还可以实现:

      • 对象转Json数据(POJO -> json)

      • 集合转Json数据(Collection -> json)

4、REST风格

4.1 REST 简介

  • REST（Representational State Transfer），表现形式状态转换，它是一种软件架构风格

  • REST风格与传统风格的区别

    • 传统风格资源描述形式

      • http://localhost/user/getById?id=1 查询id为1的用户信息
      • http://localhost/user/saveUser 保存用户信息

    • REST风格描述形式

      • http://localhost/user/1
      • http://localhost/user

  • REST风格的优点

    • 隐藏资源的访问行为，无法通过地址得知对资源是何种操作
    • 书写简化

  • REST风格的使用

    • 按照REST风格访问资源时使用行为动作区分对资源进行了何种操作

      • GET（查询）http://localhost/users 查询全部用户信息
      • GET（查询）http://localhost/users/1 查询指定用户信息
      • POST（新增/保存）http://localhost/users 添加用户信息
      • PUT（修改/更新）http://localhost/users 修改用户信息
      • DELETE（删除）http://localhost/users/1 删除用户信息

    • 请求方式：按照不同的请求方式代表不同的操作类型

      • 发送GET请求是用来做查询
      • 发送POST请求是用来做新增
      • 发送PUT请求是用来做修改
      • 发送DELETE请求是用来做删除

  • 注意

    • 上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范
      • REST提供了对应的架构方式，按照这种架构设计项目可以降低开发的复杂性，提高系统的可伸缩性
      • REST中规定GET/POST/PUT/DELETE针对的是查询/新增/修改/删除，但是我们如果非要用GET请求做删除，这点在程序上运行是可以实现的
      • 但是如果绝大多数人都遵循这种风格，你写的代码让别人读起来就有点莫名其妙了。
    • 描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如:users、books、accounts......

  • RESTful

    • 根据REST风格对资源进行访问称为RESTful

4.2 RESTful 入门案例

4.2.1 环境准备

  • 依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>priv.dandelion</groupId>
    <artifactId>06_rest</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <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.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

  • 配置类

    • 服务器配置类

      public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        return new Filter[]{characterEncodingFilter};
    }
}

    • SpringMVC配置类，开启json数据类型自动转换

      @Configuration
@ComponentScan("priv.dandelion.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

  • 实体类

    • User

      public class User {
    private String name;
    private int age;
    //getter...setter...toString省略
}

    • Book

      public class Book {
    private String name;
    private double price;
     //getter...setter...toString省略
}

  • Controller

    • UserController

      @Controller
public class UserController {
    @RequestMapping("/save")
    @ResponseBody
    public String save(@RequestBody User user) {
        System.out.println("user save..."+user);
        return "{'module':'user save'}";
    }

    @RequestMapping("/delete")
    @ResponseBody
    public String delete(Integer id) {
        System.out.println("user delete..." + id);
        return "{'module':'user delete'}";
    }

    @RequestMapping("/update")
    @ResponseBody
    public String update(@RequestBody User user) {
        System.out.println("user update..." + user);
        return "{'module':'user update'}";
    }

    @RequestMapping("/getById")
    @ResponseBody
    public String getById(Integer id) {
        System.out.println("user getById..." + id);
        return "{'module':'user getById'}";
    }

    @RequestMapping("/findAll")
    @ResponseBody
    public String getAll() {
        System.out.println("user getAll...");
        return "{'module':'user getAll'}";
    }
}

    • BookController

      @Controller
public class BookController {

    @RequestMapping(value = "/books",method = RequestMethod.POST)
    @ResponseBody
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    @RequestMapping(value = "/books/{id}",method = RequestMethod.DELETE)
    @ResponseBody
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    @RequestMapping(value = "/books",method = RequestMethod.PUT)
    @ResponseBody
    public String update(@RequestBody Book book){
        System.out.println("book update..." + book);
        return "{'module':'book update'}";
    }

    @RequestMapping(value = "/books/{id}",method = RequestMethod.GET)
    @ResponseBody
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..." + id);
        return "{'module':'book getById'}";
    }

    @RequestMapping(value = "/books",method = RequestMethod.GET)
    @ResponseBody
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }

}

4.2.2 思路分析

  • 将之前的增删改查替换成RESTful的开发方式
    • 修改前: 新增: /save ,修改: /update,删除 /delete...
  • 修改后:
    • 增删改查: /users
    • 根据GET查询、POST新增、PUT修改、DELETE删除对方法的请求方式进行限定

4.2.3 修改 RESTFUL 风格

4.2.3.1 各项操作

  • 新增

    • 请求

      POST http://localhost/users

    • 接收

      @RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public String save(@RequestBody User user) {
    System.out.println("user save..."+user);
    return "{'module':'user save'}";
}

  • 删除

    • 请求

      DELETE http://localhost/users/1

    • 接收

      • 使用REST风格时，参数写在请求路径中

      • 接收时对参数使用 @PathVariable 注解，在资源路径的参数位置使用{}，其中的值应和参数名称保持一致

      • 若参数名称和{}中的内容不一致，应手动进行绑定，使用 @PathVariable 注解的 value 属性，如下：

        @RequestMapping(value = "/users/{id}", method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable("id") Integer userId) {}

      @RequestMapping(value = "/users/{id}", method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id) {
    System.out.println("user delete..." + id);
    return "{'module':'user delete'}";
}

  • 修改

    • 请求

      PUT http://localhost/users

    • 接收

      @RequestMapping(value = "/users", method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user) {
    System.out.println("user update..." + user);
    return "{'module':'user update'}";
}

  • 查询

    • 查询单个

      • 请求

        GET http://localhost/users/1

      • 接收

        @RequestMapping(value = "/users/{id}", method = RequestMethod.GET)
@ResponseBody
public String getById(@PathVariable Integer id) {
    System.out.println("user getById..." + id);
    return "{'module':'user getById'}";
}

    • 查询所有

      • 请求

        GET http://localhost/users

      • 接收

        @RequestMapping(value = "/users", method = RequestMethod.GET)
@ResponseBody
public String getAll() {
    System.out.println("user getAll...");
    return "{'module':'user getAll'}";
}
4.2.3.2 相关知识点：@PathVarlable
名称 @PathVariable
类型 形参注解
位置 SpringMVC控制器方法形参定义前面
作用 绑定路径参数与处理器方法形参间的关系，要求路径参数名与形参名一一对应
4.2.3.3 相关知识点：三种接收参数的注解

  • 区别

    • @RequestParam 用于接收url地址传参或表单传参
    • @RequestBody 用于接收json数据
    • @PathVariable 用于接收路径参数，使用{参数名称}描述路径参数

  • 应用

    • 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody 应用较广
    • 如果发送非 json 格式数据，选用 @RequestParam 接收请求参数
    • 采用 RESTful 进行开发，当参数数量较少时，例如1个，可以采用 @PathVariable 接收请求路径变量，通常用于传递id值

4.3 RESTFUL 快速开发

4.3.1 开发简化

  • 未简化代码

    @Controller
public class BookController {

    @RequestMapping(value = "/books",method = RequestMethod.POST)
    @ResponseBody
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    @RequestMapping(value = "/books/{id}",method = RequestMethod.DELETE)
    @ResponseBody
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    @RequestMapping(value = "/books",method = RequestMethod.PUT)
    @ResponseBody
    public String update(@RequestBody Book book){
        System.out.println("book update..." + book);
        return "{'module':'book update'}";
    }

    @RequestMapping(value = "/books/{id}",method = RequestMethod.GET)
    @ResponseBody
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..." + id);
        return "{'module':'book getById'}";
    }

    @RequestMapping(value = "/books",method = RequestMethod.GET)
    @ResponseBody
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }

}

  • 简化过程（参见注释）

    1. 将请求路径中共同的部分抽取
    2. 将方法上@RequestMapping中不需要的value属性省略
    3. 将所有方法上的@ResponseBody抽取
    4. 存在@Controller和@ResponseBody，可以使用@RestController代替
    5. 使用@PostMapping、@DeleteMapping等注解代替@RequestMapping
    // @Controller
// 3.所有方法均需要@ResponseBody，抽取
// @ResponseBody
@RestController // 4.其中包含了@Controller和@ResponseBody
// 1.以前缀的形式将请求路径中相同的内容抽取出来
@RequestMapping("/books")
public class BookController {

    // 2.value属性已经完全被抽取，可以省略
    // @RequestMapping(method = RequestMethod.POST)
    // 5.简化上一行代码，下同
    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    // @RequestMapping(value = "/{id}",method = RequestMethod.DELETE)
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    // @RequestMapping(method = RequestMethod.PUT)
    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..." + book);
        return "{'module':'book update'}";
    }

    // @RequestMapping(value = "/{id}",method = RequestMethod.GET)
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..." + id);
        return "{'module':'book getById'}";
    }

    // @RequestMapping(method = RequestMethod.GET)
    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
}

  • 简化后代码

    @RestController
@RequestMapping("/books")
public class BookController {

    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save..." + book);
        return "{'module':'book save'}";
    }

    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id){
        System.out.println("book delete..." + id);
        return "{'module':'book delete'}";
    }

    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..." + book);
        return "{'module':'book update'}";
    }

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..." + id);
        return "{'module':'book getById'}";
    }

    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
}

4.3.2 相关知识点

  • 知识点1：@RestController

    名称 @RestController
    类型 类注解
    位置 基于SpringMVC的RESTful开发控制器类定义上方
    作用 设置当前控制器类为RESTful风格，
    等同于@Controller与@ResponseBody两个注解组合功能

  • 知识点2：@GetMapping @PostMapping @PutMapping @DeleteMapping

    名称 @GetMapping @PostMapping @PutMapping @DeleteMapping
    类型 方法注解
    位置 基于SpringMVC的RESTful开发控制器方法定义上方
    作用 设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作，
    例如@GetMapping对应GET请求
    相关属性 value（默认）：请求访问路径

4.4 RESTFUL 案例

4.4.1 需求分析

4.4.2 环境准备

  • 依赖

    <?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>priv.dandelion</groupId>
    <artifactId>07_rest_case</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <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.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>80</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

  • 配置类

    • 服务器配置类

      public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        return new Filter[]{characterEncodingFilter};
    }
}

    • SpringMVC配置类

      @Configuration
@ComponentScan("priv.dandelion.controller")
@EnableWebMvc
public class SpringMvcConfig {
}

  • 实体类

    public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
    //setter...getter...toString略
}

  • 控制器

    @Controller
public class BookController {

}

4.4.3 后台接口开发

@RestController
@RequestMapping("/books")
public class BookController {

    @PostMapping
    public String save(@RequestBody Book book) {
        System.out.println("book save ==> "+ book);
        return "{'module':'book save success'}";
    }

    @GetMapping
    public List<Book> getAll() {
        System.out.println("book getAll is running ...");
        List<Book> bookList = new ArrayList<Book>();

        Book book1 = new Book();
        book1.setType("计算机");
        book1.setName("SpringMVC1");
        book1.setDescription("123");
        bookList.add(book1);

        Book book2 = new Book();
        book2.setType("计算机");
        book2.setName("SpringMVC2");
        book2.setDescription("234");
        bookList.add(book2);

        Book book3 = new Book();
        book3.setType("计算机丛书");
        book3.setName("SpringMVC3");
        book3.setDescription("345");
        bookList.add(book3);

        return bookList;
    }
}

4.4.4 页面访问处理

  • 页面准备

    • 环境：vue.js + axios + elementui

    • 页面

      <!DOCTYPE html>

<html>
    <head>
        <!-- 页面meta -->
        <meta charset="utf-8">
        <title>SpringMVC案例</title>
        <!-- 引入样式 -->
        <link rel="stylesheet" href="../plugins/elementui/index.css">
        <link rel="stylesheet" href="../plugins/font-awesome/css/font-awesome.min.css">
        <link rel="stylesheet" href="../css/style.css">
    </head>

    <body class="hold-transition">

        <div id="app">

            <div class="content-header">
                <h1>图书管理</h1>
            </div>

            <div class="app-container">
                <div class="box">
                    <div class="filter-container">
                        <el-input placeholder="图书名称" style="width: 200px;" class="filter-item"></el-input>
                        <el-button class="dalfBut">查询</el-button>
                        <el-button type="primary" class="butT" @click="openSave()">新建</el-button>
                    </div>

                    <el-table size="small" current-row-key="id" :data="dataList" stripe highlight-current-row>
                        <el-table-column type="index" align="center" label="序号"></el-table-column>
                        <el-table-column prop="type" label="图书类别" align="center"></el-table-column>
                        <el-table-column prop="name" label="图书名称" align="center"></el-table-column>
                        <el-table-column prop="description" label="描述" align="center"></el-table-column>
                        <el-table-column label="操作" align="center">
                            <template slot-scope="scope">
                                <el-button type="primary" size="mini">编辑</el-button>
                                <el-button size="mini" type="danger">删除</el-button>
                            </template>
                        </el-table-column>
                    </el-table>

                    <div class="pagination-container">
                        <el-pagination
                            class="pagiantion"
                            @current-change="handleCurrentChange"
                            :current-page="pagination.currentPage"
                            :page-size="pagination.pageSize"
                            layout="total, prev, pager, next, jumper"
                            :total="pagination.total">
                        </el-pagination>
                    </div>

                    <!-- 新增标签弹层 -->
                    <div class="add-form">
                        <el-dialog title="新增图书" :visible.sync="dialogFormVisible">
                            <el-form ref="dataAddForm" :model="formData" :rules="rules" label-position="right" label-width="100px">
                                <el-row>
                                    <el-col :span="12">
                                        <el-form-item label="图书类别" prop="type">
                                            <el-input v-model="formData.type"/>
                                        </el-form-item>
                                    </el-col>
                                    <el-col :span="12">
                                        <el-form-item label="图书名称" prop="name">
                                            <el-input v-model="formData.name"/>
                                        </el-form-item>
                                    </el-col>
                                </el-row>
                                <el-row>
                                    <el-col :span="24">
                                        <el-form-item label="描述">
                                            <el-input v-model="formData.description" type="textarea"></el-input>
                                        </el-form-item>
                                    </el-col>
                                </el-row>
                            </el-form>
                            <div slot="footer" class="dialog-footer">
                                <el-button @click="dialogFormVisible = false">取消</el-button>
                                <el-button type="primary" @click="saveBook()">确定</el-button>
                            </div>
                        </el-dialog>
                    </div>

                </div>
            </div>
        </div>
    </body>

    <!-- 引入组件库 -->
    <script src="../js/vue.js"></script>
    <script src="../plugins/elementui/index.js"></script>
    <script type="text/javascript" src="../js/jquery.min.js"></script>
    <script src="../js/axios-0.18.0.js"></script>

    <script>
        var vue = new Vue({

            el: '#app',

            data:{
				dataList: [],//当前页要展示的分页列表数据
                formData: {},//表单数据
                dialogFormVisible: false,//增加表单是否可见
                dialogFormVisible4Edit:false,//编辑表单是否可见
                pagination: {},//分页模型数据，暂时弃用
            },

            //钩子函数，VUE对象初始化完成后自动执行
            created() {
                this.getAll();
            },

            methods: {
                // 重置表单
                resetForm() {
                    //清空输入框
                    this.formData = {};
                },

                // 弹出添加窗口
                openSave() {
                    this.dialogFormVisible = true;
                    this.resetForm();
                },

                //添加
                saveBook () {
                    axios.post("/books",this.formData).then((res)=>{

                    });
                },

                //主页列表查询
                getAll() {
                    axios.get("/books").then((res)=>{
                        this.dataList = res.data;
                    });
                },

            }
        })
    </script>
</html>

  • 页面访问存在问题及解决方案

    • 存在问题：无法访问到页面

      • 报错内容

        [WARNING] Resolved [org.springframework.web.HttpMediaTypeNotAcceptableException: Could not find acceptable representation]
[WARNING] No mapping for GET /pages/books.html

      • 原因

        现在发送请求 http://localhost/pages/books.html 访问这个页面，但是被SpringMVC拦截，认为应该有一个 Controller 中方法的 RequestMapping 叫这个名字

    • 解决方案 放行非SpringMVC的请求

      • 遇到这种情况 SpringMVC 应当放行，由 web 服务器进行处理
      • web 服务器配置类中 getServletMappings 拦截了所有的请求，交给 SpringMVC 处理，需要为 SpringMVC 的配置添加过滤，放行页面请求
      • 对页面的过滤一般单独抽成一个功能类

      • 功能类 SpringMvcSupport

        • 需要继承 WebMvcConfigurationSupport，覆写 addResourceHandlers ，操作 registry 属性
        • 添加 @Configuration 注解，以用于包扫描
        @Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {

    // 添加资源过滤
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        // 当访问页面时，如果请求的是/pages/**，不走MVC，走/pages目录下的内容
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
        // ...
    }
}

      • 配置包扫描

        @Configuration
@ComponentScan({"priv.dandelion.controller","priv.dandelion.config"})
@EnableWebMvc
public class SpringMvcConfig {
}
posted @ 2023-01-26 17:16  Dandelion_000  阅读(426)  评论(2)  编辑  收藏  举报