Spring Boot

1.概述

SpringBoot是对Spring框架的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

1.1 SpringBoot的特点

• 为基于Spring的开发提供更快的入门体验
• 开箱即用，没有代码生成，也无需XML配置。只需要少量配置即可构建一个JAVA EE项目
• 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
• 内置Web服务器，可以快速部署
• SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring构建JavaEE项目的方式

2. 快速入门

利用IDEA工具通过Spring Initializr快速构建一个SpringBoot项目

2.1 Spring Initializr新建项目

点击下一步

配置好项目名称和jdk后点击下一步

勾选上Web里面的Spring Web依赖然后点击下一步

项目创建完成后的maven依赖如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

其中spring-boot-starter-parent是一个特殊的Starter，提供了一些maven的默认配置，同时还提供了dependency-management统一依赖管理，可以让开发者在引入其它依赖时不用输入版本号，方便依赖的管理，SpringBoot提供的starter很多，这些starter主要为第三方库提供的自动配置，例如spring-web依赖就是开发一个web项目必备的依赖。

2.2 编写启动类

@EnableAutoConfiguration
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        System.out.println("http://localhost:3399");
    }
}

• @EnableAutoConfiguration注解表示开启自动配置，因为添加了springweb依赖，所以使用此注解可以对spring和springmvc之间进行自动配置。在传统xml配置里需要配置大量的标签。
• 在main方法中通过SpringApplication中的run方法启动项目，参数一传入该类的.class，告诉spring主要的组件，参数二是运行时输入的其他参数。

2.3 编写控制器

在控制器指定一个/index接口，并在主启动类配置包扫描将控制器注册到spring容器中。

@RestController
public class IndexController {
    @GetMapping("/index")
    public String index() {
        return "This is a SpringBoot Application";
    }
}

启动类

@EnableAutoConfiguration
@ComponentScan    //扫描所有的包到spring容器
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class);
        System.out.println("http://localhost:3399");
    }
}

上面的@EnableAutoConfiguration和@ComponentScan注解可以用一个组合注解代替，@SpringBootApplication，此注解默认覆盖了这两个注解的功能。

@SpringBootApplication
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class);
        System.out.println("http://localhost:3399");
    }
}

启动项目访问`http://localhost:3399/index`

3. SpringBoot基本配置

3.1 @SpringBootApplication

上面用到的@SpringBootApplication注解是一个组合注解，是Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，项目启动应该运行这个类的main方法来启动SpringBoot应用，源码如下

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
      @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

• @SpringBootConfiguration:Spring Boot的配置类，表示这是一个Spring Boot的配置类；
• @Configuration:配置类上来标注这个注解
• @Component：表示这是一个配置类，是容器中的一个组件；

• @EnableAutoConfiguration：开启自动配置功能；

    以前需要xml中配置的信息，Spring Boot可以自动配置；@**EnableAutoConfiguration**告诉SpringBoot开启自动配置功能，这样自动配置才能生效。

3.2 自定义banner

SpringBoot项目在启动时会打印一个信息图标，如下图所示

上面这个图标可以通过自定义其它的内容显示，做法是在resources目录下创建一个banner.txt文件，在这个文件中写入文本，内容将会在项目启动时被打印出来，如果想替换各种艺术字则有以下几个网站可以定制。

• http://www.network-science.de/ascii/
• http://www.kammerl.de/asciiSignature.php
• http://patorjk.com/software/taag

如果想要关闭显示banner图标则可以在启动类设置。

SpringApplicationBuilder builder = new SpringApplicationBuilder(SpringBootDemoApplication.class);
builder.bannerMode(Banner.Mode.OFF).run(args);

3.3 Web容器配置

    在SpringBoot项目中可以内置Tomcat、Jetty、Undertow、Netty等容器，当添加了springweb依赖时默认会使用tomcat作为Web服务器，可以在resources下的application.properties文件中进行其它配置。

3.3.1 常规配置

