[SpringBoot3]Web服务

五、Web服务

  • 基于浏览器的B/S结构应用十分流行。SpringBoot非常适合Web应用开发,可以使用嵌入式Tomcat、Jetty、Undertow或Netty创建一个自包含的HTTP服务器。一个SpringBoot的Web应用能够自己独立运行,不依赖需要安装的Tomcat、Jetty等。
  • SpringBoot可以创建两种类型的Web应用
    • 基于Servlet体系的Spring Web MVC应用
    • 使用spring-boot-starter-webflux模块来构建响应式,非阻塞的Web应用程序
  • Spring WebFlux是单独一个体系的内容。Spring Web MVC又被称为SpringMVC,专注web应用开发。我们快速的创建控制器(Controller),接受来自浏览器或其他客户端的请求,并将业务代码的结果返回给请求方。

[SpringBoot3]Web服务_第1张图片

5.1高效构建Web应用

  • 创建Web应用,依赖选择spring-web(包含了Spring MVC、Tomcat)、Thymeleaf(视图技术,代替jsp)、Lombok。
  • 项目结构:

[SpringBoot3]Web服务_第2张图片

5.1.1html页面视图

1.Maven依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-thymeleafartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>

    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <optional>trueoptional>
    dependency>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
    dependency>
dependencies>

2.创建Controller

@Controller
/**
 * @Controller:创建控制器对象,控制器能够浏览器接收请求,并响应结果给浏览器,控制器也叫处理器
 */
public class QuickController {
    @RequestMapping("/exam/quick")
    public String quick(Model model) {
        model.addAttribute("title", "Web开发");
        model.addAttribute("time", LocalDateTime.now());
        return "quick";
    }
}

3.创建视图

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<div style="margin-left: 200px">
    <h3>视图技术h3>
    <div th:text="${title}">div>
    <div th:text="${time}">div>
div>
body>
html>

4.代码编写完成,启动运行类,在浏览器访问exam/quick地址

[SpringBoot3]Web服务_第3张图片

  • 编写SpringMVC的应用分成三步:
    • 编写请求页面(在浏览器直接模拟的请求)
    • 编写Controller
    • 编写视图技术

5.1.2JSON视图

  • 上面的例子以Html文件作为视图,可以编写复杂的交互的页面,CSS美化数据。除了带有页面的数据,还有一种只需要数据的视图,比如手机应用app,app的数据来自服务器应用处理结果。主流的方式是服务器返回json格式数据给手机app应用。我们可以通过原始的HttpServletResponse响应数据给请求方。借助SpringMVC能够无感知的处理json。

1.创建Controller

@Data
public class User {
    private String username;
    private Integer age;
}

@Controller
public class JSONViewController {

    //显示JSON视图,包含json数据
    @RequestMapping("/exam/json")
    public void responseJson(HttpServletResponse response) throws IOException {
        String json = "{\"name\":\"lisi\",\"age\":20}";
        //响应
        response.setContentType("application/json;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.println(json);
        out.flush();
        out.close();
    }

    //SpringMVC支持控制器方法返回对象,由框架将对象使用jackson转为json并输出
    //User--Jackson工具库的ObjectMapper对象,---user转为json格式字符串--HttpServletResponse输出

    /**
     * 接收请求的注解
     *
     * @GetMapping:接收get请求,简化的@RequestMapping(method=RequestMethod.GET)
     * @PostMapping:接收post请求
     * @PutMapping:接收put请求
     * @DeleteMapping:接收delete请求
     */

    @ResponseBody
    //@RequestMapping("/exam/json2")
    @GetMapping("/exam/json2")
    public User getUserJson() {
        User user = new User();
        user.setUsername("张三");
        user.setAge(22);
        return user;
    }
}
  • 注意:从Spring6,SpringBoot3开始javax包名称,修改为jakarta。

2.浏览器测试两个地址

[SpringBoot3]Web服务_第4张图片

  • 构建前后端分离项目经常采用这种方式。

[SpringBoot3]Web服务_第5张图片

5.1.3给项目加favicon

  • 什么是favicon.ico?
    • favicon.ico是网站的缩略标志,可先显示浏览器标签、地址栏左边和收藏夹,是展示网站个性的logo标志。

[SpringBoot3]Web服务_第6张图片

  • 我们自己的网站定制 logo。首先找一个在线工具创建 favicon.ico。比如 https://quanxin.org/favicon , 用文字、图片生成我们需要的内容。生成的 logo 文件名称是 favicon.ico。

1.将生成的favicon.ico拷贝到项目的resources/或resources/static/目录。

2.在你的视图文件,加入对favicon.ico的引用

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
    <link rel="icon" href="../favicon.ico" type="image/x-icon"/>
head>
<body>
<div style="margin-left: 200px">
    <h3>视图技术h3>
    <div th:text="${title}">div>
    <div th:text="${time}">div>
div>
body>
html>
  • 注意:如果项目有过滤器,拦截器要放行对favicon.ico的访问。

5.2SpringMVC

  • SpringMVC是非常著名的Web应用框架,现在的大多数Web项目都采用SpringMVC。它与Spring有着紧密的联系,是Spring框架中的模块,专注于Web应用,能够使用Spring提供的强大功能,IoC、Aop等等。
  • SpringMVC框架底层是基于Servlet技术,遵循Servlet规范,Web组件Servlet、Filter、Listener在SpringMVC中都能使用。同时SpringMVC也是基于MVC架构的,职责分离,每个组件只负责自己的功能,组件解耦。
  • SpringBoot的自动配置、按约定编程极大简化、提供了Web应用的开发效率,

5.2.1控制器Controller

  • 控制器用来处理请求,接收浏览器发送过来的参数,将数据和视图应答给浏览器或者客户端app等。
  • 控制器是一个普通的Bean,使用@Controller或者@RestController注解。
    • @RestController包含了@Controller的功能,同时加入了@ResponseBody的注解,表示当前控制器类中的所有方法都会默认加上@ResponseBody的功能。
    • @Controller注解有@Component的功能,控制器类对象是Spring容器管理的。
  • 如何创建控制器对象?
    • 创建普通Java类,其中定义public方法,类上注解@Controller 或者@RestController。

[SpringBoot3]Web服务_第7张图片

5.2.1.1匹配请求路径到控制器方法
  • Spring支持多种策略,匹配请求路径到控制器方法。
  • SpringBoot3推荐使用PathPatternParser策略,比之前AntPathMatcher提高6-8倍吞吐量。
  • 吞吐量:吞吐量是指单位时间内系统能够完成的工作量,它衡量的是软件系统服务器的处理能力,就是在一秒中 统计所完成的工作量。 一个系统的吞度量(承压能力)与请求对CPU的消耗、外部接口、IO等等紧密关联。

[SpringBoot3]Web服务_第8张图片

