SpringMVC

第一章 SpingMVC简介

1.1SpringMVC概述

SpringMVC是一种基于Java实现MVC模型的轻量级Web框架
SpringMVC技术与Servlet技术功能等同，均属于web开发技术

优点：

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

传统Servlet

package com.priv.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * @author : 十一
 * @data : 13:45 2022/12/17
 * When in doubt, use brute force.
 */
@WebServlet("/user/delete")
public class UserDeleteServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //1.接受请求参数
        String name = req.getParameter("name");
        System.out.println("servlet delete name ==>" + name);
        //2.产生响应
        resp.setContentType("text/json;charset=utf-8");
        PrintWriter pw = resp.getWriter();
        pw.write("{'module' : 'servlet delete'}");
    }

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

SpringMVC

package com.priv.springmvc;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author : 十一
 * @data : 14:05 2022/12/17
 * When in doubt, use brute force.
 */
@Controller
public class UserController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(String name){
        System.out.println("springmvc save name ==> " + name);
        return "{'module' : 'springmvc save'}";
    }

    @RequestMapping("/delete")
    @ResponseBody
    public String delete(String name){
        System.out.println("springmvc delete name ==> " + name);
        return "{'module' : 'springmvc delete'}";
    }

    @RequestMapping("/select")
    @ResponseBody
    public String select(String name){
        System.out.println("springmvc select name ==> " + name);
        return "{'module' : 'springmvc select'}";
    }

    @RequestMapping("/update")
    @ResponseBody
    public String update(String name){
        System.out.println("springmvc update name ==> " + name);
        return "{'module' : 'springmvc update'}";
    }
}

1.2入门案例

一、先导入SpringMVC和Servlet的坐标

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>6.0.3</version>
</dependency>

二、创建SpringMVC控制器类(等同于Servlet功能)

package com.priv.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author : 十一
 * @data : 14:51 2022/12/25
 * When in doubt, use brute force.
 */
@Controller
public class UserController {

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

三、初始化SpringMVC环境(同Spring环境)，设定SpringMVC加载对应的bean

package com.priv.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author : 十一
 * @data : 14:54 2022/12/25
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan("com.priv.controller")
public class SpringMvcConfig {
}

四、初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC技术处理的请求

package com.priv.config;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

/**
 * @author : 十一
 * @data : 14:56 2022/12/25
 * When in doubt, use brute force.
 */
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    /**
     * 加载SpringMVC容器配置
     */
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    /**
     * 设置哪些请求归属SpringMVC处理
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 加载Spring容器配置
     */
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

20221225151954

1.3入门案例工作流程分析

启动服务器初始化过程

1、服务器启动，执行ServletContainerInitConfig类，初始化web容器

2、执行createServletApplicationContext方法，创建了WebApplicationContext对象

3、加载SpringMvcConfig

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

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

6、执行getServletMappings方法，定义所有的请求都通过SpringMVC
单次请求过程

1、发送请求localhost/save

2、web容器发现所有请求都经过SpringMVC，将请求交给SpringMVC处理

3、解析请求路径/save

4、由/save匹配执行对应的方法save()

5、执行save()

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

1.4Controller加载控制

一、因为功能不同，如何避免Spring错误的加载到SpringMVC的bean？

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

SpringMVC相关bean加载控制
- SpringMVC加载的bean对应的包均在com.priv.controller包内
Spring相关bean加载控制
- 方式一：Spring加载的bean设定扫描范围为com.priv，排除掉controller包内的bean
- 方式二：Spring加载的bean设定扫描范围为精准范围，如service包，dao包等
- 方式三：不区分Spring与SpringMVC的环境，加载到同一个环境中

package com.priv.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

/**
 * @author : 十一
 * @data : 14:54 2022/12/25
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan(value = "com.priv",
        excludeFilters = @ComponentScan.Filter(
            type = FilterType.ANNOTATION,//按注解排除，使用Controller注解排除
            classes = Controller.class                
))
public class SpringConfig {
}

package com.priv.config;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

/**
 * @author : 十一
 * @data : 14:56 2022/12/25
 * When in doubt, use brute force.
 */
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    /**
     * 加载SpringMVC容器配置
     */
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }

    /**
     * 设置哪些请求归属SpringMVC处理
     */
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    /**
     * 加载Spring容器配置
     */
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }
}