server.port=39    #配置项目访问端口号
server.error.path=/error    #项目出错时跳转到error命名的页面
server.servlet.session.timeout=30m    #设置session失效时间，30m为三十分钟
server.servlet.context-path=/hello    #配置访问路径，默认为/
server.tomcat.uri-encoding=utf-8    #设置Tomcat请求编码
server.tomcat.basedir=/src/log    #设置存放Tomcat运行日志和临时文件的目录

3.32 Jetty配置

将默认的Tomcat服务器切换为Jetty服务器，配置如下

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

首先排除Tomcat的starter依赖，然后再添加Jetty的依赖。启动项目查看控制台结果

3.4 properties配置

SpringBoot中采用大量的自动化配置，替换了繁杂的XML配置，但也需要少量的配置来满足项目的开发需求，这些配置通常写入到resources目录下的application.properties文件，或者application.yaml文件，这两种配置文件有着格式上的区别。

SpringBoot项目中的application.properties配置文件可以放置到以下四个路径位置

1. 项目根目录下的config文件夹中
2. 项目根目录下
3. classpath下的config文件夹中
4. classpath路径下

   如果这四个位置都有properties文件则加载的时候按照优先级高低，上面从高到低分别为：1-2-3-4

3.5 类型安全配置属性

SpringBoot提供了@Value注解来将类中的属性通过配置注入数据，这样即使在数据量大的情况下，也可以方便的将配置文件中设置的数据注入到Bean中。

在properties中添加一段配置

user.name=admin
user.password=system
user.age=30;

新建一个类，将配置数据注入到Bean中

@Component
@ConfigurationProperties(prefix = "user")
public class User {
    private String username;
    private String password;
    private Integer age;
    //省略get&set方法
}

@ConfigurationProperties中的prefix属性表示要加载的配置类中指定的前缀，通过此前缀在配置文件中调用成员变量属性。

最后创建一个Controller测试

@Autowired
private User user; //注入user类
@GetMapping("/user")
public String user() {
    return user.toString();
}

最后测试访问http://localhost:3399/user地址

3.6 yaml配置

yaml是json的超集，是一种专门用来编写配置文件的语言，功能和properties文件一样，yaml采用缩进来表示层级的关系，并且大小写敏感，使用yaml文件只需要在resources目录下创建一个application.yaml文件。

3.6.1 语法示例

新建两个User实体类

@Data
@Component //注入到容器当中
@ConfigurationProperties(prefix = "user") //指定配置文件中对象的前缀
public class User implements Serializable {
    private String username; //字符串类型
    private Boolean showStatus; //布尔类型
    private Date birthday; //日期类型
    private Integer age; //数值类型
    private Pet pet; //对象类型
    private String[] hobby; //字符串数组
    private List<String> pets; //List集合类型
    private Map<String, Object> money; //Map集合类型
    private Set<String> salaries; //Set集合类型
    private Map<String, List<Pet>> allPets; //复杂Map集合类型
}
@Data
public class Pet {
    private String name;
    private Integer age;
}

• yaml语法配置

# 指定的suer前缀
user:
  username: Ted #普通字符串类型
  showStatus: true #布尔类型
  birthday: 2020/12/30 22:22:22 #日期类型
  age: 20 #数值类型
  #对象类型配置
  pet:
    name: Bear
    age: 3
  #数组类型配置
  hobby: [学习,睡觉]
  #List集合类型配置
  pets:
    - Cat
    - Dog
  #Map集合类型  
  money:
    ted:
      bear: 20
      dog: 30
      cat: 40
    #行内写法  
    admin: [1,2,3]
    arthur: [deer: 30, horse: 40]
  #Set集合类型  
  salaries: [2000,3000,4000]
  #复杂Map集合类型
  allPets:
    big:
      - {name: Bear}
      - {name: elephant}
    small: [{name: cat,age: 3}]

• 测试

@Autowired
User user; //注入user对象
@GetMapping("/user")
public User findAll() {
    return user; //返回user对象
}

3.7 profile

为了替换不同开发环境的配置文件，springboot提供了profile表示配置环境，根据后缀配置不同的开发环境。

使用如下：

1. 在resources目录下创建两个配置文件：application-dev.properties、application-prod.properties
   • application-dev.properties

server.port=8080

• application-dev.properties

server.port=80