  • 通配符:
    • ?:一个字符
    • *:0或多个字符
    • **:匹配0个或多个路径

示例

@GetMapping("/file/t?st.html")
//?匹配只有一个字符
//GET http://localhost:8080/file/test.html(对)
//GET http://localhost:8080/file/teest.html(错)

@GetMapping("/file/t?st.html")
public String path1(HttpServletRequest request){
	return "path 请求="+request.getRequestURI();
}
@GetMapping ("/images/*.gif")
*:匹配一个路径段中的 0 或多个字符
() GET http://localhost:8080/images/user.gif
() GET http://localhost:8080/images/cat.gif
() GET http://localhost:8080/images/.gif
() GET http://localhost:8080/images/gif/header.gif
() GET http://localhost:8080/images/dog.jpg

@GetMapping ("/images/*.gif")
public String path2(HttpServletRequest request){
	return "* 请求="+request.getRequestURI();
}
@GetMapping ("/pic/**")
** 匹配 0 或多段路径, 匹配/pic 开始的所有请求
() GET http://localhost:8080/pic/p1.gif
() GET http://localhost:8080/pic/20222/p1.gif
() GET http://localhost:8080/pic/user
() GET http://localhost:8080/pic/

@GetMapping ("/pic/**")
public String path3(HttpServletRequest request){
	return "/pic/**请求="+request.getRequestURI();
}

RESTFul

@GetMapping("/order/{*id}")
{*id} 匹配 /order 开始的所有请求, id 表示 order 后面直到路径末尾的所有内容。
id 自定义路径变量名称。与@PathVariable 一样使用
() GET http://localhost:8080/order/1001
() GET http://localhost:8080/order/1001/2023-02-16

@GetMapping("/order/{*id}")
public String path4(@PathVariable("id") String orderId, HttpServletRequest request){
	return "/order/{*id}请求="+request.getRequestURI() + ",id="+orderId;
}
注意:@GetMapping("/order/{*id}/{*date}")无效的, {*..}后面不能在有匹配规则了
@GetMapping("/pages/{fname:\\w+}.log")
:\\w+ 正则匹配, xxx.log
() GET http://localhost:8080/pages/req.log
() GET http://localhost:8080/pages/111.log
() GET http://localhost:8080/pages/req.txt
() GET http://localhost:8080/pages/###.log
() GET http://localhost:8080/pages/.log

@GetMapping("/pages/{fname:\\w+}.log")
public String path5(@PathVariable("fname") String filename, HttpServletRequest request){
	return "/pages/{fname:\\w}.log 请求="+request.getRequestURI() + ",filename="+filename;
}
5.2.1.2@RequestMapping
  • @RequestMapping:用于将web请求映射到控制器类的方法上。此方法处理请求,可用在类上或方法上。
  • 重要的属性:
    • value:别名path表示请求的uri,在类和方法同时使用value,方法上的继承类上的value。
    • method:请求方式,支持GET、POST、HEAD、OPTIONS、PUT、PATCH、DELETE、TRACE。值为:RequestMethod[] method() , RequestMethod 是 enum 类型。
  • 快捷注解:
    • @GetMapping: 表示 get 请求方式的@RequestMapping
    • @PostMapping:表示 post 请求方式的@RequestMapping
    • @PutMapping:表示 put 请求方式的@RequestMapping
    • @DeleteMapping: 表示 delete 请求方式的@RequestMapping
5.2.1.3控制器方法参数类型与可用返回值类型
  • 参数类型

[SpringBoot3]Web服务_第9张图片

  • 返回值

[SpringBoot3]Web服务_第10张图片

5.2.1.4接收请求参数
  • 用户在浏览器中点击按钮时,会发送一个请求给服务器,其中包含让服务器程序需要做什么的参数。这些参数发送给控制器方法,控制器方法的形参列表接收请求参数。

接收参数方式