二、@ComponentScan

类型：类注解

属性：

excludeFilters：排除扫描路径中加载的bean，需要指定类别(type)与具体项(classes)
includeFilters：加载指定的bean，需要指定类别(type)与具体项(classes)

三、替换简单的初始化web容器方法：

去继承AbstractDispatcherServletInitializer的子类AbstractAnnotationConfigDispatcherServletInitializer：

package com.priv.config;

import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
import org.springframework.web.servlet.support.AbstractDispatcherServletInitializer;

/**
 * @author : 十一
 * @data : 14:56 2022/12/25
 * When in doubt, use brute force.
 */
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[]{"/"};
    }
}

1.5PostMan

Postman是一款功能强大的网页调试与发送网页HTTP请求的Chrome插件
作用：常用于进行接口测试

20221225172844

第二章请求与响应

2.1请求映射路径

一、团队多人开发，每个人设置不同的请求路径，冲突问题如何解决？

设置模块名作为请求路径前缀

package com.priv.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author : 十一
 * @data : 12:10 2022/12/26
 * When in doubt, use brute force.
 */
@Controller
@RequestMapping("/book")
public class BookController {

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

package com.priv.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author : 十一
 * @data : 17:10 2022/12/25
 * When in doubt, use brute force.
 */
@Controller
@RequestMapping("/user")
public class UserController {

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

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

20221226121942

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

2.2请求参数

Get请求传参

普通参数：url地址传参，地址参数名与形参变量名相同，定义形参即可接收参数

Post请求参数

普通参数：form表单post请求传参，表单参数名与形参变量名相同，定义形参即可接收参数

package com.priv.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author : 十一
 * @data : 18:05 2022/12/26
 * When in doubt, use brute force.
 */
@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' : 'common param'";
    }
}

乱码问题(Post请求)

为web容器添加过滤器并指定字符集，Spring-web包中提供了专用的字符过滤器

package com.priv.config;

import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

import javax.servlet.Filter;

/**
 * @author : 十一
 * @data : 18:06 2022/12/26
 * When in doubt, use brute force.
 */
public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

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

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

    /**
     * 乱码处理
     */
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

20221226185112

请求参数

普通参数
- 请求参数名与形参变量名不同，使用@RequestParam绑定参数关系
POJO类型参数
- 请求参数名与形参对象属性名相同，定义POJO类型形参即可接收参数
嵌套POJO类型参数
- 请求参数名与形参对象属性名相同，按照对象层次结构关系即可接收嵌套POJO属性参数
数组类型参数
- 请求参数名与形参对象属性名相同且请求参数为多个，定义数组类型形参即可接收参数
集合类型参数
- 请求参数名与形参集合对象名相同且请求参数为多个，@RequestParam绑定参数关系

package com.priv.controller;

import com.priv.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.Arrays;
import java.util.List;

/**
 * @author : 十一
 * @data : 18:05 2022/12/26
 * When in doubt, use brute force.
 */
@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' : 'common param'";
    }

    /**
     * 普通参数：请求参数名与形参名不同
     */
    @RequestMapping("/commonParamDifferentName")
    @ResponseBody
    public String commonParamDifferentName(@RequestParam("name") String username, int age){
        System.out.println("普通参数传递 username ==> " + username);
        System.out.println("普通参数传递 age ==> " + age);
        return "'module' : 'common param different name'";
    }

    /**
     * POJO参数
     */
    @RequestMapping("/pojoParam")
    @ResponseBody
    public String pojoParam(User user){
        System.out.println("pojo参数传递 user ==> " + user);
        return "'module' : 'pojo param'";
    }

    /**
     * 嵌套POJO参数
     */
    @RequestMapping("/pojoContainPojoParam")
    @ResponseBody
    public String pojoContainPojoParam(User user){
        System.out.println("pojo嵌套pojo参数传递 user ==> " + user);
        return "'module' : 'pojo contain pojo param'";
    }

    /**
     * 数组参数
     */
    @RequestMapping("/arrayParam")
    @ResponseBody
    public String arrayParam(String[] likes){
        System.out.println("数组参数传递 likes ==> " + Arrays.toString(likes));
        return "'module' : 'array param'";
    }

    /**
     * 集合参数
     */
    @RequestMapping("/listParam")
    @ResponseBody
    public String listParam(@RequestParam List<String> likes){
        System.out.println("集合参数传递 likes ==> " + likes);
        return "'module' : 'list param'";
    }
}

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

