SpringBoot

一.为什么要有 SpringBoot(SpringBoot的优点)

1)实现自动配置，不用配置大量的XML文件

2)创建项目时，可以选择需要的功能，SpringBoot将为你管理依赖关系

3)SpringBoot项目可以打包成jar包，使用java-jar命令运行将应用程序独立运行

4)内嵌Tomcat服务器(默认的，也可以使用Jetty或Undertow)

5)包括许多非功能特性，比如安全和健康检查

二.Spring Boot 支持哪些内嵌 Servlet 容器

Spring Boot支持Tomcat、Jetty和Undertow三种Servlet容器

三.如何在Spring Boot应用程序中使用Jetty而不是Tomcat

Spring Boot启动程序通常使用Tomcat作为默认的嵌入式服务器。如果需要更改可以排除Tomcat依赖项并改为包含Jetty或Undertow： 

< 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 >

SpringBoot2使用Jetty容器（替换默认Tomcat）_★【World Of Moshow 郑锴】★-CSDN博客_springboot使用jetty

四.什么是 Spring Boot Starters 

Starters可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，你可以一站式集成Spring及其他技术，而不需要到处找示例代码和依赖包。如你想使用SpringJPA访问数据库，只要加入spring-boot-starter-data-jpa 启动器依赖就能使用了。
Starters包含了许多项目中需要用到的依赖，它们能快速持续的运行，都是一系列得到支持的管理传递性依赖。

五.介绍一下@SpringBootApplication 注解

进入到@SpringBootApplication的源码，可以看到组合三个注解：@ComponentScan,@EnableAutoConfiguration,@SpringBootConfiguration.分析这三个注解． 

@ComponentScan

spring里有四大注解：@Service,@Repository,@Component,@Controller用来定义一个bean.@ComponentScan注解就是用来自动扫描被这些注解标识的类，最终生成ioc容器里的bean

@SpringBootConfiguration

这个注解的作用与@Configuration作用相同，都是用来声明当前类是一个配置类

@EnableAutoConfiguration

@EnableAutoConfiguration是springboot实现自动化配置的核心注解，通过这个注解把spring应用所需的bean注入容器中．@EnableAutoConfiguration源码通过@Import注入了一个ImportSelector的实现类AutoConfigurationImportSelector,这个ImportSelector最终实现根据我们的配置，动态加载所需的bean

@SpringBootApplication注解介绍_fenlin88l的博客-CSDN博客_springbootapplication的作用

六.开发RESTful Web服务常用的注解有哪些 

1)请求路径

@Path：用来标注资源类或者方法的URI路径，URI路径模板是URI语法中嵌入的变量的URI。这些变量在运行时被替换，以便资源对基于被替换的URI的请求作出响应，变量用花括号"{}"表示，如：@Path("/users/{username}")

URI路径模板还支持正则表达式，如：@Path("users/{username: [a-zA-Z][a-zA-Z_0-9]*}")

2)Http请求类型 

@GET，@PUT，@POST，@DELETE 

3)返回和接收的MIME媒体类型 

（1）@Produces：标注在资源类的方法上，表示返回的MIME媒体类型

如：@Produces(MediaType.APPLICATION_JSON)

（2）@Consumes：标注在资源类的方法上，表示可接受请求的MIME媒体类型

如：@Consumes(MediaType.APPLICATION_XML)

4)Http请求参数处理相关注解 

 1.@PathParam：绑定@path中的url参数到@PathParam标注的方法参数中

@Component
@Path("userMgr")
public class UserMgrResource {
    @GET
    @Path("/getUserById/{id}/{name}")
    public String getUserInfoId(@PathParam("id") int id,
                                @PathParam("name") String name) {
        return "Receive name is:" + name + ",id is:" + id;
    }
}

 URI Pattern : /userMgr/getUserById/100/lzm

2.@QueryParam：绑定Http请求参数到资源类的方法参数中

@GET
@Path("getUserByName")
public String getUserInfo(@QueryParam("name") String name) {
    return "Receive name is:" + name;
}

 URI Pattern : /userMgr/getUserByName?name=lzm

3.@HeaderParam： 绑定Http请求header头中的参数到资源类的方法参数中

@GET
@Path("getHeader")
public String getHeader(@HeaderParam(HttpHeaders.CONTENT_TYPE) String contentType) {
    return "Receive header contentType is:" + contentType;
}

 4.@CookieParam： 绑定Http请求的cookie参数到资源类的方法参数中

@GET
@Path("getCookie")
public String getCookie(@CookieParam("sessionId") String sessionId) {
    return "Receive header sessionId is:" + sessionId;
}