  • 请求参数与形参一一对应,适合简单类型。形参可以有合适的数据类型,比如String、Integer、int等。
@RestController
public class ParameterController {
    //一一对应,适合接收简单类型数据String、int、long、double、float,适合接收参数数量少
    //http://localhost:8080/param/p1?name=lisi&age=20&sex=m
    @GetMapping("/param/p1")
    public String p1(String name, Integer age, String sex) {
        return "接收参数:" + name + "," + age + "," + sex;
    }
}
  • 对象类型,控制器方法形参是对象,请求的多个参数名与属性名相对应。
@Data
public class Person {
    private String name;
    private Integer age;
    private String sex;
}
//使用对象接收参数,要求对象的属性名称和请求中参数名不一样,属性有set方法,类有无参数构造方法
//http://localhost:8080/param/p2?name=张三&age=22&type=asd
@GetMapping("/param/p2")
public String p2(Person person, String type) {
    return "接收参数,使用对象:" + person.toString() + ",type=" + type;
}
  • HttpServletRequest 使用request对象接收参数
//http://localhost:8080/param/p3?name=张三&age=22&sex=男
@GetMapping("/param/p3")
public String p3(HttpServletRequest request) {
    String name = request.getParameter("name");
    String age = request.getParameter("age");
    String sex = request.getParameter("sex");
    return "name=" + name + ",age=" + age + ",sex=" + sex;
}
  • @RequestParam注解,将查询参数、form表单数据解析到方法参数
//http://localhost:8080/param/p4?name=张三&age=22
@GetMapping("/param/p4")
public String p4(@RequestParam(value = "name", required = true) String name,
                 @RequestParam(value = "age", required = false, defaultValue = "26") Integer age) {
    return "p4,name=" + name + ",age=" + age;
}
  • @RequestHeader从请求header中获取某项值
//http://localhost:8080/param/p5?name=张三&age=22
//Accept: application/json
@GetMapping("/param/p5")
public String p5(@RequestParam(value = "name", required = true) String name,
                 @RequestParam(value = "age", required = false, defaultValue = "26") Integer age,
                 @RequestHeader("Accept") String accept) {
    return "p5,name=" + name + ",age=" + age + ",Accept:" + accept;
}
5.2.1.4.1接收json
  • @RequestBody接收前端传递的json格式参数
@Data
public class User {
    private String username;
    private Integer age;
}

@PostMapping("/param/json")
public String p6(@RequestBody User user) {
    return "p6,json:" + user.toString();
}

IDEA Http Client测试:

POST http://localhost:8080/param/json
Content-Type: application/json

{
  "username": "lisi",
  "age": 22
}
5.2.1.4.2Reader-InputStream
  • Reader或InputStream读取请求体的数据,适合post请求体的各种数据。具有广泛性。
@PostMapping("/param/json2")
public String p6(Reader reader) {
    StringBuffer content = new StringBuffer("");
    try (BufferedReader bin = new BufferedReader(reader)) {
        var line = "";
        while ((line = bin.readLine()) != null) {
            content.append(line);
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return "p7,reader=" + content.toString();
}
IDEA Http Client 测试:
    
POST http://localhost:8080/param/json2

hello world !!!
5.2.1.4.3数组参数接收多个值
  • 数组作为形参,接收多个参数值。
@GetMapping("/param/vals")
public String getMultiVal(Integer [] id){
	List<Integer> idList = Arrays.stream(id).toList();
	return idList.toString();
}

测试请求:
GET http://localhost:8080/param/vals?id=11&id=12&id=13
GET http://localhost:8080/param/vals?id=11,12,13,14,15
都是成功的方式
5.2.1.5验证参数
  • 服务器端程序,Controller在方法接受了参数,这些参数都是由用户提供的,使用之前必须校验参数是我们需要的吗,值是否在允许的范围内,是否符合业务的要求。比如年龄不能是负数,姓名不能是空字符串,email必须有@符号,phone国内的11位才可以。
  • 验证参数方案
    • 编写代码,手工验证,主要是if语句、switch等等。
    • Java Bean Validation:JSR-303是JAVA EE 6中的一项子规范,叫做Bean Validation,是一个运行时的数据验证规范,为JavaBean验证定义了相应的元数据模型和API。
5.2.1.5.1 Java Bean Validation
  • Spring Boot使用Java Bean Validation验证域模型属性值是否符合预期,如果验证失败,立即返回错误信息。Java Bean Validation将验证规则从controller、service集中到Bean对象,一个地方控制所有的验证。
  • Bean的属性上,加入JSR-303的注解,实现验证规则的定义。
5.2.1.5.2JSR-303注解

[SpringBoot3]Web服务_第11张图片

  • Hibernate提供的部分注解

[SpringBoot3]Web服务_第12张图片

5.2.1.5.3快速上手
  • 验证Blog中的文章信息,用户提交文章给Controller,控制器使用Java Object接收参数,给Bean添加约束注解,验证文章数据。

1.添加Bean Validator Starter

<dependency>
	<groupId>org.springframework.bootgroupId>
	<artifactId>spring-boot-starter-validationartifactId>
dependency>

2.创建文章数据类,添加约束注解

@Data
public class ArticleVo {
    private Integer id;
    @NotNull(message = "必须有作者")
    private Integer userId;

    @NotBlank(message = "文章必须有标题")
    //@Size 认为 null是有效值。
    @Size(min = 3,max = 30,message = "标题在3个字符以上")
    private String title;

    @NotBlank(message = "必须有副标题")
    @Size(min = 5,max = 60,message = "副标题在5个字以上")
    private String summary;

    @DecimalMin(value = "0",message = "阅读数量不能小于0")
    private Integer readCount;

    @Email(message = "邮箱不符合规则")
    private String email;
}

3.Controller使用Bean

@RestController
public class ArticleController {
    //发布新文章

    /**
     * @Validated:Spring中的注解,支持JSR 303规范,还能对group验证。可以在类、方法、参数上使用
     * BindingResult:包含Bean的验证结果
     */
    @PostMapping("/article/add")
    public Map<String, Object> addArticle(@Validated @RequestBody ArticleVo article, BindingResult br) {
        Map<String, Object> map = new HashMap<>();
        if (br.hasErrors()) {
            List<FieldError> fieldErrors = br.getFieldErrors();
            for (int i = 0, len = fieldErrors.size(); i < len; i++) {
                FieldError field = fieldErrors.get(i);
                map.put(i + "-" + field.getField(), field.getDefaultMessage());
            }
        }
        return map;
    }
}
5.2.1.5.4分组校验
  • 上面的ArticleVo用来新增文章,新的文章主键id是系统生成的。现在要修改文章,比如修改某个文章的title,summary, readCount,email 等。此时id必须有值,修改这个id的文章。新增和修改操作对id有不同的约束要求,通过group来区分是否验证。

1.添加group标志

@Data
public class ArticleVo {
    //组就是接口名
    public static interface AddArticleGroup {};
    public static interface EditArticleGroup {};

    @NotNull(message = "文章id必须有值", groups = {EditArticleGroup.class})
    @Min(value = 1, message = "id大于0", groups = {EditArticleGroup.class})
    private Integer id;
    @NotNull(message = "必须有作者", groups = {AddArticleGroup.class, EditArticleGroup.class})
    private Integer userId;

    @NotBlank(message = "文章必须有标题", groups = {AddArticleGroup.class, EditArticleGroup.class})
    //@Size 认为 null是有效值。
    @Size(min = 3, max = 30, message = "标题在3个字符以上", groups = {AddArticleGroup.class, EditArticleGroup.class})
    private String title;

    @NotBlank(message = "必须有副标题", groups = {AddArticleGroup.class, EditArticleGroup.class})
    @Size(min = 5, max = 60, message = "副标题在5个字以上", groups = {AddArticleGroup.class, EditArticleGroup.class})
    private String summary;

    @DecimalMin(value = "0", message = "阅读数量不能小于0", groups = {AddArticleGroup.class, EditArticleGroup.class})
    private Integer readCount;

    @Email(message = "邮箱不符合规则", groups = {AddArticleGroup.class, EditArticleGroup.class})
    private String email;
}

2.修改Controller,不同方法增加group标志

@RestController
public class ArticleController {
    @PostMapping("/article/add")
    public Map<String, Object> addArticle(@Validated(ArticleVo.AddArticleGroup.class) @RequestBody ArticleVo article, BindingResult br) {
        Map<String, Object> map = new HashMap<>();
        if (br.hasErrors()) {
            List<FieldError> fieldErrors = br.getFieldErrors();
            for (int i = 0, len = fieldErrors.size(); i < len; i++) {
                FieldError field = fieldErrors.get(i);
                map.put(i + "-" + field.getField(), field.getDefaultMessage());
            }
        }
        return map;
    }
    @PostMapping("/article/edit")
    public Map<String, Object> editArticle(@Validated(ArticleVo.EditArticleGroup.class) @RequestBody ArticleVo article, BindingResult br) {
        Map<String, Object> map = new HashMap<>();
        if (br.hasErrors()) {
            List<FieldError> fieldErrors = br.getFieldErrors();
            for (int i = 0, len = fieldErrors.size(); i < len; i++) {
                FieldError field = fieldErrors.get(i);
                map.put(i + "-" + field.getField(), field.getDefaultMessage());
            }
        }
        return map;
    }
}

3.测试代码

POST http://localhost:8080/article/edit
Content-Type: application/json

{
  "id": 10,
  "userId": 10,
  "title": "云原生",
  "summary": "云原生SpringClod,Linux",
  "readCount": 10,
  "email": "[email protected]"
}

5.2.2模型Model

  • 在许多实际项目需求中,后台要从控制器直接返回前端所需的数据,这时Model大家族就派上用场了。
  • Model指的是Spring MVC中的”M“,用来传输数据。从控制器直接返回数据给前端,配置jsp,模板技术都能够展示M中存储的数据。
  • Model简单理解就是给前端浏览器的数据,放在Model中,ModelAndView里的任意值,还有json格式的字符串都是Model。
@RequestMapping("/exam/quick")
public String quick(Model model) {
    model.addAttribute("title", "Web开发");
    model.addAttribute("time", LocalDateTime.now());
    return "quick";
}

5.2.3视图View

  • SpringMVC中的View(视图)用来展示数据的。无论使用thymleaf、jsp还是其他技术,classpath有jar就能使用视图了。程序员主要就是配置更改,Spring Boot3不推荐FreeMarker、jsp这些了。页面的视图技术Thymeleaf、Groovy Templates。
  • org.springframework.web.servlet.View 视图的接口,实现此接口的都是视图类,视图类作为Bean被Spring管理。
5.2.3.1页面视图
  • Thymeleaf作为代替jsp的视图技术,可以编写页面,排列数据。

1.创建Controller,控制器方法返回ModelAndView

@GetMapping("/hello")
public ModelAndView hello() {
    //ModelAndView表示数据和视图
    ModelAndView mv = new ModelAndView();
    mv.addObject("name", "李四");
    mv.addObject("age", 20);
    mv.setViewName("hello");
    return mv;
}

2.创建视图:在resources/templates创建hello.html

DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Titletitle>
head>
<body>
  <div th:text="${name}">div> <br/>
  <div th:text="${age}">div> <br/>
body>
html>
  • application.properties默认thymeleaf的设置
#前缀 视图文件存放位置
spring.thymeleaf.prefix=classpath:/templates/
#后缀 视图文件扩展名
spring.thymeleaf.suffix=.html

3.测试,浏览器访问

[SpringBoot3]Web服务_第13张图片

5.2.3.2JSON视图
  • 在一个类中定义其他多个引用类型或集合类型,构成复杂json

1.编写实体类

@Data
public class User {
    private String username;
    private Integer age;
    private RoleVO roleVO;
}

@Data
public class RoleVO {
  private Integer id;
  private String roleName;
  private String memo;
}

2.增加控制器方法

@GetMapping("/json")
@ResponseBody
public User returnJson() {
    User user = new User();
    user.setUsername("张三");
    user.setAge(20);

    RoleVO roleVO = new RoleVO();
    roleVO.setRoleName("管理员");
    roleVO.setMemo("具有较高的权限");
    roleVO.setId(10);
    user.setRoleVO(roleVO);
    return user;
}

3.浏览器访问

5.2.3.3ResponseEntity
  • ResponseEntity包含HttpStatus Code和应答数据的结合体。因为有Http Code能表达标准的语义,200成功,404没有发现等。

1.ResponseEntity做控制器方法返回值

@GetMapping("/json3")
@ResponseBody
public ResponseEntity<User> returnEntity() {
    User user = new User();
    user.setUsername("张三");
    user.setAge(20);

    RoleVO roleVO = new RoleVO();
    roleVO.setRoleName("管理员");
    roleVO.setMemo("具有较高的权限");
    roleVO.setId(10);
    user.setRoleVO(roleVO);

    ResponseEntity<User> response = new ResponseEntity<>(user, HttpStatus.OK);
    return response;
}

2.测试

[SpringBoot3]Web服务_第14张图片

5.2.3.4Map作为返回值
  • Map作为返回值是数据,能够自动转为json

1.创建Map返回值的方法

@GetMapping("/map")
@ResponseBody
public Map<String, Object> returnMap() {
    Map<String, Object> map = new HashMap<>();
    map.put("name", "lisi");
    map.put("age", 20);
    return map;
}

2.测试

[SpringBoot3]Web服务_第15张图片

5.3SpringMVC请求流程

  • SpringMVC框架是基于Servlet技术的。以请求为驱动,围绕Servlet设计的。SpringMVC处理用户请求与访问一个Servlet是类似的,请求发送给Servlet,执行doService方法,最后响应结果给浏览器完成一次请求处理。

  • DispatcherServlet是核心对象,称为中央调度器。负责接收所有对Controller的请求,调用开发者的Controller处理业务逻辑,将Controller方法的返回值经过视图处理响应给浏览器。

[SpringBoot3]Web服务_第16张图片

  • 红色的DispatcherServlet是框架创建的核心对象。
  • 蓝色的部分框架已经提供多个对象,开发任意可自定义,替换默认的对象。
  • 绿色的部分是开发人员自己创建的对象,控制器Conroller和视图对象。

5.4SpringMVC自动配置

  • SpringBoot检测classpath上存在的类,从而判断当前应用使用的是哪个Servlet Web服务器,从而决定定义相应的工厂组件,也就是Web服务器。
  • 配置类:ServerProperties.class,配置web server服务器
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
}
  • application文件配置服务器,现在使用tomcat服务器
#配置服务器
#服务器端口号
server.port=8081
#上下文访问路径
server.servlet.context-path=/api
#request、response字符编码
server.servlet.encoding.charset=UTF-8
#强制request、response设置charset字符编码
server.servlet.encoding.force=true

#配置tomcat服务器的日志
#日志路径
server.tomcat.accesslog.directory=D:/log
#启用访问日志
server.tomcat.accesslog.enabled=true
#日志文件名前缀
server.tomcat.accesslog.prefix=access_log
#日志文件日期时间
server.tomcat.accesslog.file-date-format=.yyyy-MM-dd
#日志文件名称后缀
server.tomcat.accesslog.suffix=.log
#post 请求内容最大值,默认2M
server.tomcat.max-http-form-post-size=2000000
#服务器最大连接数
server.tomcat.max-connections=8192
  • SpringMVC配置
#配置DispatcherServlet
spring.mvc.servlet.path=/course
#Servlet的加载顺序,越小越先加载
spring.mvc.servlet.load-on-startup=0
#时间格式,可以接受请求参数使用
spring.mvc.format.date-time=yyyy-MM-dd HH:mm:ss

 	//测试日期参数
    @GetMapping("/param/date")
    @ResponseBody
    public String paramDate(LocalDateTime date) {
        return "日期:" + date;
    }
http://localhost:8081/api/course/param/date?date=2203-02-02 12:10:10

5.5Servlets、Filters、Listeners

  • web应用还会用到Servlet、Filter或Listener。这些对象能够作为Spring Bean注册到嵌入式的Tomcat中。ServletRegistrationBean、FilterRegistrationBean 和ServletListenerRegistrationBean 控制 Servlet,Filter,Listener。@Order或Ordered接口控制对象的先后顺序。
  • Servlet现在完全支持注解的使用方式,@WebServlet。

5.5.1Servlets

5.5.1.1@WebServlet使用Servlet

1.创建Servlet

@WebServlet(urlPatterns = "/helloServlet",name = "HelloServlet")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.println("这是一个SpringBoot中的Servlet");
        out.flush();
        out.close();
    }
}