20221227141117

传递json数据

一、json数组

/**
 * 集合参数：json数据
 */
@RequestMapping("/listParamForJson")
@ResponseBody
public String listParamForJson(@RequestBody List<String> likes){
    System.out.println("list common(json)参数传递 list ==> " + likes);
    return "'module' : 'list common for json param'";
}

二、json对象(POJO)

json数据与形参对象属性名相同，定义POJO类型形参即可接收参数

/**
 * POJO参数：json数据
 */
@RequestMapping("/pojoParamForJson")
@ResponseBody
public String pojoParamForJson(@RequestBody User user){
    System.out.println("pojo(json)参数传递 user ==> " + user);
    return "'module' : 'pojo for json param'";
}

三、json数组(POJO)

json数组数据与集合泛型属性名相同，定义List类型形参即可接收参数

/**
 * 集合参数：json数据
 */
@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'";
}

第一步：添加json数据转换相关坐标

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

第二步：设置发送json数据

第三步：开启自动转换json数据的支持

package com.priv.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;

/**
 * @author : 十一
 * @data : 18:04 2022/12/26
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan("com.priv.controller")
@EnableWebMvc//开启自动转换json数据的支持
public class SpringMvcConfig {
}

第四步：设置接收json数据

@RequestBody

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

2.3日期类型参数传递

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

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

类型转换器

Converter接口

public interface Converter<S, T>{
	@Nullable
	T convert(S source);
}

请求参数年龄数据(String -> Integer)
日期格式转换(String -> Date)
@EnableWebMvc功能之一：根据类型匹配对应的类型转换器

2.4响应json数据

package com.priv.controller;

import com.priv.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.List;

/**
 * @author : 十一
 * @data : 15:12 2022/12/27
 * When in doubt, use brute force.
 */
@Controller
public class UserController {

    /**
     * 响应页面 跳转页面
     */
    @RequestMapping("/toJumpPage")
    public String toJumpPage(){
        System.out.println("跳转页面");
        return "index.jsp";
    }

    /**
     * 响应文本数据
     */
    @RequestMapping("/toText")
    @ResponseBody
    public String toText(){
        System.out.println("返回纯文本数据");
        return "response text";
    }

    /**
     * 响应POJO对象
     */
    @RequestMapping("/toJsonPOJO")
    @ResponseBody
    public User toJsonPOJO(){
        System.out.println("返回json对象数据");
        User user = new User();
        user.setName("Jack");
        user.setAge(19);
        return user;
    }

    /**
     * 响应POJO集合对象
     */
    @RequestMapping("/toJsonList")
    @ResponseBody
    public List<User> toJsonList(){
        System.out.println("返回json集合数据");
        User user1 = new User();
        user1.setName("Java");
        user1.setAge(14);

        User user2 = new User();
        user2.setName("Go");
        user2.setAge(10);

        ArrayList<User> userList = new ArrayList<>();
        userList.add(user1);
        userList.add(user2);

        return userList;
    }
}

响应

名称：@ResponseBody
类型：方法注解
位置：SpringMVC控制器方法定义上方
作用：设置当前控制器返回值作为响应体

底层：HttpMessageConverter接口

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.http.converter;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.lang.Nullable;

public interface HttpMessageConverter<T> {
    boolean canRead(Class<?> clazz, @Nullable MediaType mediaType);

    boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType);

    List<MediaType> getSupportedMediaTypes();

    default List<MediaType> getSupportedMediaTypes(Class<?> clazz) {
        return !this.canRead(clazz, (MediaType)null) && !this.canWrite(clazz, (MediaType)null) ? Collections.emptyList() : this.getSupportedMediaTypes();
    }

    T read(Class<? extends T> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException;

    void write(T t, @Nullable MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException;
}

第三章 REST风格

3.1REST简介

REST(Representational State Transfer)，表现形式状态转换

传统风格资源描述形式

http://localhost/user/getById?id=1

http://localhost/user/saveUser

REST风格描述形式

http://localhost/user/1

http://localhost/user

优点：

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

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

tips：上述行为是约定方式，约定不是规范，可以打破，所以称为REST风格，而不是REST规范

描述模块的名称通常使用复数，也就是加s的格式描述，表示此类资源，而非单个资源，例如：users、books、accounts

3.2RESTful入门案例

设定http请求动作
设定请求参数(路径变量)
名称：@RequestMapping
类型：方法注解
位置：SpringMVC控制器方法定义上方
作用：设置当前控制器方法请求访问路径
属性：
- value：请求访问路径(默认)
- method：http请求动作，标准动作(GET/POST/PUT/DELETE)
名称：@PathVariable
类型：形参注解
位置：SpringMVC控制器方法形参定义前面
作用：绑定路径参数与处理器方法形参间的关系，要求路径参数名与形参名一一对应

package com.priv.controller;

import com.priv.domain.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

/**
 * @author : 十一
 * @data : 20:19 2022/12/27
 * When in doubt, use brute force.
 */
@Controller
public class UserController {

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

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

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

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

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

}

3.3REST快速开发

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

package com.priv.controller;

import com.priv.domain.User;
import org.springframework.web.bind.annotation.*;

/**
 * @author : 十一
 * @data : 20:46 2022/12/27
 * When in doubt, use brute force.
 */
@RestController
@RequestMapping("/books")
public class BookController {

    @PostMapping
    public String save(){
        System.out.println("book save...");
        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 User user){
        System.out.println("book update..." + user);
        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'}";
    }
}

tips：当访问静态资源时，SpringMVC会进行拦截，需要配置资源放行，交给Tomcat去处理

package com.priv.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

/**
 * @author : 十一
 * @data : 21:03 2022/12/27
 * When in doubt, use brute force.
 */
@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**","/pages/");
        registry.addResourceHandler("/js/**","/js/");
        registry.addResourceHandler("/css/**","/css/");
        registry.addResourceHandler("/plugins/**","/plugins/");
    }
}

第四章 SSM整合

4.1SSM整合

SSM整合流程

1、创建工程

2、SSM整合

Spring
- SpringConfig
Mybatis
- MybatisConfig
- JdbcConfig
- jdbc.properties
SpringMVC
- ServletConfig
- SpringMvcConfig

3、功能模块

表与实体类
dao(接口+自动代理)
service(接口+实现类)
- 业务层接口测试(整合JUnit)
controller
- 表现层接口测试(PostMan)

Spring整合MyBatis

配置
- SpringConfig
- JdbcConfig、jdbc.properties
- MyBatisConfig
模型
- Book
数据层标准开发
- BookDao
业务层标准开发
- BookService
- BookServiceImpl
测试接口
- BookServiceTest
事务处理

Spring整合SpringMVC

web配置类
SpringMVC配置类
基于Restful的Controller开发

4.2表现层数据封装

前端接收数据格式：

创建结果模型类，封装数据到data属性中
封装操作结果到code属性中
封装特殊消息到message(msg)属性中
设置统一数据返回结果类

public class Result{
	private Object data;
	private Integer code;
	private String msg;
}

tips：Result类中的字段并不是固定的，可以根据需要自行增减，提供若干个构造方法，方便操作

设置统一数据返回结果编码

package com.priv.controller;

/**
 * @author : 十一
 * @data : 17:56 2022/12/28
 * When in doubt, use brute force.
 */
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

根据情况设定合理的Result

package com.priv.controller;

import com.priv.domain.Book;
import com.priv.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * @author : 十一
 * @data : 13:06 2022/12/28
 * When in doubt, use brute force.
 */
@RestController
@RequestMapping("/books")
public class BookController {

    @Autowired
    private BookService bookService;

    @PostMapping
    public Result save(@RequestBody Book book) {
        boolean flag = bookService.save(book);
        return new Result(flag ? Code.SAVE_OK : Code.SAVE_ERR, flag);
    }