区分两个配置文件的端口号

• 接下来在application.properties文件指定开发的环境

spring.profiles.active=dev

上面这段内容表示指定并使用application-dev.properties配置文件中的内容，如果替换为prod，则是用application-prod.properties中的内容

• 在启动器中指定开发环境

SpringApplicationBuilder builder = new SpringApplicationBuilder(SpringBootDemoApplication.class);
builder.application().setAdditionalProfiles("dev");
builder.run(args);

4. Spring Boot整合视图层技术

分别整合Thymeleaf-FreeMarker两种视图层的技术

4.1 整合thymeleaf

1. 添加thymeleaf依赖

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

1. 配置thymeleaf信息

#是否开启缓存，默认为true
spring.thymeleaf.cache=true
#文件编码
spring.thymeleaf.encoding=UTF-8
#模板文件位置 
spring.thymeleaf.prefix=classpath:/templates/
#Content-Type配置
spring.thymeleaf.servlet.content-type=text/html
#模板文件后缀
spring.thymeleaf.suffix=.html

1. 编写Controller测试

@GetMapping("/datas")
public String da(Model model) {
    List<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("World");
    model.addAttribute("result",list);
    return "data";
}

1. 在templates目录下创建一个data.html视图

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <div th:text="${result[0]}"></div>
        <div th:text="${result[1]}"></div>
    </body>
</html>

视图层根据索引取两个添加的值，运行项目即可看到添加的内容

4.2 整合FreeMarker

1. 添加依赖

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

1. 编写FreeMarker配置

#是否开启缓存
spring.freemarker.cache=false
#文件编码
spring.freemarker.charset=UTF-8
#文件后缀
spring.freemarker.suffix=.ftl
#模板文件位置
spring.freemarker.template-loader-path=classpath:/templates/

1. 编写Controller代码

@GetMapping("/datas")
public String da(Model model) {
    List<String> list = new ArrayList<>();
    list.add("Hello");
    list.add("World");
    model.addAttribute("result",list);
    return "data";
}

1. 创建一个.ftl后缀的视图文件

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <div>${result[0]}</div>
        <div>${result[1]}</div>
    </body>
</html>

5. SpringBoot整合Web开发

5.1 返回JSON数据

Json是目前主流的前后端数据传输方式，SpringMVC中使用的消息转换器HttpMessageConverter接口，对JSON的转换提供了支持。在SpringBoot中更进一步的对相关配置进行了简化。

• 在项目中测试返回json数据

  • 添加web依赖

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

      • 这个依赖默认加入了jackson-databind作为JSON的处理器，此时不需要额外添加JSON的处理器就能返回一段JSON数据了。

• 创建User实体类

  • @Data
    public class User {
    private String username;
    private String password;
    private Double height;
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date birthday;
    private Integer age;
    /*
    省略get&set
    */
    }

• 创建UserController测试

  • @RestController
    public class UserController {
    @GetMapping("/user")
    public User user() {
    User user = new User();
    user.setUsername("Ted");
    user.setPassword("123");
    user.setHeight(180.5d);
    user.setAge(20);
    user.setBirthday(new Date());
    return user;
    }
    }

    • @RestController是@ResponseBody和@Controller注解的组合，用于响应json数据到网页中

• 测试

  • 启动项目访问http://localhost:8080/user

上面这种是采用SpringBoot默认的处理Json的方式，可以对字段忽略，日期格式化等需求可以通过注解实现。

5.2 自定义JSON转换器

常见的JSON处理器除了jackson-databind之外，还有Gson和fastjson，这里采用常用的方法演示。

使用Gson转换器。

Gson是Google的一个开源JSON解析框架，使用Gson需要先去除SpringBoot默认的jackson-databind，然后加入Gson依赖

1. 添加Gson依赖

   <dependency>
   <groupId>com.google.code.gson</groupId>
   <artifactId>gson</artifactId>
   </dependency>
   <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
       <exclusion>
           <groupId>com.fasterxml.jackson.core</groupId>
           <artifactId>jackson-databind</artifactId>
       </exclusion>
   </exclusions>
   </dependency>

   SpringBoot中也默认提供了Gson的自动转换类`GsonHttpMessageConvertersConfiguration`，因此Gson的依赖添加成功后，就可以和默认的jackson-databind一样直接使用Gson了

   1. 自定义格式化处理类