2.扫描Servlet注解

//扫描@WebServlet注解
@ServletComponentScan(basePackages = "com.hhb.web")
@SpringBootApplication
public class Springboot13ServletFilterApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot13ServletFilterApplication.class, args);
    }

}

3.测试

5.5.1.2ServletRegistrationBean

1.创建Servlet,不需要注解

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=utf-8");
        PrintWriter out = response.getWriter();
        out.println("这是一个登录的Servlet");
        out.flush();
        out.close();
    }
}

2.配置Servlet

@Configuration
public class WebAppConfig {
    @Bean
    public ServletRegistrationBean servletRegistrationBean() {
        //创建ServletRegistrationBean登录一个或多个Servlet
        ServletRegistrationBean bean = new ServletRegistrationBean();
        bean.setServlet(new LoginServlet());
        bean.addUrlMappings("/user/login");
        bean.setLoadOnStartup(1);
        return bean;
    }
}

3.测试

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tMowdVMT-1692712231668)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230819101553421.png)]

5.5.2创建Filter

  • Filter对象使用频率比较高,比如记录日志、权限验证、敏感字符过滤等等。Web框架中包含内置的Filter,SpringMVC中也包含较多的内置Filter。
5.5.2.1@WebFilter注解
  • @WebFilter创建Filter对象,使用方式同@WebServlet

1.创建过滤器

@WebFilter(urlPatterns = "/*")
public class LogFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String uri = ((HttpServletRequest) request).getRequestURI().toString();
        System.out.println("***LogFilter过滤器执行了,uri:" + uri);
        chain.doFilter(request, response);
    }
}

2.扫描包

@ServletComponentScan(basePackages = "com.hhb.web")
@SpringBootApplication
public class Springboot13ServletFilterApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot13ServletFilterApplication.class, args);
    }
}

3.浏览器访问测试