    @PutMapping
    public Result update(@RequestBody Book book) {
        boolean flag = bookService.update(book);
        return new Result(flag ? Code.UPDATE_OK : Code.UPDATE_ERR, flag);
    }

    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) {
        boolean flag = bookService.delete(id);
        return new Result(flag ? Code.DELETE_OK : Code.DELETE_ERR, flag);
    }

    @GetMapping("/{id}")
    public Result findById(@PathVariable Integer id) {
        Book book = bookService.findById(id);
        Integer code = book != null ? Code.GET_OK : Code.GET_ERR;
        String msg = book != null ? "" : "数据查询失败，请重试！";
        return new Result(code, book, msg);
    }

    @GetMapping
    public Result findAll() {
        List<Book> bookList = bookService.findAll();
        Integer code = bookList != null ? Code.GET_OK : Code.GET_ERR;
        String msg = bookList != null ? "" : "数据查询失败，请重试！";
        return new Result(code, bookList, msg);
    }
}

4.3异常处理器

程序开发过程中不可避免的会遇到异常现象

出现异常现象的常见位置与常见诱因如下：

框架内部抛出的异常：因使用不合规导致
数据层抛出的异常：因外部服务器故障导致(例如：服务器超时访问)
业务层抛出的异常：因业务逻辑书写错误导致(例如：遍历业务书写操作，导致索引异常等)
表现层抛出的异常：因数据收集、校验等规则导致(例如：不匹配的数据类型间导致异常)
工具类抛出的异常：因工具类书写不严谨不够健壮导致(例如：必要释放的连接长期未释放等)

一、各个层级均出现异常，异常处理代码书写在哪一层？

所有的异常均抛出到表现层进行处理

二、表现层处理异常，每个方法单独书写，代码书写量巨大且意义不强，如何解决？

AOP思想

异常处理器

集中的、统一的处理项目中出现的异常

package com.priv.controller;

import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * @author : 十一
 * @data : 18:39 2022/12/28
 * When in doubt, use brute force.
 */
@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(Exception.class)
    public Result doException(Exception exception){
        System.out.println("出现异常");
        return new Result(666, null);
    }
}

名称：@RestControllerAdvice
类型：类注解
位置：Rest风格开发的控制器增强类定义上方
作用：为Rest风格开发的控制器类做增强
说明：此注解自带@ResponseBody注解与@Component注解，具备对应的功能
名称：@ExceptionHandler
类型：方法注解
位置：专用于异常处理的控制器方法上方
作用：设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行，并转入当前方法执行
说明：此类方法可以根据处理的异常不同，制作多个方法分别处理对应的异常

4.4项目异常处理方案

项目异常分类
- 业务异常(BusinessException)：规范的用户行为产生的异常，不规范的用户行为操作产生的异常
  - 发送对应消息传递给用户，提醒规范操作
- 系统异常(SystemException)：项目运行过程中可预计且无法避免的异常
  - 发送固定消息传递给用户，安抚用户
  - 发送特定消息给运维人员，提醒维护
  - 记录日志
- 其他异常(Exception)：编程任意未预期到的异常
  - 发送固定消息传递给用户，安抚用户
  - 发送特定消息给编程人员，提醒维护(纳入预期范围内)
  - 记录日志

自定义项目系统级异常

package com.priv.exception;

/**
 * @author : 十一
 * @data : 21:13 2022/12/28
 * When in doubt, use brute force.
 */
public class SystemException extends RuntimeException{

    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    /**
     * Constructs a new runtime exception with the specified detail message.
     * The cause is not initialized, and may subsequently be initialized by a
     * call to {@link #initCause}.
     *
     * @param message the detail message. The detail message is saved for
     *                later retrieval by the {@link #getMessage()} method.
     */
    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    /**
     * Constructs a new runtime exception with the specified detail message and
     * cause.  <p>Note that the detail message associated with
     * {@code cause} is <i>not</i> automatically incorporated in
     * this runtime exception's detail message.
     *
     * @param message the detail message (which is saved for later retrieval
     *                by the {@link #getMessage()} method).
     * @param cause   the cause (which is saved for later retrieval by the
     *                {@link #getCause()} method).  (A {@code null} value is
     *                permitted, and indicates that the cause is nonexistent or
     *                unknown.)
     * @since 1.4
     */
    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }

}

自定义项目业务级异常

package com.priv.exception;

