SpringMVC修炼之旅（1）什么是SpringMVC

一、什么是MVC

1.1概述

• MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。

• 是将业务逻辑、数据、显示分离的方法来组织代码。

• MVC主要作用是降低了视图与业务逻辑间的双向偶合。

• MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

 Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据Dao） 和 服务层（行为Service）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。也就是说控制器做了个调度员的工作。

最典型的MVC就是JSP + servlet + javabean的模式。

职责分析：

Controller：控制器

1. 取得表单数据

2. 调用业务逻辑

3. 转向指定的页面

Model：模型

1. 业务逻辑

2. 保存数据的状态

View：视图

1. 显示页面

 1.2Servlet

环境配置

 
        
            junit
            junit
            4.12
        
        
            org.springframework
            spring-webmvc
            5.1.9.RELEASE
        
        
            javax.servlet
            servlet-api
            2.5
        
        
        
            jakarta.servlet
            jakarta.servlet-api
            6.0.0
            provided
        
        
        
            jakarta.servlet.jsp.jstl
            jakarta.servlet.jsp.jstl-api
            3.0.0
        
        
        
            org.glassfish.web
            jakarta.servlet.jsp.jstl
            3.0.1
        
        
            javax.servlet
            jstl
            1.2
        
    

编写一个Servlet类