[SpringBoot3]Web服务_第17张图片

5.5.2.2FilterRegistrationBean
  • FilterRegistrationBean 与 ServletRegistrationBean 使用方式类似,无需注解。

注册Filter

@Bean
public FilterRegistrationBean filterRegistrationBean() {
    FilterRegistrationBean bean = new FilterRegistrationBean();
    bean.setFilter(new LogFilter());
    bean.addUrlPatterns("/*");
    return bean;
}
5.5.2.3Filter排序
  • 多个Filter对象如果要排序,有两种途径:
    • 过滤器类名称,按字典顺序排列,AuthFilter->LogFilter
    • FilterRegistrationBean登记Filter,设置order顺序,数值越小越先执行。

1.创建两个Filter,使用之前的AuthFilter、LogFilter

public class LogFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        String uri = ((HttpServletRequest) request).getRequestURI().toString();
        System.out.println("LogFilter过滤器执行了,uri:" + uri);
        chain.doFilter(request, response);
    }
}

public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        String uri = ((HttpServletRequest) request).getRequestURI().toString();
        System.out.println("AuthFilter过滤器执行了,uri:" + uri);
        chain.doFilter(request, response);
    }
}

2.创建配置类,登记Filter

@Bean
public FilterRegistrationBean logFilter() {
    FilterRegistrationBean log = new FilterRegistrationBean();
    log.setFilter(new LogFilter());
    log.setOrder(1);
    log.addUrlPatterns("/*");
    return log;
}

@Bean
public FilterRegistrationBean authFilter() {
    FilterRegistrationBean auth = new FilterRegistrationBean();
    auth.setFilter(new AuthFilter());
    auth.setOrder(2);
    auth.addUrlPatterns("/*");
    return auth;
}

3.测试Filter

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ebZErCeB-1692712231668)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230819110825309.png)]

5.5.2.4使用框架中的Filter
  • SpringBoot中有许多已经定义好的Filter,这些Filter实现类一些功能,如果我们需要使用他们,可以像自己的Filter一样,通过FilterRegistrationBean注册Filter对象。
  • 现在我们想记录每个请求的日志。CommonsRequestLoggingFilter 就能完成简单的请求记录。

1.登记CommonsRequestLoggingFilter

@Bean
public FilterRegistrationBean addOtherFilter() {
    FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
    //创建Filter对象
    CommonsRequestLoggingFilter commonLog = new CommonsRequestLoggingFilter();
    //包含请求uri
    commonLog.setIncludeQueryString(true);
    //登记Filter
    filterRegistrationBean.setFilter(commonLog);
    //拦截所有地址
    filterRegistrationBean.addUrlPatterns("/*");
    return filterRegistrationBean;
}

2.设置日志级别为debug,修改application.properties

logging.level.web=debug

3.测试访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8kgFe1l4-1692712231669)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230819112417433.png)]

5.5.3Listener

创建监听器

@WebListener("Listener 的描述说明")
public class MySessionListener implements HttpSessionListener {
	@Override
	public void sessionCreated(HttpSessionEvent se) {
	HttpSessionListener.super.sessionCreated(se);
	}
}

5.6WebMvcConfigurer

  • WebMvcConfigurer作为配置类是采用JavaBean的形式来代替传统的xml配置文件形式进行针对框架个性化定制,就是SpringMVC XML配置文件的JavaConfig(编码)实现方式。
  • WebMvcConfigurer是一个接口,需要自定义某个对象,实现接口并覆盖某个方法。主要方法功能介绍一下:
public interface WebMvcConfigurer {
	//帮助配置 HandlerMapping
	default void configurePathMatch(PathMatchConfigurer configurer) {}
	//处理内容协商
	default void configureContentNegotiation(ContentNegotiationConfigurer configurer) {}
	//异步请求
	default void configureAsyncSupport(AsyncSupportConfigurer configurer) {}
	//配置默认 servlet
	default void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {}
	//配置内容转换器
	default void addFormatters(FormatterRegistry registry) {}
	//配置拦截器
	default void addInterceptors(InterceptorRegistry registry) {}
	//处理静态资源
	default void addResourceHandlers(ResourceHandlerRegistry registry) {}
	//配置全局跨域
	default void addCorsMappings(CorsRegistry registry) {}
	//配置视图页面跳转
	default void addViewControllers(ViewControllerRegistry registry) {}
	//配置视图解析器
	default void configureViewResolvers(ViewResolverRegistry registry) {}
	//自定义参数解析器,处理请求参数
	default void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {}
	//自定义控制器方法返回值处理器
	default void addReturnValueHandlers(List<HandlerMethodReturnValueHandler> handlers) {}
	//配置 HttpMessageConverters
	default void configureMessageConverters(List<HttpMessageConverter<?>> converters) {}
	//配置 HttpMessageConverters
	default void extendMessageConverters(List<HttpMessageConverter<?>> converters) {}
	//配置异常处理器
	default void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {}
	//扩展异常处理器
	default void extendHandlerExceptionResolvers(List<HandlerExceptionResolver> resolvers) {}
	//JSR303 的自定义验证器
	default Validator getValidator() {
	return null;
	}
	//消息处理对象
	default MessageCodesResolver getMessageCodesResolver() {
	return null;
	}
}

5.6.1页面跳转控制器

  • SpringBoot中使用页面视图,比如Thymeleaf。要跳转显示某个页面,必须通过Controller对象。也就是我们需要创建一个Controller,转发到一个视图才行。如果我们现在需要显示页面,可以无需这个Controller。addViewControllers()完成从请求到视图跳转。

  • 项目代码结构:

[SpringBoot3]Web服务_第18张图片

1.创建视图

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h3>欢迎!!!h3>
body>
html>

2.创建SpringMVC配置类

//SpringMVC配置:使用JavaConfig的方式配置SpringMVC,代替原来的xml配置文件
@Configuration
public class MvcSettings implements WebMvcConfigurer {
    //页面跳转控制器,从请求直达视图页面(无需controller)
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        //配置页面的控制:addViewController("请求uri").setViewName("目标视图")
        registry.addViewController("/welcome").setViewName("index");
    }
}

3.测试功能

[SpringBoot3]Web服务_第19张图片

5.6.2数据格式化

  • Formatter是数据转换接口,将一种数据类型转换为另一种数据类型。与Formatter功能类似的还有Converter。本章研究Formatter接口。

  • Formatter只能将String类型转换为其他数据类型,这点在Web应用适用更广,因为Web请求的所有参数都是String,我们需要把String转为Integer、Long、Date等等。

  • Spring中内置了一些Formatter:

    • DateFormatter:String和Date之间的解析与格式化
    • InetAddressFormatter:String和InetAddress之间的解析与格式化
    • PercentStyleFormatter:String与Number之间的解析与格式化,带货币符号
    • NumberFormat:String和Number之间的解析与格式化
  • 接口原型:

    public interface Formatter<T> extends Printer<T>, Parser<T> {}
    
    • Formatter是一个组合接口,没有自己的方法。内容来自Printer和 Parser
    • Printer:将T类型转换为String,格式化输出
    • Parser:将String类型转为期望的T对象
  • 需求:将“1111;2222;333,NF;4;561”接收,代码中用DeviceInfo存储参数值

1.创建DeviceInfo数据类