处理对日期数据进行格式化的自定义转换代码

@Configuration
public class GsonConfigure {
    @Bean //注册一个格式转换对象实例
    public GsonHttpMessageConverter gsonHttpMessageConverter() {
        GsonHttpMessageConverter converter = new GsonHttpMessageConverter();
        GsonBuilder builder = new GsonBuilder(); 
        builder.setDateFormat("yyyy-MM-dd"); //设置日期格式化
        Gson gson = builder.create(); //创建Gsno对象放入
        converter.setGson(gson); 
        return converter;
    }
}

1. Controller层

@GetMapping("/user")
public User user() {
    User user = new User();
    user.setUsername("Ted");
    user.setPassword("123");
    user.setHeight(180.5d);
    user.setAge(20);
    user.setBirthday(new Date());
    return user;
}

1. 测试

启动项目访问http://localhost:8080/user

5.3 文件上传

SpringBoot中对文件上传做了更进一步的简化，使得文件上传更方便。

Java中文件上传一共涉及两个组件，一个是CommonsMultipartResolver，另一个是StandardServletMultipartResolver，其中CommonsMultipartResolver是使用commons-fileupload来处理multipart请求，而StandardServletMultipartResolver则是基于Servlet 3.0来处理multipart请求。

5.3.1 文件上传功能实现

1. 创建springboot项目添加web依赖

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

1. 在resource目录下创建upload.html文件

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>upload</title>
    </head>
    <body>
        <form action="/upload" method="post" enctype="multipart/form-data">
            <input type="file" name="uploadFile" value="请选择文件">
            <input type="submit" value="上传文件">
        </form>
    </body>
</html>

1. 编写Controller层处理文件上传

package com.bear.springboot.controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
@RestController
public class FileUploadController {
    SimpleDateFormat sdf =  new SimpleDateFormat("yyyy/MM/dd/");
    @PostMapping("/upload")
    public String upload(MultipartFile uploadFile, HttpServletRequest request) {
        //指定文件上传路径为当前项目运行目录
        String realPath = request.getSession().getServletContext().getRealPath("/uploadFile/");
        //格式化日期
        String format = sdf.format(new Date());
        //判断是否是目录，不是就创建
        File folder = new File(realPath + format);
        if (!folder.isDirectory()) {
            folder.mkdirs();
        }
        //获取原始文件名
        String oldName = uploadFile.getOriginalFilename();
        //使用随机数生成文件不同的名称。
        String newName = UUID.randomUUID().toString()+oldName.substring(oldName.lastIndexOf("."),oldName.length());
        try {
            //调用transferTo方法进行文件上传操作
            uploadFile.transferTo(new File(folder,newName));
            //生成上传文件访问路径，并渲染到网页中。
            return request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+"/uploadFile/"+format+newName;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "上传失败";
    }
}

1. 测试

   访问`http://localhost:8080/upload.html` 上传文件，然后根据生成路径访问图片。

• 指定上传文件的配置

spring.servlet.multipart.enabled=true    #是否开启上传文件的支持，默认为true
spring.servlet.multipart.file-size-threshold=0    #文件写入磁盘的阈值，默认为0
spring.servlet.multipart.location=D:\\file    #文件临时保存的位置
spring.servlet.multipart.max-file-size=1MB    #上传单个文件的最大大小。默认为1MB
spring.servlet.multipart.max-request-size=10MB    #上传多文件的总大小，默认为10MB
spring.servlet.multipart.resolve-lazily=false    #是否延迟解析，默认为false

5.4 全局异常处理

使用`@ControllerAdvice`注解进行全局的异常处理

• ControllerAdvice此注解通常用于处理项目的全局异常，全局异常就是只要项目中的任何一个类任何一行代码触发了全局异常配置类中的代码，则会报出定义的错误信息。
• 此注解用于处理页面之间的跳转异常。

5.4.1 根据转发视图处理

• 下面定义一个全局处理算术的异常演示
  1.引入所需的依赖

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

1. 定义全局异常类

@ControllerAdvice
public class CustomException {
    @ExceptionHandler(value = ArithmeticException.class)
    public ModelAndView modelAndView(Exception e) {
        ModelAndView mv = new ModelAndView();
        mv.addObject("message", "执行了算术异常"); 
        mv.setViewName("error"); //设置跳转的视图
        return mv;
    }
}

[@ExceptionHandler ](/ExceptionHandler ) 注解为指定要抛出的异常，如果抛出所有异常则调用父类Exception.class，这里演示算术异常 

1. error页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <span th:text="${message}"></span>
    </body>

在templates目录下建立一个error.html文件，并输出message信息。

1. 编写控制器，定义一个错误代码

@Controller
public class ExceptionController {
    @GetMapping("/index")
    public void index() {
        int a = 10/0;
    }
}

在Controller中设定一个10除0的错误，以演示全局异常功能。

1. 测试