package com.yanyu.test;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet("/hello")
//实现Servlet接口
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //取得参数
        String method = req.getParameter("method");
        if (method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if (method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //业务逻辑
        //视图跳转
        req.getRequestDispatcher("/WEB-INF/jsp/hello.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }
}

编写Hello.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


  
  


${msg}

二、什么是SpringMVC

2.1Spring MVC的特点

1. 轻量级，简单易学

2. 高效 , 基于请求响应的MVC框架

3. 与Spring兼容性好，无缝结合

4. 约定优于配置

5. 功能强大：RESTful、数据验证、格式化、本地化、主题等

6. 简洁灵活

Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。

DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；

正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等......所以我们要学习 .

2.2中心控制器

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

SpringMVC的原理如下图所示：

当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

2.3SpringMVC执行原理

图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

简要分析执行流程

1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

   我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

   如上url拆分成三部分：

   http://localhost:8080服务器域名

   SpringMVC部署在服务器上的web站点

   hello表示控制器

   通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

2. HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping,HandlerMapping根据请求url查找Handler。

3. HandlerExecution表示具体的Handler,其主要作用是根据url查找控制器，如上url被查找控制器为：hello。

4. HandlerExecution将解析后的信息传递给DispatcherServlet,如解析控制器映射等。

5. HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler。

6. Handler让具体的Controller执行。

7. Controller将具体的执行信息返回给HandlerAdapter,如ModelAndView。

8. HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet。

9. DispatcherServlet调用视图解析器(ViewResolver)来解析HandlerAdapter传递的逻辑视图名。

10. 视图解析器将解析的逻辑视图名传给DispatcherServlet。

11. DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图。

12. 最终视图呈现给用户。

2.4Java Json解析框架

这里有四个常用的Java JSON解析框架：Gson，FastJson，Jackson和Json-lib。这些框架都有各自的优缺点。其中，Gson是功能最全的JSON解析器之一，无需额外的jar包就能直接运行在JDK上。FastJson是阿里巴巴公司开发的高性能JSON处理器，采用独创的算法，将parse的速度提升到极致，超过所有JSON库。Jackson是当前用得比较广泛的Java开源框架，它所依赖的jar包较少，简单易用。Json-lib最开始也是应用最广泛的JSON解析工具之一，但现在在功能和性能上都不能满足互联网化的需求。 

2.5相关注解

 @Controller注解

SpringMVC中，@Controller注解是用来标记一个类是一个控制器，也就是一个处理请求的组件。@Controller注解可以让一个普通的Java类变成一个SpringMVC的控制器，而不需要实现任何接口或继承任何类。@Controller注解可以和@RequestMapping注解配合使用，来定义请求和控制器方法之间的映射关系。@Controller注解还可以和其他注解一起使用，来实现更多的功能，比如@RequestParam、@PathVariable、@ModelAttribute等。

@RestController注解

SpringMVC中，@RestController注解是用来标记一个类是一个RESTful风格的控制器，也就是说，该类中的所有方法的返回值都会直接写入HTTP响应体中，而不需要经过视图解析器。@RestController注解相当于@Controller和@ResponseBody注解的组合，可以简化开发过程。@RestController注解可以和@RequestMapping注解配合使用，来定义请求和控制器方法之间的映射关系。@RestController注解还可以和其他注解一起使用，来实现更多的功能，比如@PathVariable、@RequestParam、@RequestBody等。 

@RequestMapping注解

SpringMVC中，@RequestMapping注解是用来将请求和处理请求的控制器方法关联起来，建立映射关系。@RequestMapping注解可以标注在类或者方法上，用来定义请求的URL地址、请求的方式、请求的参数、请求的头部等。@RequestMapping注解还可以和其他注解一起使用，来实现更多的功能，比如@PathVariable、@RequestParam、@RequestBody等。 

三、第一个程序

实体类

package com.example.springmvcexamples.example01.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.time.LocalDateTime;

@Data
@NoArgsConstructor
public class Address {
    private Integer id; // 地址的ID
    private String detail; // 地址的详细信息
    private String comment; // 地址的备注
    private User user; // 地址所属的用户
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 指定日期时间的格式化模式
    private LocalDateTime inertTime; // 地址的创建时间

    public Address(Integer id, String detail, String comment, LocalDateTime inertTime) {
        this.id = id;
        this.detail = detail;
        this.comment = comment;
        this.inertTime = inertTime;
    }
}

package com.example.springmvcexamples.example01.entity;

import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
public class User {
    private Integer id;
}

控制类

package com.example.springmvcexamples.example01;

import com.example.springmvcexamples.example01.entity.Address;
import com.example.springmvcexamples.vo.ResultVO;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController
@RequestMapping("/api/example01/")
public class ExampleController01 {
    // 返回一个 ResultVO 对象，其中包含一个名为 "name" 的键和值为 "SUN" 的映射
    @GetMapping("index")
    public ResultVO getIndex() {
        return ResultVO.success(Map.of("name", "SUN"));
    }

    // 返回一个 ResultVO 对象，其中包含一个名为 "addresses" 的键和值为 ADDRESSES 的映射
    @GetMapping("addresses")
    public ResultVO getAddresses() {
        return ResultVO.success(Map.of("addresses", ADDRESSES));
    }

    // 接收一个 Address 对象作为请求体，并打印 address 的 detail 和 comment 属性
    @PostMapping("addresses")
    public ResultVO postAddress(@RequestBody Address address) {
        log.debug(address.getDetail());
        log.debug(address.getComment());
        return ResultVO.success(Map.of());
    }

    // 接收一个 Address 对象作为请求体，并打印 address 的 detail、comment 和 user 的 id 属性
    @PostMapping("addresses02")
    public ResultVO postAddress2(@RequestBody Address address) {
        log.debug(address.getDetail());
        log.debug(address.getComment());
        log.debug("{}", address.getUser().getId());
        return ResultVO.success(Map.of());
    }

    // 根据 aid 的值从 ADDRESSES 中查找对应的 Address 对象，并返回一个 ResultVO 对象，其中包含一个名为 "address" 的键和对应的 Address 对象的映射
    @GetMapping("addresses/{aid}")
    public ResultVO getAddress(@PathVariable("aid") int aid) {
        Address address = ADDRESSES.stream()
                .filter(a -> a.getId() == aid)
                .findFirst()
                .orElse(new Address());
        return ResultVO.success(Map.of("address", address));
    }

    // 打印请求的 URI 和请求头的信息
    @GetMapping("inject")
    public void inject(HttpServletRequest request,
                       HttpServletResponse response,
                       @RequestHeader HttpHeaders headers) {
        log.debug(request.getRequestURI());
        log.debug(String.valueOf(headers));
    }

    @Autowired
    private ObjectMapper mapper;

    // 使用 @RequestParam 接收传统的 `?` 传参，打印接收到的 address 参数，并将其转换为 Address 对象，并打印 detail 属性
    @GetMapping("search")
    public ResultVO getJson(@RequestParam String address) throws JsonProcessingException {
        log.debug(address);
        Address a = mapper.readValue(address, Address.class);
        log.debug(a.getDetail());
        return ResultVO.success(Map.of("name", "BO"));
    }

    // 创建一个包含三个 Address 对象的列表
    private final List
 ADDRESSES = create();

    private List
 create() {
        Address a1 = new Address(1, "956", "a", LocalDateTime.now());
        Address a2 = new Address(2, "925", "b", LocalDateTime.now());
        Address a3 = new Address(3, "121", null, null);
        return List.of(a1, a2, a3);
    }
}

测试

###
GET http://localhost:8080/api/example01/index

###
GET http://localhost:8080/api/example01/addresses

###
POST http://localhost:8080/api/example01/addresses
Content-Type: application/json

{
  "detail": "956",
  "comment": "测试"
}

###
GET http://localhost:8080/api/example01/addresses/3

###
POST http://localhost:8080/api/example01/addresses02
Content-Type: application/json

{
  "detail": "956",
  "comment": "测试",
  "user3": {
    "id": 10
  }
}
###
GET http://localhost:8080/api/example01/inject

### 传统`?`传参，支持传递json字符串
GET http://localhost:8080/api/example01/search?address={"detail": "12"}