@Data
public class DeviceInfo {
    private String item1;
    private String item2;
    private String item3;
    private String item4;
    private String item5;
}

2.自定义Formatter

//将请求参数String转为DeviceInfo
public class DeviceFormatter implements Formatter<DeviceInfo> {
    //text表示请求参数的值
    @Override
    public DeviceInfo parse(String text, Locale locale) throws ParseException {
        DeviceInfo info = null;
        if (StringUtils.hasLength(text)) {
            String[] items = text.split(";");
            info  = new DeviceInfo();
            info.setItem1(items[0]);
            info.setItem2(items[1]);
            info.setItem3(items[2]);
            info.setItem4(items[3]);
            info.setItem5(items[4]);
        }
        return info;
    }

    @Override
    public String print(DeviceInfo object, Locale locale) {
        StringJoiner joiner = new StringJoiner("#");
        joiner.add(object.getItem1()).add(object.getItem2())
                .add(object.getItem3()).add(object.getItem4())
                .add(object.getItem5());
        return joiner.toString();
    }
}

3.登记自定义的DeviceFormatter

//转换器
@Override
public void addFormatters(FormatterRegistry registry) {
    registry.addFormatter(new DeviceFormatter());
}

4.新建Controller接收请求设备数据

@RestController
public class DeviceController {

    @PostMapping("/device/add")
    public String addDeviceInfo(@RequestParam("device") DeviceInfo info){
        return "接收的设备信息:"+info.toString();
    }
}

5.单元测试

POST http://localhost:8080/device/add
Content-Type: application/x-www-form-urlencoded

device=1111;2222;333,NF;4;561

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tVwVXCTR-1692712231669)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230819145817001.png)]

5.6.3拦截器

  • HandlerInterceptor接口和它的实现类称为拦截器,是SpringMVC的一种对象。拦截器是SpringMVC框架的对象,与Servlet无关。拦截器能够预先处理发给Controller的请求,可以决定请求是否被Controller处理。用户请求是先由DispatcherServlet接收后,在Controller之前执行的拦截器对象。
  • 一个项目中有众多的拦截器:框架中预定义的拦截器,自定义拦截器。下面我们说说自定义拦截器的应用。
  • 拦截器定义步骤:
    • 声明类实现HandlerInterceptor接口,重写三个方法(需要哪个重写哪个)
    • 登记拦截器
5.6.3.1一个拦截器
  • 需求:zhangsan操作员用户,只能查看文章,不能修改删除。

1.创建文章的Controller

@RestController
public class ArticleController {
    @PostMapping("/article/add")
    public String addArticle() {
        return "发布新的文章";
    }

    @PostMapping("/article/edit")
    public String editArticle() {
        return "修改文章";
    }

    @DeleteMapping("/article/remove")
    public String removeArticle() {
        return "删除文章";
    }

    @GetMapping("/article/query")
    public String queryArticle() {
        return "查询文章";
    }
}

2.创建有关的权限拦截器

public class AuthInterceptor implements HandlerInterceptor {
    public static final String COMMON_USER = "zhangsan";

    //判断登录的用户,能否执行相应的动作
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("AuthInterceptor权限拦截器");
        //登录的用户
        String loginUser = request.getParameter("loginUser");
        //获取请求的uri地址
        String requestURI = request.getRequestURI();

        //判断用户和操作
        if (COMMON_USER.equals(loginUser) && (
                requestURI.startsWith("/article/add") ||
                requestURI.startsWith("/article/edit") ||
                requestURI.startsWith("/article/remove")
        )) {
            return false;
        }
        return true;
    }
}

3.登记拦截器

//拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
    //权限拦截器
    AuthInterceptor authInterceptor = new AuthInterceptor();
    registry.addInterceptor(authInterceptor)
            .addPathPatterns("/article/**")//拦截以article开头的所有请求
            .excludePathPatterns("/article/query");//不拦截的地址
}

4.测试拦截器

###
POST http://localhost:8080/article/add
Content-Type: application/x-www-form-urlencoded

loginUser=zhangsan&title=Vue


###
GET http://localhost:8080/article/query
Content-Type: application/x-www-form-urlencoded

loginUser=zhangsan&title=Vue
5.6.3.2多个拦截器
  • 增加一个验证登录用户的拦截器,只有zhangsan,lisi,admin能够登录系统。其他用户不可以。两个拦截器登录的拦截器先执行,权限拦截器后执行,order()方法设置顺序,整数值越小,先执行。

1.创建登录拦截器

public class LoginInterceptor implements HandlerInterceptor {

    private List<String> permitUser = new ArrayList<>();

    public LoginInterceptor() {
        this.permitUser = Arrays.asList("zhangsan", "lisi", "admin");
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        System.out.println("==========LoginInterceptor执行了==========");
        //获取登录的用户名称
        String loginUser = request.getParameter("loginUser");

        //只有三个用户能够访问系统
        if (StringUtils.hasText(loginUser) && permitUser.contains(loginUser)) {
            return true;
        }
        return false;
    }
}

2.登记拦截器,设置顺序order

//拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
    //权限拦截器
    AuthInterceptor authInterceptor = new AuthInterceptor();
    registry.addInterceptor(authInterceptor)
            .order(2)
            .addPathPatterns("/article/**")//拦截以article开头的所有请求
            .excludePathPatterns("/article/query");//不拦截的地址

    //登录拦截器
    LoginInterceptor loginInterceptor = new LoginInterceptor();
    registry.addInterceptor(loginInterceptor)
            .order(1)//顺序,整数值,越小越先执行
            .addPathPatterns("/**")//拦截所有对controller的请求
            .excludePathPatterns("/article/query");//排除
}

5.7文件上传

  • SpringBoot上传文件现在变得非常简单,提供了封装好的处理上传文件的接口MultipartResolver,用于解析上传文件的请求。
  • MultipartFile表示上传的文件,提供了方便的方法保存文件到磁盘。

MultipartFile API

方法 作用
getName() 参数名称
getOriginalFilename() 上传文件原始名称
isEmpty() 上传文件是否为空
getSize() 上传的文件字节大小
getInputStream() 文件的InputStream,可用于读取部件的内容
transferTo(File dest) 保存上传文件到目标dest

5.7.1MultipartResolver

1.服务器创建目录存放上传后的文件

  • 例如在 D:/upload

2.创建index.html作为上传后的显示页面

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h3>文件上传成功!!!h3>
body>
html>

3.创建上传文件页面

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<div style="margin-left: 200px">
    <h3>文件上传h3>
    <form action="uploadFile" enctype="multipart/form-data" method="post">
        选择文件:<input type="file" name="upfile"><br>
        <input type="submit" value="上传">
    form>
div>
body>
html>
  • 要求:
    • enctype=“multipart/form-data”
    • method=“post”
    • 表示一个上传文件,upfile自定义上传文件参数名称

4.创建Controller

