Spring Boot 实战指南（一）：入门、配置、Web、文件上传、异常页面_异常页面如何部署

一、创建项目

• 点击file>new>project
• 在页面上输入项目的详细信息：

Name：项目名称
Location：本地存放目录
Language：编程语言肯定选择java
Type：管理工具选择Maven
Group：包的目录结构，一般形式是com.xxx，我写的是moodNotepad
Artifact：我写的项目名称moodNotepad
Package name：Group+Artifact
Project SDK：jdk版本选择1.8
Java：语言等级选择版，要与jdk版本相对应
Packaging：部署项目的形式，我选的jar
1
2
3
4
5
6
7
8
9
10

• 点击next，再点击finish，完成创建

创建好的目录结构如下，删除了一些无关紧要的东西。把application.properties的后缀修改为application.yml，只是修改了文件类型而已，并不影响文件功能。

• 文件目录说明：

src/main路径下有两个目录，一个是java用来存放源代码，另一个是resources用来存放一些重要资源。
application.yml是项目的配置文件。
pom.xml是项目的依赖管理文件。
MoodNotepadApplication是项目的启动类，运行它就可以启动项目。
1
2
3
4

二、配置文件

1.配置基础

• properties文件和yml文件的语法的不同：

application.properties语法：

# 数据库配置信息
driver=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/user
user=root
password=123456
1
2
3
4
5

application.yml语法：

# 数据库配置信息(键值对中间有一个空格)
driver: com.mysql.jdbc.Driver
jdbcUrl: jdbc:mysql://localhost:3306/user
user: root
password: 123456

person:
  name: xiaoming
  age: 20
  friends:
    # List结构
    - xiaowang
    - xiaohong
  dog:
    # Map结构
    name: xiaogou
    age: 2

person:
  name: xiaoming
  age: 20
  friends: [xiaoming, xiaohong]
  dog: { name: xiaogou, age: 2 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2.配置注入

• 单值注入：

//在变量声明上方写这一行注解
@Value("${course.id}")
private int id;
1
2
3

• 多值注入：

//在类的定义上方写这一行的注解，就可以以对象的形式把所有属性值注入进来
@ConfigurationProperties(prefix = "user")
1
2

3.自定义配置

除了将配置写在application.yml或application.properties文件中，还可以在resources路径下创建自定义的配置文件。

• 创建resources/user.properties文件

注意：为了使自定义配置生效，应该将application.yml或application.properties文件中的user相关配置删除。

user.id=1
user.userName=tracy
user.age=2
user.gender=male
1
2
3
4

• 创建tracy.moodnotepad.User类：

package tracy.moodnotepad;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "user")
@PropertySource(value= "classpath:user.properties")
public class User {
    Integer id;
    String userName;
    String gender;
    Integer age;