   访问http://localhost:8080/index 则会看到网页中抛出的自定义异常信息

5.4.2 根据返回字符串处理

直接在浏览器返回字符串，使用`@RestControllerAdvice`注解。

1. 修改自定义异常类

@RestControllerAdvice
public class CustomException {
    @ExceptionHandler(value = ArithmeticException.class)
    public String error(Exception e) {
      return "触发了算术异常" + e.getMessage();
    }
}

直接定义一个String方法，并返回指定的异常信息。

1. Controller

@Controller
public class ExceptionController {
    @GetMapping("/index")
    public void index() {
        int a = 10/0;
    }
}

5.5 注册拦截器

SpringMVC中的拦截器可以做到对项目运行之前、运行时、运行之后进行预处理。在SpringBoot中使用拦截器更加方便，只需要两个配置类即可对项目进行额外的处理。

• 在项目中配置拦截器
  1.首先引入web依赖

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

  1. 编写自定义拦截器，并实现HandlerInterceptor接口

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle==>:执行了");
        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==>:执行了");
    }
}

HandlerInterceptor接口中一共有三个方法，这三个方法会按照preHandle-Controller-postHandle-afterCompletion顺序执行，只有当第一个方法preHandle方法返回true时后面的方法才会执行，而postHandle方法则是当拦截器链内所有的拦截器返回成功后才会调用，afterCompletion则是只有preHandle方法返回true时才会调用。

3.配置拦截器拦截的资源。

@Configuration
public class WebMvcConfiguration implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor())
                .addPathPatterns("/**")
                .addPathPatterns("/hello")
                .excludePathPatterns("/user");
    }
}

这个配置类对应拦截器所配置的拦截资源，比如拦截路径、静态资源。
addInterceptors中的方法表示添加拦截的路径，excludePathPatterns表示排除的路径。

1. 配置两个Controller接口

@RestController
public class Interceptor {
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }
    @GetMapping("/user")
    public String getUser() {
        return "admin user";
    }
}

提供一个hello、user路径的接口，由于在拦截器中配置了拦截/hello接口和排除了/user接口，所以当测试的时候访问/hello接口会触发拦截器中的方法，而访问/user接口则不会。

5.6 启动系统任务

有一些特殊的任务需要在启动器启动的时候执行，例如加载配置文件、数据库初始化等操作，springboot提供了两种方案，实现`ApplicationRunner`或`CommandLineRunner`接口，这两个接口基本一致，差别体现在参数上面。

5.6.1 CommandLineRunner

SpringBoot项目在启动时会遍历所有此接口的实现类，并调用其中的run方法，达到在项目启动时就执行的效果，如果配置了多个类继承CommandLineRunner接口则使用@Order注解指定任务执行的顺序

1. 在项目中分别添加两个类继承CommandLineRunner接口

MyCommandLineRunner1

@Component
@Order(1)
public class MyCommandLineRunner1 implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("MyCommandLineRunner1任务执行");
    }
}

MyCommandLineRunner2

@Component
@Order(2)
public class MyCommandLineRunner2 implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("MyCommandLineRunner2任务执行");
    }
}