package com.hhb.upload.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Controller
public class UploadFileController {
    //上传文件
    @PostMapping("/uploadFile")
    public String uploadFile(@RequestParam("upfile") MultipartFile multipartFile) throws IOException {
        System.out.println("开始处理上传文件");
        Map<String, Object> info = new HashMap<>();
        if (!multipartFile.isEmpty()) {
            info.put("上传文件的参数名称", multipartFile.getName());
            info.put("内容类型", multipartFile.getContentType());
            var ext = "unknown";
            //原始文件名称,例如a.gif
            var filename = multipartFile.getOriginalFilename();
            //indexOf(".") 判断"."第一次出现的位置
            if (filename.indexOf(".") > 0) {
                //截取"."之后的字符
                ext = filename.substring(filename.indexOf(".") + 1);
            }
            //生成服务器使用的文件名称
            var newFileName = UUID.randomUUID().toString() + "." + ext;
            //存储服务器的文件
            var path = "D://upload//" + newFileName;
            //把文件保存到path目录
            multipartFile.transferTo(new File(path));
            info.put("文件名称", newFileName);
        }
        System.out.println("info = " + info);
        //重定向到index页面,防止刷新,避免重复上传
        return "redirect:/index.html";
    }
}

5.测试

  • 浏览器访问 http://localhost:8080/upload.html

  • 文件上传,查看 D:/upload 目录上传的文件

  • SpringBoot默认单个文件最大支持1MB,一次请求最大10MB,改变默认值,需要application修改配置项。

#一次请求最大支持5MB
spring.servlet.multipart.max-request-size=5MB
#单个文件最大支持100KB
spring.servlet.multipart.max-file-size=100KB
#超过指定大小,直接写文件到磁盘,不再内存处理
spring.servlet.multipart.file-size-threshold=0KB
  • 配置错误页面**(规定格式)**

  • resources/static/error/5xx.html

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h3>文件上传错误h3>
body>
html>

5.7.2Servlet规范

  • Servlet3.0规范中,定义了jakarta.servlet.http.Part接口处理multipart/form-data POST请求中接收到表单数据。
  • 有了Part对象,其write()方法将上传文件保存到服务器本地磁盘目录。
  • 在HttpServletRequest接口中引入的新方法:
    • getParts():返回Part对象的集合。
    • getPart(字符串名称):检索具有给定名称的单个Part对象。

原生的Servlet规范的文件上传

@Controller
public class UploadAction {
    @PostMapping("/files")
    public String upload(HttpServletRequest request) throws ServletException, IOException {
        for (Part part : request.getParts()) {
            String filename = extractFileName(part);
            //将文件写入服务器的目录
            part.write(filename);
        }
        return "redirect:/index.html";
    }

    private String extractFileName(Part part) {
        String contentDisp = part.getHeader("content-disposition");
        System.out.println("contentDisp=" + contentDisp);
        String[] items = contentDisp.split(";");
        for (String s : items) {
            if (s.trim().startsWith("filename")) {
                return s.substring(s.indexOf("=") + 2, s.length() - 1);
            }
        }
        return "";
    }
}

application文件,配置服务器存储文件位置

spring.servlet.multipart.location=D://upload

5.7.3多文件上传

  • 多文件上传,在接收文件参数部分有所改变MultiPartFile [] files。循环遍历数组解析每个上传的文件。

前端请求页面

DOCTYPE html>
<html lang="en">
<body>
<div style="margin-left: 200px">
    <h3>文件上传h3>
    <form action="file" enctype="multipart/form-data" method="post">
        选择文件-1:<input type="file" name="upfile"> <br/> <br/>
        选择文件-2:<input type="file" name="upfile"> <br/> <br/>
        选择文件-3:<input type="file" name="upfile"> <br/> <br/>
        <input type="submit" value="上传">
    form>
div>
body>
html>

5.8全局异常处理

  • 在Controller处理请求过程中发生了异常,DispatcherServlet将异常处理委托给异常处理器(处理异常的类),实现HandlerExceptionResolver接口的都是异常处理类。
  • 项目中的异常一般都是集中处理,定义全局异常处理器。再结合框架提供的注解,例如:@ExceptionHandler、@ControllerAdvice、@RestControllerAdvice一起完成异常的处理。
  • @ControllerAdvice与@RestControllerAdvice区别在于:@RestControllerAdvice加入了@ResponseBody。

5.8.1全局异常处理器

1.创建输入数字的页面

  • 在static目录下创建input.html,static目录下的资源浏览器可以直接访问。
DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<form action="divide" method="post">  数:<input type="text" name="n1"><br>
    被除数:<input type="text" name="n2"><br>
    <input type="submit" value="计算">
form>
body>
html>

2.创建控制器,计算两个整数相除

@RestController
public class NumberController {
    @PostMapping("/divide")
    public String some(Integer n1, Integer n2) {
        int res = n1 / n2;
        return "n1/n2=" + res;
    }
}

3.浏览器访问input.html,计算两个数字相除

  • 显示默认错误页面

[SpringBoot3]Web服务_第20张图片

4.创建自定义异常处理器

/**
 * 1.在类的上面加@ControllerAdvice、@RestControllerAdvice,灵活组合
 * 2.在类中自定义方法,处理各种异常。方法定义同Controller类中的方法的定义
 */
//控制器增强,给Controller增加异常处理功能,类似AOP的思想
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法处理数学异常

    /**
     * @ExceptionHandler:指定处理异常的方法 位置:在方法的上面
     * 属性:是异常类的class数组,如果你的系统抛出的异常类型与@ExceptionHandler声明的相同,由当前方法处理异常
     */
    /*@ExceptionHandler({ArithmeticException.class})
    public String handlerArithmeticException(ArithmeticException e, Model model) {
        String error = e.getMessage();
        model.addAttribute("error", error);
        return "exp";//视图
    }*/
    //不带视图,直接返回数据
    @ExceptionHandler({ArithmeticException.class})
    @ResponseBody
    public Map<String, String> handlerReturnDataException(ArithmeticException e) {
        Map<String, String> error = new HashMap<>();
        error.put("msg", e.getMessage());
        error.put("tips", "被除数不能为0");
        return error;
    }
}

5.创建错误提示页面

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h3>显示异常的信息:
    <div th:text="${error}">div>
h3>
body>
html>
  • 再测试显示,提示页面

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LhmSxwbg-1692712231670)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230821142843877.png)]

5.8.2BeanValidator异常处理

  • 使用JSR-303验证参数时,我们是在Controller方法声明BindingResult对象获取校验结果。Controller的方法很多,每个方法都加入BindingResult处理检验参数比较繁琐。校验参数失败抛出异常给框架,异常处理器能够捕获到MethodArgumentNotValidException,它是BindException的子类。
  • BindException异常实现了BindingResult接口,异常类能够得到BindingResult对象,进一步获取JSR303校验的异常信息。

1.添加JSR-303依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

2.创建Bean对象,属性加入JSR-303注解

@Data
public class OrderVO {
    @NotBlank(message = "订单名称不能为空")
    private String name;

    @NotNull(message = "商品必须有数量")
    @Range(min = 1, max = 99, message = "一个订单的商品数量在{min}--{max}")
    private Integer amount;

    @NotNull(message = "用户不能为空")
    @Min(value = 1, message = "从1开始")
    private Integer userId;
}

3.Controller接收请求

@RestController
public class OrderController {
    @PostMapping("/order/new")
    public String createOrder(@Validated @RequestBody OrderVO orderVO) {
        return "订单信息:" + orderVO.toString();
    }
}

4.创建异常处理器