5.@MatrixParam： 绑定url中的参数到资源类的方法参数中，如：URL：/getMatrix;name=lzm，Matrix参数是name=feinik，在URL中以‘；’分割

@GET
@Path("getMatrix")
public String getMatrix(@MatrixParam("name") String name,
                        @MatrixParam("address") String address) {
    return "Receive name is:" + name + ", address is:" + address;
}

URI Pattern : /userMgr/getMatrix;name=lzm;address=北京

6.@FormParam： 绑定HTML中的表单参数到资源类的方法参数中

7.@Context：  注入辅助对象或信息对象，如 HttpServletRequest，ServletContext 等

七.Spirng Boot常用的两种配置文件 

在Spring Boot中，配置文件有两种不同的格式，一个是properties，另一个是yaml。properties文件比较常见相对于properties而言，yaml更加简洁明了，而且使用的场景也更多，很多的开源项目都是使用yaml进行配置。除了简洁，yaml还有另外一个特点，就是yaml中的数据是有序的，properties中的数据是无序的。在一些需要路径匹配的的配置中，顺序就显得尤为重要，此时我们一般采用yaml

八.什么是YAML？YAML配置的优势在哪里?

YAML 是一种人类可读的数据序列化语言。它通常用于配置文件。与属性文件相比，如果我们想要在配置文件中添加复杂的属性，YAML 文件就更加结构化，而且更少混淆。可以看出 YAML 具有分层配置数据

优势：

1. 配置有序，在一些特殊的场景下，配置有序很关键
2. 支持数组，数组中的元素可以是基本数据类型也可以是对象
3. 简洁

相比 properties 配置文件，YAML 还有一个缺点，就是不支持 @PropertySource 注解导入自定义的 YAML 配置 

九.Spring Boot常用的读取配置文件的方法有哪些

1.通过@Value来获取

application.properties 文件中先设置要读取的属性   

database.driverName=con.mysql.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/chapter3
database.username=root
database.password=123456

@Component
public class MyConf {
 
    @Value("${database.driverName}")     
    private String driverName;

    @Value("${database.url}")     
    private  String url;

    @Value("${database.username}")     
    private String username;

    @Value("${database.password}")  
    private String password;

}

 2.使用 @ConfigurationProperties,记得把之前@Vlaue  注释掉，直接使@ConfigurationProperties 注解配置前缀名即可

application.yml中配置信息

test:
  msg: lzm

@Component
@ConfigurationProperties("test")
public class MyConf {
 
        
    private String driverName;

       
    private  String url;

     
    private String username;

    
    private String password;

}

3.通过指定配置文件,@PropertySource可以声明多个。
或者使用@PropertySources(@PropertySource(“xxx”),@PropertySource(“xxx”))

只有properties可以使用这个注解，YAML和YML不能

@PropertySource(value = {"classpath:application.properties","classpath:jdbc.properties"})

十.Spring Boot加载配置文件的优先级

springboot启动会扫描一下位置的application.properties或者application.yml作为默认的配置文件
工程根目录:./config/
工程根目录：./
classpath:/config/
classpath:/
加载的优先级顺序是从上向下加载，并且所有的文件都会被加载，高优先级的内容会覆盖底优先级的内容 

十一.常用的Bean映射工具有哪些

 1)Dozer

Dozer 是一个映射框架，它使用递归将数据从一个对象复制到另一个对象。框架不仅能够在 bean 之间复制属性，还能够在不同类型之间自动转换

要使用 Dozer 框架，我们需要添加这样的依赖到我们的项目:

<dependency>
    <groupId>net.sf.dozer</groupId>
    <artifactId>dozer</artifactId>
    <version>5.5.1</version>
</dependency>

2)Orika

Orika 是一个 bean 到 bean 的映射框架，它递归地将数据从一个对象复制到另一个对象。

Orika 的工作原理与 Dozer 相似。两者之间的主要区别是 Orika 使用字节码生成。这允许以最小的开销生成更快的映射器。

要使用 Orika 框架，我们需要添加这样的依赖到我们的项目:

<dependency>
    <groupId>ma.glasnost.orika</groupId>
    <artifactId>orika-core</artifactId>
    <version>1.5.2</version>
</dependency>

 3)MapStruct

MapStruct 是一个自动生成 bean mapper 类的代码生成器。MapStruct 还能够在不同的数据类型之间进行转换

要使用 MapStruct 框架，我们需要添加这样的依赖到我们的项目:

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.2.0.Final</version>
</dependency>

 4)ModelMapper