    public void setId(Integer id) {
        this.id = id;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getGender() {
        return gender;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + userName + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

• 创建tracy.moodnotepad.controller.UserController类：

package tracy.moodnotepad.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import tracy.moodnotepad.User;

@RestController
public class UserController {
    @Autowired
    private User user;

    @RequestMapping(value="/user")
    public String getUser(){
        return user.toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

@RestController ：集合了 @Controller 注解和 @RequestBody 注解。表示该注解标识的类为一个控制器，且该类的所有方法的返回值都转换为 JSON 格式，同时将返回值写入到 Response 对象的 body 中。
@RequestMapping(“/user”) ：“/user” 路径的 HTTP 请求都将映射到该方法进行处理。

• 运行MoodNotepadApplication启动类

默认端口是8080

• 浏览器中访问：

浏览器地址栏输入localhost:8080/user回车，页面上就出现了自定义配置文件中的属性值。

注意：我尝试了一下，项目配置文件application.properties可以更改为yml格式，仍然能生效；但是自定义的配置文件只能是properties格式的，暂时不知道原因。

4.多环境配置

(1)基于properties配置文件

在resources目录下，创建以下三个配置文件，分别对应三种不同的环境配置。

• application-dev.properties：开发环境

user.id=1
user.userName=dev-tracy
user.age=2
user.gender=male
1
2
3
4

• application-test.properties：测试环境

user.id=1
user.userName=test-tracy
user.age=2
user.gender=male
1
2
3
4

• application-prod.properties：生产环境

user.id=1
user.userName=prod-tracy
user.age=2
user.gender=male
1
2
3
4

• 修改默认配置文件application.yml

# 激活开发环境，使用开发环境设置
spring:
  profiles:
    active: dev
1
2
3
4

然后运行项目：

(2)基于yml配置文件

基于yml的多环境配置比较简单，首先删除三个properties文件，然后将多环境配置内容全部写在默认的application.yml中：

# 激活开发环境，使用开发环境设置
spring:
  profiles:
    active: test

---
# 开发环境
user:
  id: 1
  userName: dev-tracy
  age: 2
  gender: male
spring:
  config:
    activate:
      on-profile: dev

---
# 测试环境
user:
  id: 1
  userName: test-tracy
  age: 2
  gender: male
spring:
  config:
    activate:
      on-profile: test

---
# 生产环境
user:
  id: 1
  userName: prod-tracy
  age: 2
  gender: male
spring:
  config:
    activate:
      on-profile: prod
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

这样就可以了。可以自行运行下项目试一下效果。

(3)打包后切换环境

前面展示的都是在打包前进行多环境配置，但实际上，如果项目已经打包了，就很难再去修改配置文件了。因此，有必要学习下项目打包之后的多环境切换。

• 打包：

在IDEA中的terminal终端中执行命令mvn package命令，等待打包完成。

• 运行jar包：

打包好的jar在target目录下，运行jar包：

java -jar target/moodNotepad-0.0.1-SNAPSHOT.jar
1

默认环境为test：

• 切换环境：

java -jar target/moodNotepad-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev
1

三、Web开发

1.spring mvc

当在 Spring Boot 中引入 Web 模块时，会自动配置 Web 相关的组件，其中 Spring MVC 便是最重要的部分。

下面分析一下spring mvc的原理。

• Servlet

首先，有必要了解一下Servlet是什么。关于java Servlet，这位大佬写的非常详细，请看他的博客：这里

• MVC

文字参考：博客1、博客2

在使用Servlet的过程中，我们需要手动安排好Servlet和URI之间的对应关系，这个过程并不高效。因此，就有了Spring MVC这样的框架，用来简化web开发工作。在了解Spring MVC框架前，我们先通过一张图片来看看什么是MVC。

• spring mvc

组件介绍：

 1. DispatcherServlet前端控制器：整个流程的控制中心，由它调用其他组件处理用户请求。
 2. HandlerMapping处理器映射器：根据用户请求的 URL 找到相应的 Handler 处理器。
 3. HandlerAdapter处理器适配器：根据HandlerMapping找到的 Handler的相关信息，依据特定的规则去执行相关的处理器 Handler。
 4. Handler处理器：负责执行用户的请求，Controller便是处理器。
 5. ModelAndView : 使用 ModelAndView类用来存储处理完后的结果数据，以及显示该数据的视图。
 6. ViewResolver视图解析器：首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成 View 视图对象，最后对 View 进行渲染将处理结果通过页面展示给用户。

1
2
3
4
5
6
7
8

其中，需要开发者开发的是Handler和视图。

Spring MVC 工作流程：

 1. 用户向服务器发送请求至前端控制器 DispatcherServlet。 
 2. DispathcherServlet 调用HandlerMapping，由此得知由哪个 Handler （Controller）来处理该请求。
 3. HandlerMapping找到具体的处理器，生成处理器对象及处理器拦截器一并返回给 DispathcherServlet。
 4. DispathcherServlet调用 HandlerAdapter 。
 5. HandlerAdapter 经过适配调用具体的Handler，也叫做控制器（Controller）。
 6. Handler 处理完请求后返回 ModelAndView 。
 7. HandlerAdapter 将后端处理器的结果 ModelAndView 反馈给 DispathcherServlet。
 8. DispathcherServlet 将 ModelAndView 传给 视图解析器 ViewResolver 。
 9. ViewResolver 根据 ModelAndView 中的视图名称返回具体的 View 。
 10. DispathcherServlet 将 ModelAndView 中的模型数据填充到视图中，渲染视图。
 11. DispathcherServlet 将结果响应给用户。
1
2
3
4
5
6
7
8
9
10
11

2.常用注解

(1)组件

• 通用组件注解：@Component

通用的组件，用来标识任意类为 Spring 组件，该组件会被扫描到 IOC 容器中。当组件不好归类的时候，可以使用这个组件进行标注。

• @Controller

对应 Spring MVC 控制层，主要用户接受用户请求并调用 Service 层返回数据给前端页面。

• @Service

对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。

• @Repository

对应持久层即 Dao 层，主要用于数据库相关操作。

(2)Controller层类和方法专用

• @RequestMapping用于URL映射

用在类或者方法上，将URL与该类、该方法映射起来。

属性：

path：用来指定请求的 URL ，value 是它的别名。
method：用来指定请求的方式。值为 GET、POST、PUT、DELETE 等。
params ：用于指定限制请求参数的条件。
headers：用于指定限制请求消息头的条件。
1
2
3
4

在 Spring Boot 中，针对不同的请求方式，都提供了具体的注解：

• @ResponseBody用于将方法的返回类型写入Response 的 body 中

用在方法上。如果返回值是字符串，那么直接将字符串返回给前端。如果返回值是一个对象，会将对象转换为 JSON 串，然后返回给前端。

• @RestController

用在类上。

是 @Controller 和 @ResponseBody 的结合体。当被 @RestController 注解修饰时，表示该类是一个控制器类，且方法的返回值会写入到 Response 的 body 中。

(3)Controller层参数专用

• @PathVariable 、@RequestParam

@PathVariable 的作用为获取路径变量。
@RequestParam 的作用为获取请求参数，也能获取 HTTP 请求体中Content-Type 为 application/x-www-form-urlencoded 编码的内容格式，类似于 id=1&name=ha&age=1 这种格式的数据。

@RequestMapping("/user/addUser/{id}")
public void addUser(@PathVariable("id") int id, @RequestParam("name") String name){
    ...
}
1
2
3
4

• @RequestBody

接收的参数来自于 HTTP 报文的 Request Body 中，即请求体。一般用于处理非 Content-Type: application/x-www-form-urlencoded编码格式的数据，比如：application/json、application/xml 即 JSON、XML 等类型的数据。

@RequestBody和@RequestParam的区别：这里

四、自定义 Spring MVC 配置

在使用spring boot的时候，其实它已经对spring mvc进行了自动配置，但有时候也需要自定义spring mvc的配置来满足开发需求。

自定义 Spring MVC 配置有两种方式： 一种是在自动配置的基础上，进一步扩展 Spring MVC 配置；另外一种是使原有的 Spring MVC 自动配置失效，重写 Spring MVC 配置。

扩展Spring MVC配置需要定义一个配置类，并实现WebMvcConfigurer接口；重写Spring MVC配置通过定义一个继承 WebMvcConfigurationSupport 类的配置类来实现，或者在一个配置类上使用 @EnableWebMvc 注解。

在正式学习本章内容前，请先确保pom.xml中已经添加了web的依赖：

<!--添加web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
1
2
3
4
5

扩展Spring MVC配置

需求

1. 将URL与本地静态资源路径映射起来，比如，访问/upload/**会去项目中的resources/upload路径下读取。
2. 首页绑定，访问/index时，自动跳转至index.html。
3. 当发送 /test 请求时，添加一个拦截器，在请求执行前后和视图渲染后打印相关信息。

下面就进入需求的实现部分。

(1)静态资源映射

• 首先，在项目中的resources路径下创建文件夹upload，并放入一张图片cover.png
• 然后，在com.moodnotepad.config包下创建配置类ExtendMvcConfig，并实现WebMvcConfigurer接口

类上添加注解@Configuration，表明这是一个配置类。
实现接口中的方法addResourceHandlers。

package tracy.moodnotepad.config;

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

@Configuration
public class ExtendMvcConfig implements WebMvcConfigurer {

    /**
     * 添加资源映射器
     * @param registry
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/upload/**")
                .addResourceLocations("classpath:/upload/");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 启动项目，然后去浏览器中访问http://localhost:8080/upload/cover.png

静态资源映射成功。

(2)首页绑定

• 在resources目录下创建文件夹static，在static下创建页面index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
</head>
<body>
    <h1>this is index page</h1>
</body>
</html>
1
2
3
4
5
6
7
8
9
10

• 在ExtendMvcConfig类中添加如下方法

    /**
     * 添加视图控制器
     * @param registry
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/index").setViewName("index.html");
    }
1
2
3
4
5
6
7
8

• 启动项目，然后去浏览器中访问http://localhost:8080/index

配置成功。

(3)添加拦截器

• 在tracy.moodnotepad.util包下自定义一个拦截器

package tracy.moodnotepad.util;

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

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

public class TestInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("前置处理完成");
        return true;
    }

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• 在ExtendMvcConfig配置类下定义如下方法

    /**
     * 添加拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TestInterceptor()).addPathPatterns("/test");
    }
1
2
3
4
5
6
7
8

• 启动项目，在浏览器中访问http://localhost:8080/test，IDEA后台出现拦截器中的处理：

配置成功。

五、文件上传

1.html文件

在resources/static下创建fileupload.html文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h2>Spring Boot 文件上传</h2>
    <form action="/upload" method="post" enctype="multipart/form-data">
        <input type="file" name="file" />
        <br /><br />
        <input type="submit" value="文件上传" />
    </form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.controller实现

在com.moodnotepad.controller包下创建UploadController类：

package tracy.moodnotepad.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

@RestController
public class UploadController {
    //配置的文件存储绝对路径
    @Value("${file.upload.path}")
    String fileSavePath;

    //实现的文件上传方法
    @PostMapping("/upload")
    public String uploadFile(@RequestParam("file") MultipartFile file){
        if(file.isEmpty())return "上传失败";
        String fileName = System.currentTimeMillis()+file.getOriginalFilename();//生成文件名
        String filePath = fileSavePath+ File.separator+fileName;//生成绝对路径
        try{
            byte[] bytes = file.getBytes();
            Path path= Paths.get(filePath);
            Files.write(path,bytes);
        }catch (IOException e){
            e.printStackTrace();
        }
        return "文件保存路径："+filePath;
    }
}

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

3.存储路径配置

将application.yml清空，然后添加如下配置。

注意，path的绝对路径配置一定要写正确，windows和linux操作系统的绝对路径写法是不一样的。

# -----文件上传相关配置-----
# 自定义文件上传路径
file:
  upload:
    path: C:\Users\14095\Desktop

# 最大支持文件大小，默认1M
spring:
  http:
    multipart:
      maxFileSize: 10Mb
1
2
3
4
5
6
7
8
9
10
11

4.测试

最后，启动项目，然后在浏览器中访问http://localhost:8080/fileUpload.html：

上传文件后，配置的绝对路径下出现了上传的文件，表明功能实现成功：

六、异常页面

spring boot默认的异常处理页面是这样的：

接下来，我们来学习如何进行异常页面的配置。

1.添加依赖

在pom.xml中添加模板引擎的依赖，用来动态渲染html页面：

        <!--Thymeleaf依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
1
2
3
4
5

然后更新maven：

2.设置通用异常页面

在resources目录下创建模板文件目录templates，然后在templates下创建error文件夹，再在error下创建4xx.html。我们使用thymeleaf 模板引擎来设置动态的异常页面。

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8" />
  <title>4xx</title>
</head>
<body>
<h1>4xx</h1>
<table border="1">
  <tr>
    <td>path</td>
    <td th:text="${path}"></td>
  </tr>
  <tr>
    <td>error</td>
    <td th:text="${error}"></td>
  </tr>
  <tr>
    <td>message</td>
    <td th:text="${message}"></td>
  </tr>
  <tr>
    <td>timestamp</td>
    <td th:text="${timestamp}"></td>
  </tr>
  <tr>
    <td>status</td>
    <td th:text="${status}"></td>
  </tr>
</table>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• 解析：

4xx.html页面上获取的几个属性值均来自于 DefaultErrorAttributes 类对异常属性的封装。感兴趣的可以自行查看源码进行学习。

• 测试：

运行项目后在浏览器中访问一个不存在的链接：http://localhost:8080/t

3.自定义返回的异常属性值

一种简单好用的实现方法是：继承 DefaultErrorAttributes 类，重写 getErrorAttributes 方法。

• 在tracy.moodnotepad.util包下创建ExtendError类，继承DefaultErrorAttributes 类，重写 getErrorAttributes 方法。

package tracy.moodnotepad.util;

import org.springframework.boot.web.error.ErrorAttributeOptions;
import org.springframework.boot.web.servlet.error.DefaultErrorAttributes;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.WebRequest;

import java.util.Map;

@Component
public class ExtendError extends DefaultErrorAttributes {
    @Override
    public Map<String, Object> getErrorAttributes(WebRequest webRequest, ErrorAttributeOptions options) {
        // 调用父类的方法获取包装好的异常数据
        Map<String, Object> attributes = super.getErrorAttributes(webRequest, options);
        if (attributes.get("status").equals(404)) {
            // 添加自定义异常数据
            attributes.put("author", "tracy");
        }
        return attributes;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

• 修改4xx.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="UTF-8" />
  <title>4xx</title>
</head>
<body>
<h1>4xx</h1>
<table border="1">
  <tr>
    <td>path</td>
    <td th:text="${path}"></td>
  </tr>
  <tr>
    <td>error</td>
    <td th:text="${error}"></td>
  </tr>
  <tr>
    <td>message</td>
    <td th:text="${message}"></td>
  </tr>
  <tr>
    <td>timestamp</td>
    <td th:text="${timestamp}"></td>
  </tr>
  <tr>
    <td>status</td>
    <td th:text="${status}"></td>
  </tr>
<!--  添加属性-->
  <tr>
    <td>author</td>
    <td th:text="${author}"></td>
  </tr>
</table>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

• 测试：

运行项目后在浏览器中访问一个不存在的链接：http://localhost:8080/t

成功！

---

参考：蓝桥云课Spring boot实战系列