@ControllerAdvice
public class GlobalExceptionHandler {
    //处理JSR303 验证参数的异常
    //@ExceptionHandler({BindException.class})
    @ExceptionHandler({MethodArgumentNotValidException.class})
    @ResponseBody
    public Map<String, Object> handlerJSR303Exception(MethodArgumentNotValidException e) {
        System.out.println("**********JSR303**********");
        Map<String, Object> map = new HashMap<>();
        BindingResult result = e.getBindingResult();
        if (result.hasErrors()) {
            List<FieldError> errors = result.getFieldErrors();
            for (int i = 0, len = errors.size(); i < len; i++) {
                FieldError field = errors.get(i);
                map.put(field.getField(), field.getDefaultMessage());
            }
        }
        return map;
    }
}

5.测试

POST http://localhost:8080/order/new
Content-Type: application/json

{
  "name": "",
  "amount": 0,
  "userId": 10
}

[SpringBoot3]Web服务_第21张图片

5.8.3ProblemDetail[SpringBoot3]

  • 一直以来SpringBoot默认的异常反馈内容比较单一,包含Http Status Code、时间、异常信息。但具体异常原因没有体现,这次SpringBoot3对错误信息增强了。
5.8.3.1 RFC 7807

”Problem Details“ 的 JSON 应答格式

{
"type": "https://example.com/probs/out-of-credit",
"title": "You do not have enough credit.",
"detail": "Your current balance is 30, but that costs 50.",
"instance": "/account/12345/transactions/abc"
}
  • ”Problem Details“ 包含内容:

[SpringBoot3]Web服务_第22张图片

标准字段 描述 是否必须
type 标识错误类型的URI。在浏览器中加载这个URI应该转向这个错误的文档。默认为 about:blank 可认为是
title 问题类型的简单描述
datail 错误信息详细描述
instance 标识该特定故障实例的URI,它可以作为发生的这个错误的ID
status 错误使用的HTTP状态代码,它必须与实际状态匹配

5.8.3.2MediaType
  • RFC 7807增加了两种媒体类型:application/problem+jsonapplication/problem+xml。返回错误的HTTP响应应在其Content-Type响应标头中包含适当的内容类型,并且客户端可以检查该标头以确认格式。
5.8.3.3Spring支持Problem Detail

[SpringBoot3]Web服务_第23张图片

5.8.3.4自定义异常处理器ProblemDetail
  • 需求:我们示例查询某个isbn的图书。在application.yml中配置图书的初始数据,用户访问一个api地址,查询某个isbn的图书,查询不到抛出自定义异常BootNotFoundException,自定义异常处理器捕获异常。ProblemDeatil作为应答结果,支持RFC 7807。

1.新建图书的Record(普通的POJO类都是可以的)

public record BookRecord(String isbn,String name,String author) {
}

2.创建存储多本图书的容器类

@Setter
@Getter
@ConfigurationProperties(prefix = "product")
//将数据存入到BookContainer
public class BookContainer {
    private List<BookRecord> books;
}

3.application.yml配置图书基础数据

#指定初始的book数据,代替数据库
product:
  books:
    - isbn: B001
      name: java
      author: lisi
    - isbn: B002
      name: tomcat
      author: zhangsan
    - isbn: B003
      name: jvm
      author: wangwu

#访问路径
server:
  servlet:
    context-path: /api

4.新建自定义异常类

public class BookNotFoundException extends RuntimeException {
    public BookNotFoundException() {
        super();
    }

    public BookNotFoundException(String message) {
        super(message);
    }
}

5.新建控制器类

@RestController
public class BookController {
    //注入BookContainer
    @Autowired
    private BookContainer bookContainer;

    //根据isbn查询图书,如果没有查到,抛出异常
    @GetMapping("/book")
    public BookRecord getBook(String isbn) {
        Optional<BookRecord> bookRecord = bookContainer.getBooks().stream().filter(el ->
                el.isbn().equals(isbn)
        ).findFirst();
        if (bookRecord.isEmpty()) {
            throw new BookNotFoundException(" isbn :" + isbn + "->没有此图书");
        }
        return bookRecord.get();
    }
}

6.新建异常处理器

@RestControllerAdvice
public class GlobalExceptionHandler {

    //定义的ProblemDetail
    @ExceptionHandler({BookNotFoundException.class})
    public ProblemDetail handlerBookNotFoundException(BookNotFoundException e) {
        //ProblemDetail
        ProblemDetail problemDetail = ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, e.getMessage());
        //type:异常类型,是一个uri,uri找到解决问题的途径
        problemDetail.setType(URI.create("/api/probs/not-found"));
        problemDetail.setTitle("图书异常");

        //增加自定义的字段
        problemDetail.setProperty("时间", Instant.now());
        problemDetail.setProperty("客服", "[email protected]");
        return problemDetail;
    }
}

7.测试接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hNtkaSWh-1692712231670)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230822202408704.png)]

[SpringBoot3]Web服务_第24张图片

5.8.3.5ErrorResponse
  • SpringBoot识别ErrorResponse类型作为异常的应答结果。可以直接使用ErrorResponse作为异常处理方法的返回值。

修改异常处理器GlobalExceptionHandler

@RestControllerAdvice
public class GlobalExceptionHandler {
	//返回ErrorResponse
    @ExceptionHandler({BookNotFoundException.class})
    public ErrorResponse handlerException(BookNotFoundException e) {
        ErrorResponseException error = new ErrorResponseException(HttpStatus.NOT_FOUND, e);
        return error;
    }
}

测试接口

[SpringBoot3]Web服务_第25张图片

5.8.3.6扩展ErrorResponseException
  • 自定义异常可以扩展ErrorResponseException,SpringMVC将处理异常以符合RFC7807的格式返回错误响应。

1.创建新的异常类继承ErrorResponseException

//自定义异常类,让SpringMVC的异常处理器使用
public class IsbnNotFoundException extends ErrorResponseException {
    public IsbnNotFoundException(HttpStatus httpStatus, String detail) {
        super(httpStatus, createProblemDetail(httpStatus, detail), null);
    }

    private static ProblemDetail createProblemDetail(HttpStatus status, String detail) {
        //封装RFC7807字段
        ProblemDetail problemDetail = ProblemDetail.forStatus(status);
        problemDetail.setType(URI.create("/api/probs/not-found"));
        problemDetail.setTitle("图书异常");
        problemDetail.setDetail(detail);
        //自定义字段
        problemDetail.setProperty("严重程度", "低");
        problemDetail.setProperty("客服邮箱", "[email protected]");
        return problemDetail;
    }
}

2.抛出IsbnNotFoundException

@RestController
public class BookController {
    //注入BookContainer
    @Autowired
    private BookContainer bookContainer;

    //根据isbn查询图书,如果没有查到,抛出异常
    @GetMapping("/book")
    public BookRecord getBook(String isbn) {
        Optional<BookRecord> bookRecord = bookContainer.getBooks().stream().filter(el ->
                el.isbn().equals(isbn)
        ).findFirst();
        if (bookRecord.isEmpty()) {
            //throw new BookNotFoundException(" isbn :" + isbn + "->没有此图书");
            throw new IsbnNotFoundException(HttpStatus.NOT_FOUND, " isbn :" + isbn + "->没有此图书");
        }
        return bookRecord.get();
    }
}

3.启动RFC7807支持,修改application.yml,增加配置

spring:
  mvc:
    problemdetails:
      enabled: true

4.测试接口
[SpringBoot3]Web服务_第26张图片

你可能感兴趣的:(java,springboot)