上面分别创建了两个类实现了CommandLineRunner接口，并使用@Component将类注入到spring容器中重写run方法打印一段信息，这些信息会在项目启动时在控制台打印。@Order注解是指定优先级顺序，数字越小优先级就越高，越先执行。

5.6.2 ApplicationRunner

5.7 整合Servlet、Filter、Listener

对传统web开发中的Servlet网页交互技术、filter过滤器、listener监听器整合到springboot项目当中

1. 分别创建三个对应的类

• servlet

@WebServlet("/servlet")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println(req.getParameter("name"));
    }
}

• Filter

@WebFilter("/*")
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("init方法执行");
    }
    @Override
    public void destroy() {
        System.out.println("destroy方法执行");
    }
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("doFilter方法执行");
        filterChain.doFilter(request, response);
    }
}

• Listener

@WebListener
public class MyListener implements ServletRequestListener {
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("requestDestroyed方法执行");
    }
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("requestInitialized方法执行");
    }
}

上面分别定义了对应三个组件，分别使用@WebServlet表示Servlet应用，@WebFilter表示过滤器应用，@Listener表示监听器应用进行表示。

1. 在启动类中标上注解扫描Servlet 的应用

@SpringBootApplication
@ServletComponentScan    //扫描servlet应用
public class SpringBootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootDemoApplication.class);
    }
}

• 测试

  启动项目访问http://localhost:8080/servlet?name=ted 路径即可看到结果。

5.8 整合AOP功能

AOP是（Aspect Oriented Programming）的缩写，翻译为面向切面编程，AOP是通过预编译方式和运行期间基于动态代理实现程序功能的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时可提高开发的效率。

• AOP基本概念
  • Joinpoint(连接点)：类里面被增强的方法就成为连接点，比如修改哪个方法哪个方法即为连接点。
  • Pointcut(切入点)：对Joinpoint进行拦截的定义即为切入点，例如对某个方法进行拦截，这个定义即为切入点。
  • Advice(通知)：使对方法配置进行输出的方式，通知分为前置、后置、异常、最终、环绕通知
  • Aspect(切面)：Pointcut和Advice的结合
  • Target(目标对象)：增强的类称为Target

    SpringBoot在原生Spring配置上做了简化的开发，省去了繁琐的XML配置。但需要导入额外的依赖

1.引入AOPstarter

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

1. 创建一个service供演示操作

package com.bear.springboot.service;
import org.springframework.stereotype.Service;
@Service //标识这是一个Service层的类，并注入到spring容器当中
public class UserService {
    //模拟根据id获取用户
    public String findUserById(int id) {
        System.out.println(id);
        return "获取" + id + "号用户";
    }
    //模拟删除用户
    public void removeUserById(int id) {
        System.out.println("删除了" + id + "号用户");
    }
}

1. 创建切面类，分别配置前置、后置、后置返回、后置异常、环绕通知方法。