/**
 * @author : 十一
 * @data : 21:16 2022/12/28
 * When in doubt, use brute force.
 */
public class BusinessException extends RuntimeException{
    private Integer code;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    /**
     * Constructs a new runtime exception with the specified detail message.
     * The cause is not initialized, and may subsequently be initialized by a
     * call to {@link #initCause}.
     *
     * @param message the detail message. The detail message is saved for
     *                later retrieval by the {@link #getMessage()} method.
     */
    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }

    /**
     * Constructs a new runtime exception with the specified detail message and
     * cause.  <p>Note that the detail message associated with
     * {@code cause} is <i>not</i> automatically incorporated in
     * this runtime exception's detail message.
     *
     * @param message the detail message (which is saved for later retrieval
     *                by the {@link #getMessage()} method).
     * @param cause   the cause (which is saved for later retrieval by the
     *                {@link #getCause()} method).  (A {@code null} value is
     *                permitted, and indicates that the cause is nonexistent or
     *                unknown.)
     * @since 1.4
     */
    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }
}

自定义异常编码

package com.priv.controller;

/**
 * @author : 十一
 * @data : 17:56 2022/12/28
 * When in doubt, use brute force.
 */
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;

    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;

    public static final Integer SYSTEM_ERR = 50001;
    public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
    public static final Integer SYSTEM_UNKNOW_ERR = 59999;
    public static final Integer BUSINESS_ERR = 60002;
}

触发自定义异常

package com.priv.service.impl;

import com.priv.controller.Code;
import com.priv.dao.BookDao;
import com.priv.domain.Book;
import com.priv.exception.BusinessException;
import com.priv.exception.SystemException;
import com.priv.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author : 十一
 * @data : 13:05 2022/12/28
 * When in doubt, use brute force.
 */
@Service
public class BookServiceImpl implements BookService {

    @Autowired
    private BookDao bookDao;
    /**
     * 按id查询
     *
     * @param id
     * @return
     */
    public Book findById(Integer id) {
        if (id == 1){
            throw new BusinessException(Code.BUSINESS_ERR,"出异常了！");
        }
        try {
            int i = 1/0;
        }catch (Exception e){
            throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请重试！",e);
        }

        return bookDao.findById(id);
    }
}

拦截并处理异常

package com.priv.controller;

import com.priv.exception.BusinessException;
import com.priv.exception.SystemException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/**
 * @author : 十一
 * @data : 18:39 2022/12/28
 * When in doubt, use brute force.
 */
@RestControllerAdvice
public class ProjectExceptionAdvice {

    @ExceptionHandler(SystemException.class)
    public Result doSystemException(SystemException exception){
        /**
         * 记录日志
         * 发送消息给运维
         * 发送邮件给开发人员，exception对象发送给开发人员
         */
        return new Result(exception.getCode(), null, exception.getMessage());
    }


    @ExceptionHandler(BusinessException.class)
    public Result doBusinessException(BusinessException exception){
        return new Result(exception.getCode(), null, exception.getMessage());
    }


    @ExceptionHandler(Exception.class)
    public Result doException(Exception exception){
        /**
         * 记录日志
         * 发送消息给运维
         * 发送邮件给开发人员，exception对象发送给开发人员
         */
        return new Result(Code.SYSTEM_UNKNOW_ERR, null, "系统繁忙，请稍后再试！");
    }
}

4.5案例：SSM整合标准开发