ModelMapper 是一个旨在简化对象映射的框架，它根据约定确定对象之间的映射方式。它提供了类型安全的和重构安全的 API。

要使用 ModelMapper 框架，我们需要添加这样的依赖到我们的项目:

<dependency>
  <groupId>org.modelmapper</groupId>
  <artifactId>modelmapper</artifactId>
  <version>1.1.0</version>
</dependency>

 5)JMapper

JMapper 是一个映射框架，旨在提供易于使用的、高性能的 Java bean 之间的映射。该框架旨在使用注释和关系映射应用 DRY 原则。该框架允许不同的配置方式:基于注释、XML 或基于 api 

要使用 JMapper 框架，我们需要添加这样的依赖到我们的项目:

<dependency>
    <groupId>com.googlecode.jmapper-framework</groupId>
    <artifactId>jmapper-core</artifactId>
    <version>1.6.0.1</version>
</dependency>

 综合日常使用情况和相关测试数据，个人感觉 MapStruct、ModelMapper 这两个 Bean 映射框架是最佳选择

十二.Spring Boot 如何监控系统实际运行状况

1.Spring Boot 监控核心是 spring-boot-starter-actuator 依赖，增加依赖后， Spring Boot 会默认配置一些通用的监控，比如 jvm 监控、类加载、健康监控等 

入门使用：Actuator插件

Actuator插件是SpringBoot原生提供的一个服务，可以通过暴露端点路由，用来输出应用中的诸多 端点信息。实战一下！

pom.xml中添加依赖：

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

启动Spring Boot应用程序之后，只要在浏览器中输入端点信息就能获得应用的一些状态信息。

常用端点列举如下，可以一个个详细试一下：

• /info 　　　　　　　应用基本信息
• /health 　　　　　　健康度信息
• /metrics 　　　　　运行指标
• /env 　　　　　　　环境变量信息
• /loggers 　　　　　日志相关
• /dump 　　　　　　线程相关信息
• /trace 　　　　　　请求调用轨迹

当然此时只能使用/health 和 /info端点，其他因为权限问题无法访问。想访问指定端点的话可以在yml配置中添加相关的配置项，比如/metrics端点则需要配置：

endpoints:
 metrics:
 sensitive: false

 此时浏览器访问/metrics端点就能得到诸如下面所示的信息：

{
 "mem": 71529,
 "mem.free": 15073,
 "processors": 4,
 "instance.uptime": 6376,
 "uptime": 9447,
 "systemload.average": -1.0,
 "heap.committed": 48024,
 "heap.init": 16384,
 "heap.used": 32950,
 "heap": 506816,
 "nonheap.committed": 23840,
 "nonheap.init": 160,
 "nonheap.used": 23506,
 "nonheap": 0,
 "threads.peak": 25,
 "threads.daemon": 23,
 "threads.totalStarted": 28,
 "threads": 25,
 "classes": 6129,
 "classes.loaded": 6129,
 "classes.unloaded": 0,
 "gc.copy.count": 74,
 "gc.copy.time": 173,
 "gc.marksweepcompact.count": 3,
 "gc.marksweepcompact.time": 88,
 "httpsessions.max": -1,
 "httpsessions.active": 0
}

 2.Spring Boot Admin监控系统

SBA则是基于Actuator更加进化了一步，其是一个针对Actuator接口进行UI美化封装的监控工具。我们来实验一下。

Spring Boot Actuator提供了对单个Spring Boot的监控，信息包含：应用状态、内存、线程、堆栈等等，比较全面的监控了Spring Boot应用的整个生命周期。

但是这样监控也有一些问题：第一，所有的监控都需要调用固定的接口来查看，如果全面查看应用状态需要调用很多接口，并且接口返回的Json信息不方便运营人员理解；第二，如果Spring Boot应用集群非常大，每个应用都需要调用不同的接口来查看监控信息，操作非常繁琐低效。在这样的背景下，就诞生了另外一个开源软件：Spring Boot Admin。

什么是Spring Boot Admin?

Spring Boot Admin 是一个管理和监控Spring Boot 应用程序的开源软件。每个应用都认为是一个客户端，通过HTTP或者使用 Eureka注册到admin server中进行展示，Spring Boot Admin UI部分使用AngularJs将数据展示在前端。

Spring Boot Admin 是一个针对spring-boot的actuator接口进行UI美化封装的监控工具。他可以：在列表中浏览所有被监控spring-boot项目的基本信息，详细的Health信息、内存信息、JVM信息、垃圾回收信息、各种配置信息（比如数据源、缓存列表和命中率）等，还可以直接修改logger的level。

这篇文章给大家介绍如何使用Spring Boot Admin对Spring Boot应用进行监控。