package com.bear.springboot.log;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LogAspect {
    //配置方法的切入点，为service包下的所有类。
    @Pointcut("execution(* com.bear.springboot.service.*.*(..))")
    public void log() {}
    /**
     *  配置前置通知
     * @param joinPoint
     */
    @Before(value = "log()") //value值为方法的切入点。
    public void beforeAdvice(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法执行结束");
    }
    /**
     *  配置后置通知
     * @param joinPoint
     */
    @After(value = "log()")
    public void afterAdvice(JoinPoint joinPoint) {
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法执行结束");
    }
    /**
     *  配置后置返回通知
     * @param joinPoint
     * @param result
     */
    @AfterReturning(value = "log()",returning = "result")
    public void afterReturning(JoinPoint joinPoint,Object result) {
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法的返回值为：" + result);
    }
    /**
     *  配置后置异常通知
     * @param joinPoint
     * @param exception
     */
    @AfterThrowing(value = "log()",throwing = "exception")
    public void afterThrowing(JoinPoint joinPoint,Exception exception) {
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法抛出异常，异常为：" + exception);
    }
    /**
     *  配置环绕通知
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("log()")
    public Object aroudAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        return joinPoint.proceed();
    }
}

在LogAspect类中一共定义了五种通知类型，首先类上的@Aspect注解表示这是一个AOP的切面类，然后在类中定义了一个log()方法，这个方法是用来指定类切入点用的，使用`execution`表达式去指定要影响的包名或类名，第一个_表示方法的任意返回值类型，第二个 _表示service包下的任意类都配置。

• @Before注解

  • 这个注解表示前置通知，使用了该注解的方法会在方法执行前执行，通过`JoinPoint` 可以获取目标方法的方法名，修饰符等信息。

• @After

  • 此注解和@Before注解相反，它表示后置通知，在方法执行后执行。

• @AfterReturning

  • 此注解表示返回通知，在该方法执行后获取该方法的返回值，returning参数是指定返回值的变量名称，也就是对应的Object方法参数，在参数里定义了一个Object类型的变量，表示目标返回值可以是任意类型，如果参数类型为Long，则表示只能处理Long返回值的参数。

• @AfterThrowing

  • 表示是一个后置异常类的通知，如果目标方法发生异常时则会触发该通知，形参类型指定为Exception，表示所有异常都会进入该方法中执行，如果指定其它子类异常类，则只会默认抛出指定的异常。

• @Around

  • 此注解表示环绕型通知，环绕通知是所有通知功能里最强的功能，可以实现前置、后置通知、异常通知以及返回通知的功能。目标方法进入环绕通知后，通过调用ProceedingJoinPoint对象的proceed方法使目标方法继续执行，也可以修改目标方法的执行参数，返回值等。

5.9 自定义favicon

favicon.ico是浏览器左上角的显示图标，可以放在静态资源路径下或者类路径下，静态资源路径优先级要高于类路径下的favicon.ico

6. SpringBoot整合持久层技术

持久层技术是Java EE中对数据库进行访问操作的一种技术，SpringBoot对其持久层框架提供了自动化配置，例如JdbcTemplate、JPA等，MyBatis自动化配置则是Mybatis官方提供的。

6.1 整合JdbcTemplate

JdbcTemplate是Spring官方提供的一套jdbc模板框架，利用了AOP技术解决了原生jdbc大量重复代码的问题。

• 创建数据库和表

create database study;
use study;
create table user
(
    id      varchar(20) not null
        primary key,
    name    varchar(20) null,
    age     varchar(20) null,
    address varchar(20) null,
    birth   datetime    null
);
insert into user value(1,'ted',"19","China",now())

• 创建SpringBoot项目添加以下依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

• 配置数据库连接信息

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT
    username: root
    password: system56

• 创建实体类

package com.bear.springboot.entities;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.Date;
@Data
public class User {
    private String id;
    private String name;
    private String age;
    private String address;
    private Date birth;
}

由于添加了lombok依赖，可以使用@Data代替get&set方法

• 编写dao层

package com.bear.springboot.repository;
import com.bear.springboot.entities.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import java.util.ArrayList;
import java.util.List;
@Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public int saveUser(User user) {
        return jdbcTemplate.update("insert into user(id,name,age,address,birth) values(?,?,?,?,?)"
                ,user.getId(),user.getName(),user.getAge(),user.getAddress(),user.getBirth());
    }
    public int deleteUser(int id) {
        return jdbcTemplate.update("delete from user where id = ?",id);
    }
    public int updateUser(User user) {
        return jdbcTemplate.update("update user set name =?,age =?,address=?,birth=? where id =?"
                ,user.getName(),user.getAge(),user.getAddress(),user.getBirth(),user.getId());
    }
    public List<User> findAllByUser() {
        return jdbcTemplate.query("select * from user",new BeanPropertyRowMapper<>(User.class));
    }
}

注入使用JdbcTemplate类即可进行对数据库的操作，此类会被自动注册到Spring容器当中，以上dao层分别调用了update和query方法，update则对应增删改三种方式，而query则对应查询数据。在执行查询操作时，如果数据库字段和属性名称对应则直接使用BeanPropertyRowMapper对象，如果不对应则需要实现RowMapper接口将列字段和实体类字段一一对应。

• 创建Controller层调用dao层

package com.bear.springboot.controller;
import com.bear.springboot.entities.User;
import com.bear.springboot.repository.UserDao;
import com.bear.springboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
import java.util.List;
@RestController
public class UserController {
    @Autowired
    private UserDao userDao;
    @GetMapping("/crud")
    public void saveUser() {
        User user = new User();
        user.setId("4");
        user.setName("tony");
        user.setAge("38");
        user.setAddress("China");
        user.setBirth(new Date());
        System.out.println("添加数据==>"+userDao.saveUser(user));
          User user2 = new User();
        user2.setId("3");
        user2.setName("teddy");
        user2.setAge("20");
        user2.setAddress("japan");
        user2.setBirth(new Date());
        System.out.println("修改数据==>"+userDao.updateUser(user2));
        int result = userDao.deleteUser(4);
        System.out.println("删除==>"+result);
        List<User> userList = userDao.findAllByUser();
        userList.forEach((item -> {
            String value = item.toString();
            System.out.println("查询所有数据==>"+value);
        }));
    }
}

• 测试

  • 启动项目在浏览器地址栏输入http://localhost:8080/crud 即可看到控制台打印的内容

6.2 整合MyBatis

Mybatis是一款持久层框架，原名叫做iBatis。Mybatis支持定制化SQL，存储过程以及高级映射。不用像jdbc那样手动设置参数以及获取结果集，但需要配置大量的xml文件编写sql语句。在SpringBoot中由Mybatis官方提供了一套自动化配置方案。

• 创建springboot项目，添加以下依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.3</version>
</dependency>

• 创建数据表

create database study;
use study;
create table user
(
    id      varchar(20) not null
        primary key,
    name    varchar(20) null,
    age     varchar(20) null,
    address varchar(20) null,
    birth   datetime    null
);
insert into user value(1,'Bear',"19","China",now())

• 创建实体类

package com.bear.springboot.entities;
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.Date;
@Data
public class User {
    private String id;
    private String name;
    private String age;
    private String address;
    private Date birth;
}

• 配置yaml的mysql连接

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&useSSL=true&serverTimezone=GMT
    username: root
    password: system56

• 创建Mapper接口，映射增删改查方法

package com.bear.springboot.repository;
import com.bear.springboot.entities.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;
@Mapper
public interface UserMapper {
    int saveUser(User user);
    int updateUser(User user);
    int deleteUser(int id);
    List<User> findAllByUser();
}

@Mapper注解表示该接口是MyBatis中的Mapper。使用@Respository注解也可达到同样效果

• 编写sql映射的xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bear.springboot.repository.UserMapper">
    <insert id="saveUser" parameterType="com.bear.springboot.entities.User">
        insert into user(id,name,age,address,birth) values (#{id},#{name},#{age},#{address},#{birth});
    </insert>
    <update id="updateUser" parameterType="com.bear.springboot.entities.User">
        update user set name=#{name},age=#{age}, address=#{address}, birth=#{birth} where id=#{id};
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from user where id=#{id};
    </delete>
    <select id="findAllByUser" resultType="com.bear.springboot.entities.User">
        select * from user ;
    </select>
</mapper>

xml文件中的每个标签对应着增删改查的操作，标签体内则对应着对数据库进行操作的sql语句，#{}为占位符，用来获取实体类属性名对应数据库字段。

• 编写Controller

@GetMapping("/crud")
public void mybatisCrud() {
    User user = new User();
    user.setId("4");
    user.setName("tony");
    user.setAge("38");
    user.setAddress("China");
    user.setBirth(new Date());
    System.out.println("添加数据==>"+userMapper.saveUser(user));
    User user2 = new User();
    user2.setId("3");
    user2.setName("Bear");
    user2.setAge("20");
    user2.setAddress("China");
    user2.setBirth(new Date());
    System.out.println("修改数据==>"+userMapper.updateUser(user2));
    int result = userMapper.deleteUser(4);
    System.out.println("删除==>"+result);
    List<User> userList = userMapper.findAllByUser();
    userList.forEach((item -> {
        String value = item.toString();
        System.out.println("查询所有数据==>"+value);
    }));
}