methods: {
    //列表
    getAll() {
        axios.get("/books").then((res)=>{
            this.dataList = res.data.data;
        });
    },

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

    //重置表单
    resetForm() {
        this.formData = {};
    },

    //添加
    handleAdd () {
        axios.post("/books",this.formData).then((res)=>{
            if (res.data.code == 20011){
                this.dialogFormVisible = false;
                this.$message.success("添加成功");
            }else if (res.data.code == 20010){
                this.$message.error("添加失败");
            }else {
                this.$message.error(res.data.msg);
            }
        }).finally(()=>{
           this.getAll();
        });
    },

    //弹出编辑窗口
    handleUpdate(row) {
        axios.get("/books/" + row.id).then((res)=>{
            if (res.data.code == 20041){
                this.formData = res.data.data;
                this.dialogFormVisible4Edit = true;
            }else {
                this.$message.error(res.data.msg);
            }

        });
    },

    //编辑
    handleEdit() {
        axios.put("/books",this.formData).then((res)=>{
            if (res.data.code == 20031){
                this.dialogFormVisible4Edit = false;
                this.$message.success("修改成功");
            }else if (res.data.code == 20030){
                this.$message.error("修改失败");
            }else {
                this.$message.error(res.data.msg);
            }
        }).finally(()=>{
            this.getAll();
        });
    },

    // 删除
    handleDelete(row) {
        this.$confirm("此操作永久删除当前数据，是否继续？", "提示", {
            type: 'info'
        }).then(()=>{
            axios.delete("/books/" + row.id).then((res)=>{
                if (res.data.code == 20021){
                    this.$message.success("删除成功");
                }else {
                    this.$message.error("删除失败");
                }
            }).finally(()=>{
                this.getAll();
            });
        }).catch(()=>{
            this.$message.info("取消删除操作");
        });
    }
}

第五章拦截器

5.1拦截器概念

拦截器(Interceptor)：是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行

作用：

在指定的方法调用前后执行预先设定的代码
阻止原始方法的执行

拦截器与过滤器的区别

归属不同：Filter属于Servlet技术，Interceptor属于SpringMVC技术
拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

5.2入门案例

声明拦截器的bean，并实现HandlerInterceptor接口(注意：扫描加载bean)

package com.priv.controller.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @author : 十一
 * @data : 22:54 2022/12/28
 * When in doubt, use brute force.
 */
@Component
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        /**
         * 是否终止原始操作
         * false：终止
         * true：不终止
         */
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

定义配置类，继承WebMvcConfigurationSupport，实现addInterceptor方法(注意：扫描加载配置)
添加拦截器并设定拦截的访问路径，路径可以通过可变参数设置多个

package com.priv.config;

import com.priv.controller.interceptor.ProjectInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

/**
 * @author : 十一
 * @data : 21:03 2022/12/27
 * When in doubt, use brute force.
 */
@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {

    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
    }

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books", "/books/*");
    }
}

使用标准接口WebMvcConfigurer简化开发(注意：侵入式较强)

package com.priv.config;

import com.priv.controller.interceptor.ProjectInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * @author : 十一
 * @data : 22:51 2022/12/28
 * When in doubt, use brute force.
 */
@Configuration
@ComponentScan("com.priv.controller")
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books", "/books/*");
    }
}

执行流程

5.3拦截器参数

前置处理

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    System.out.println("preHandle...");
    /**
     * 是否终止原始操作
     * false：终止
     * true：不终止
     */
    return true;
}

参数：
- request：请求对象
- response：响应对象
- handler：被调用的处理器对象，本质上是一个方法对象，对反射技术中的Method对象进行了再包装
返回值
- 返回值为false，被拦截的处理器将不执行
后置处理

@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    System.out.println("postHandle...");
}

参数：
- modelAndView：如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整
完成后处理

@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    System.out.println("afterCompletion...");
}

参数：
- ex：如果处理器执行过程中出现异常对象，可以针对异常情况单独处理

5.4拦截器工作流程分析

多拦截器执行顺序

当配置多个拦截器时，形成拦截器链
拦截器链的运行顺序参照拦截器添加顺序为准
当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行
当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

拦截器链的运行顺序

preHandle：与配置顺序相同，必定运行
postHandle：与配置顺序相反，可能不运行
afterCompletion：与配置顺序相反，可能不运行

SpringMVC

第一章 SpingMVC简介

1.1SpringMVC概述

1.2入门案例

1.3入门案例工作流程分析

1.4Controller加载控制

1.5PostMan

第二章 请求与响应

2.1请求映射路径

2.2请求参数

2.3日期类型参数传递

2.4响应json数据

第三章 REST风格

3.1REST简介

3.2RESTful入门案例

3.3REST快速开发

第四章 SSM整合

4.1SSM整合

4.2表现层数据封装

4.3异常处理器

4.4项目异常处理方案

4.5案例：SSM整合标准开发

第五章 拦截器

5.1拦截器概念

5.2入门案例

5.3拦截器参数

5.4拦截器工作流程分析

小结

第二章请求与响应

第五章拦截器