十三.Spring Boot 如何做请求参数校验

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

import lombok.Data;
import lombok.ToString;

import javax.validation.constraints.Email;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;

@Data
@ToString
public class User {
    @NotEmpty(message = "姓名不能为空")
    private String username;

    @Min(value = 1 , message = "年龄不能小于1岁")
    @Max(value = 100 , message = "年龄不能大于100岁")
    private Integer age;

    @Email
    @NotEmpty(message = "邮箱不能为空")
    private String email;

    @NotEmpty(message = "地址不能为空")
    private String address;
}

定义一个controller来暴露接口 

@RestController
public class UserController {

    @PostMapping("/save")
    public Result save(@RequestBody @Validated User user) {
        return Result.success(user.toString());
    }
}

十四.Spring Boot 中如何实现定时任务？

在 Spring + SpringMVC 环境中，一般来说，要实现定时任务，我们有两中方案，一种是使用 Spring 自带的定时任务处理器 @Scheduled 注解，另一种就是使用第三方框架 Quartz ，Spring Boot 源自 Spring+SpringMVC ，因此天然具备这两个 Spring 中的定时任务实现策略，当然也支持 Quartz 

@Scheduled 注解

使用 @Scheduled 非常容易，直接创建一个 Spring Boot 项目，并且添加 web 依赖 spring-boot-starter-web，项目创建成功后，添加 @EnableScheduling 注解，开启定时任务 

@SpringBootApplication
@EnableScheduling
public class ScheduledApplication {

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

}

接下来配置定时任务：

    @Scheduled(fixedRate = 2000)
    public void fixedRate() {
        System.out.println("fixedRate>>>"+new Date());    
    }
    @Scheduled(fixedDelay = 2000)
    public void fixedDelay() {
        System.out.println("fixedDelay>>>"+new Date());
    }
    @Scheduled(initialDelay = 2000,fixedDelay = 2000)
    public void initialDelay() {
        System.out.println("initialDelay>>>"+new Date());
    }

1. 首先使用 @Scheduled 注解开启一个定时任务。
2. fixedRate 表示任务执行之间的时间间隔，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。
3. fixedDelay 表示任务执行之间的时间间隔，具体是指本次任务结束到下次任务开始之间的时间间隔。
4. initialDelay 表示首次任务启动的延迟时间。
5. 所有时间的单位都是毫秒。

Quartz

一般在项目中，除非定时任务涉及到的业务实在是太简单，使用 @Scheduled 注解来解决定时任务，否则大部分情况可能都是使用 Quartz 来做定时任务。在 Spring Boot 中使用 Quartz ，只需要在创建项目时，添加 Quartz 依赖即可：

项目创建完成后，也需要添加开启定时任务的注解： 

@SpringBootApplication
@EnableScheduling
public class QuartzApplication {
    public static void main(String[] args) {
        SpringApplication.run(QuartzApplication.class, args);
    }
}

十五.Spring Boot的自动配置是如何实现的

SpringBootApplication主要关注的几个注解如下
@SpringBootConfiguration：标记当前类为配置类
@EnableAutoConfiguration：开启自动配置
@ComponentScan：扫描主类所在的同级包以及下级包里的Bean

@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 {
...
}

关键是@EnableAutoConfiguration 

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
   String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
   Class<?>[] exclude() default {};
   String[] excludeName() default {};
}

最关键的要属@Import(EnableAutoConfigurationImportSelector.class)，借助EnableAutoConfigurationImportSelector，@EnableAutoConfiguration可以帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IoC容器，通过@Import(AutoConfigurationImportSelector.class)导入的配置功能，
AutoConfigurationImportSelector中的方法getCandidateConfigurations，得到待配置的class的类名集合,这个集合就是所有需要进行自动配置的类，能否自动配置的关键在于META-INF/spring.factories文件中是否存在该配置信息

  protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
            AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
                getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
        Assert.notEmpty(configurations,
                "No auto configuration classes found in META-INF/spring.factories. If you "
                        + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

打开，如下图可以看到所有需要配置的类全路径都在文件中，每行一个配置，多个类名逗号分隔,而\表示忽略换行

总结：mybatis-spring-boot-starter、spring-boot-starter-web等组件的META-INF文件下均含有spring.factories文件，自动配置模块中，SpringFactoriesLoader收集到文件中的类全名并返回一个类全名的数组，返回的类全名通过反射被实例化，就形成了具体的工厂实例，工厂实例来生成组件具体需要的bean。

 SpringBoot自动配置的原理及实现_牧竹子-CSDN博客_springboot自动配置的原理