【Spring Boot】简单入门

作者: abboo | 来源:发表于2020-11-14 08:21 被阅读0次

1. 概述

1.1 什么是Spring Boot

一般把Spring Boot称为搭建程序的脚手架或者说是便捷搭建基于Spring的工程脚手架。其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注，业务而非配置。

1.2 Spring Boot优点

java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时，可能Python程序员已经把功能写好了。

究其原因注意是两点：

复杂的配置
项目各种配置其实是开发时的损耗，因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。
混乱的依赖管理
项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。

Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。

我们可以使用Spring Boot创建java应用，并使用java –jar 启动它，就能得到一个生产级别的web工程。

1.3 Spring Boot

创建独立的Spring应用，为所有 Spring 的开发者提供一个非常快速的、广泛接受的入门体验
直接嵌入应用服务器，如tomcat、jetty、undertow等；不需要去部署war包
提供固定的启动器依赖去简化组件配置；实现开箱即用（启动器starter-其实就是Spring Boot提供的一个jar包），通过自己设置参数（.properties或.yml的配置文件），即可快速使用。
自动地配置Spring和其它有需要的第三方依赖
提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
绝对没有代码生成，也无需 XML 配置。（因为已经帮你写好了）

1.4 小结

Spring Boot是一个便捷搭建基于spring工程的脚手架；作用是帮助开发人员快速搭建大型的spring 项目。简化工程的配置，依赖管理；实现开发人员把时间都集中在业务开发上。

2. Spring Boot入门

2.1 创建一个maven新项目并添加依赖

    <!--添加父工程坐标 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.5.RELEASE</version>
    </parent>
    <!--添加web启动器 -->
   <dependencies>  
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>
    </dependencies>
    <!-- 管理jdk版本，不是必须-->
    <properties>
        <java.version>1.8</java.version>
    </properties>

Spring Boot提供了一个名为spring-boot-starter-parent的工程，里面已经对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标即可！
为了让Spring Boot帮我们完成各种自动配置，我们必须引入Spring Boot提供的自动配置依赖，我们称为启动器。因为我们是web项目，这里我们引入web启动器spring-boot-starter-web
需要注意的是，我们并没有在这里指定版本信息。因为Spring Boot的父工程已经对版本进行了管理了。
这个时候，我们会发现项目中多出了大量的依赖。
那些依赖都是Spring Boot根据 spring-boot-starter-web 这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。

2.2 新建application.java和controller

项目结构如下

注意：
稍后会提到Application.java是个启动类，名字不重要

启动类要controller上一级目录
因为controller目录跟启动类目录放在同一级，到时候url解析就会出现404错误了.

启动类加上@SpringBootApplication注解

/**
 * spring boot工程都有一个启动引导类，这是工程的入口类
 * 并在引导类上添加@SpringBootApplication
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

controller类

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        return String.format("Hello %s!", name);
    }
}

点开hello函数旁边的小按钮

跳转到

可以看到这个是我们的url地址

然后运行Application类的main函数，地址栏输入http://localhost:8080/hello

快到起飞！！

错误示例：启动类不在controller的上一级目录

实现步骤：

创建工程；
添加依赖（启动器依赖，spring-boot-starter-web）；
创建启动类；
创建处理器Controller；
测试

2.3小结：

Spring Boot工程可以通过添加启动器依赖和创建启动引导类实现快速创建web工程。

spring-boot-starter-web默认的应用服务器端口是8080

3. java配置应用

在入门案例中，我们没有任何的配置，就可以实现一个SpringMVC的项目了，快速、高效！
但是有同学会有疑问，如果没有任何的xml，那么我们如果要配置一个Bean该怎么办？比如我们要配置一个数据库连接池，以前会这么配置：

<!--    加载外部properties-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="DriverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

现在改怎么做呢
在这之前我们先了解一下Spring的配置历史

3.1 sping配置历史

事实上，在Spring3.0开始，Spring官方就已经开始推荐使用java配置来代替传统的xml配置了，我们不妨来回顾一下
Spring的历史：

Spring1.0时代
在此时因为jdk1.5刚刚出来，注解开发并未盛行，因此一切Spring配置都是xml格式，想象一下所有的bean都用xml配置，细思极恐啊，心疼那个时候的程序员2秒
Spring2.0时代
Spring引入了注解开发，但是因为并不完善，因此并未完全替代xml，此时的程序员往往是把xml与注解进行结合，貌似我们之前都是这种方式。
Spring3.0及以后
3.0以后Spring的注解已经非常完善了，因此Spring推荐大家使用完全的java配置来代替以前的xml，不过似乎在国内并未推广盛行。然后当Spring Boot来临，人们才慢慢认识到java配置的优雅。

3.2 尝试java配置（注解配置方式）

java配置主要靠java类和一些注解，比较常用的注解有：

@Configuration ：声明一个类作为配置类，代替xml文件
@Bean ：声明在方法上，将方法的返回值加入Bean容器，代替 <bean> 标签
@Value ：属性注入
@PropertySource ：指定外部属性文件，

我们接下来用java配置来尝试实现连接池配置：

1. 在 pom.xml 文件中添加Druid连接池依赖如下

    <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.1</version>
        </dependency>

2. 创建数据库 test 然后在resources下创建jdbc.properties

直接从以前的文件中复制粘贴

jdbc.driver = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

3. 编写 JdbcConfig.java 如下

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {

    @Value("${jdbc.driver}")
    String driver;

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

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

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

    @Bean
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setDriverClassName(driver);
        datasource.setUrl(url);
        datasource.setUsername(username);
        datasource.setPassword(password);
        return datasource;
    }
}

解读：

@Configuration ：声明我们 JdbcConfig 是一个配置类
@PropertySource ：指定属性文件的路径是: classpath:jdbc.properties
通过 @Value 为属性注入值
通过@Bean将 dataSource() 方法声明为一个注册Bean的方法，Spring会自动调用该方法，将方法的返回值加入Spring容器中。

然后我们就可以在任意位置通过 @Autowired 注入DataSource了！

4. 在 HelloController 中注入DataSource进行测试，改造代码如下

@RestController
public class HelloController {
    @Autowired
    private DataSource dataSource;

    @GetMapping("/hello")
    public String hello(@RequestParam(value = "name", defaultValue = "World") String name) {
        System.out.println("Datasource = "+dataSource);
        return String.format("Hello %s!", name);
    }
}

在print处打上断点，返回到Application.java，debug运行main函数

5. 目录结构

6. 小结

需求：使用Java代码配置数据库连接池，并可以在处理器中注入并使用

步骤：

添加依赖；
创建数据库；
创建数据库连接参数的配置文件jdbc.properties；
创建配置类；
改造处理器类注入数据源并使用

3.3 spring boot 属性注入方式

在上面的案例中，我们实验了java配置方式。不过属性注入使用的是@Value注解。这种方式虽然可行，但是不够强大，因为它只能注入基本类型值。而且很麻烦，一个项配置一次。很多次的cv操作真是有够烦的。

在Spring Boot中，提供了一种新的属性注入方式，支持各种java基本数据类型及复杂类型的注入。

需求：将配置文件中的配置项读取到一个对象中；

实现：可以使用Spring Boot提供的注解@ConfigurationProperties，该注解可以将Spring Boot的配置文件（默认必须为application.properties或application.yml）中的配置项读取到一个对象中。

1. 新建JdbcProperties.java ，用于进行属性注入

/**
 * ConfigurationProperties 从application配置文件中读取配置项
 * prefix 表示 配置项的前缀
 * 配置项类中的类变量名必须要与 前缀之后的配置项名称保持 松散绑定（相同）
 */
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProperties {

    private String driver;

    private String url;

    private String username;

    private String password;
}

解读

在类上通过@ConfigurationProperties注解声明当前类为属性读取类
prefix="jdbc" 读取属性文件中，前缀为jdbc的值。
在类上定义各个属性，名称必须与属性文件中 jdbc. 后面部分一致
需要注意的是，这里我们并没有指定属性文件的地址，所以我们需要把jdbc.properties名称改为 application.properties，这是Spring Boot默认读取的属性文件名：

此时会出现一个错误，下图中的红色背景标注

【注意】如果出现如下提示，项目也可以运行；

怎么消除？
如果要去掉上述的提示，则可以在 pom.xml 文件中添加如下依赖：

       <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <!--不传递依赖-->
            <optional>true</optional>
        </dependency>

此时还是会有红色波浪线，因为我们还没有将该注解作为spring的组件

在次提醒：修改jdbc.properties名为application.properties

2. 将 JdbcConfig 类原来全部注释掉或删除，修改为如下内容：

@Configuration
//@PropertySource("classpath:jdbc.properties")
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    public DataSource dataSource(JdbcProperties jdbcProperties) {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setDriverClassName(jdbcProperties.getDriver());
        datasource.setUrl(jdbcProperties.getUrl());
        datasource.setUsername(jdbcProperties.getUsername());
        datasource.setPassword(jdbcProperties.getPassword());
        return datasource;
    }
}

通过 @EnableConfigurationProperties(JdbcProperties.class) 来声明要使用 JdbcProperties 这个类的对象

然后要使用配置的话；可以通过以下方式注入JdbcProperties：

@Autowired注入

@Autowired private JdbcProperties prop;

构造函数注入

private JdbcProperties prop; 
public JdbcConfig(Jdbcproperties prop){ 
    this.prop = prop; 
}

声明有@Bean的方法参数注入

@Bean public Datasource dataSource(JdbcProperties prop){
     // ... 
}

本例中，我们采用第三种方式。

3. 测试结果；与前面的测试一样的

4. 小结

创建配置项类JdbcProperties类，在该类名上面添加@ConfigurationProperties；
将jdbc.properties修改名称为application.properties；
将JdbcProperties对象注入到JdbcConfig；
测试

目录结构

大家会觉得这种方式似乎更麻烦了，事实上这种方式有更强大的功能，也是Spring Boot推荐的注入方式。与@Value对比关系：

image.png

优势：

Relaxed binding：松散绑定
- 不严格要求属性文件中的属性名与成员变量名一致。支持驼峰，中划线，下划线等等转换，甚至支持对象引导。比如：user.friend.name：代表的是user对象中的friend属性中的name属性，显然friend也是对象。@value注解就难以完成这样的注入方式。
- meta-data support：元数据支持，帮助IDE生成属性提示（写开源框架会用到）。

3.4 更优雅的注入

事实上，如果一段属性只有一个Bean需要使用，我们无需将其注入到一个类（JdbcProperties，将该类上的所有注解去掉）中。而是直接在需要的地方声明即可；再次修改 JdbcConfig 类为如下代码：

@Configuration
//@PropertySource("classpath:jdbc.properties")
//@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    @Bean
    // 声明要注入的属性前缀，Spring Boot会自动把相关属性通过set方法注入到DataSource中
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource(JdbcProperties jdbcProperties) {
        return new DruidDataSource();
    }
}

再去JdbcProperties.java将注解注释掉

//@ConfigurationProperties(prefix = "jdbc")

我们直接把 @ConfigurationProperties(prefix = "jdbc") 声明在需要使用的 @Bean 的方法上，然后Spring Boot就会自动调用这个Bean（此处是DataSource）的set方法，然后完成注入。使用的前提是：该类必须有对应属性的set方法！

错误记录

debug启动类的时候报错，
Failed to bind properties under 'jdbc.driver' to java.sql.Driver:
解决方法: 将application.properties中的driver改为driverClassName，同时修改JdbcProperties.java的变量driver为driverClassName,运行成功！

3.5 yaml配置文件

配置文件除了可以使用application.properties类型，还可以使用后缀名为：.yml或者.yaml的类型，也就是：application.yml或者application.yaml
docker也使用这种格式的文件进行配置

基本格式：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/test
  username: root
  password: root

把application.properties修改为application.yml进行测试。

只是改了文件名，但是文件内容仍然是

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=root

仍然成功运行！

yaml与properties配置文件除了展示形式不相同以外，其它功能和作用都是一样的；在项目中原路的读取方式不需要改变。

yml配置文件的特征：

树状层级结构展示配置项；
配置项之间如果有关系的话需要分行空两格；
配置项如果有值的话，那么需要在 :之后空一格再写配置项值；

将application.properties配置文件修改为application.yml的话：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/test
  username: root
  password: root

key:
  abc: cba
  def:
    - g
    - h
    - j

如果两个配置文件都有，会把两个文件的配置合并，如果有重复属性，以properties中的为准。
如果是配置数组、list、set等结构的内容，那么在yml文件中格式为：
key:
- value1
- value2

3.6 多个yaml配置文件

多个yml配置文件；在spring boot中是被允许的。这些配置文件的名称必须为application-***.yml，并且这些配置文件必须要在application.yml配置文件中激活之后才可以使用。

如果properties和yml配置文件同时存在在spring boot项目中；那么这两类配置文件都有效。在两个配置文件中如果存在同名的配置项的话会以properties文件的为主。

创建 application-github.yml 文件如下：

gitbug404:
  url: https://github.com/gitbug404

创建 application-jianshu.yml 文件如下：

abboo:
  url: https://www.jianshu.com/u/bb5286ec0fe5

在 application.yml 文件中添加如下配置：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/test
  username: root
  password: root

#激活配置文件；需要制定其他的配置文件名称
spring:
  profiles:
    active: github,jianshu

修改HelloController.java

多个文件名只需要写application-之后的名称，在多个文件之间使用,隔开。

小结

在多个配置文件时，需要将这些文件在application.yml文件中进行激活：

#激活配置文件;需要指定其它的配置文件名称
spring:
  profiles:
    active: github,jianshu

4. 自动配置原理

使用Spring Boot之后，一个整合了SpringMVC的WEB工程开发，变的无比简单，那些繁杂的配置都消失不见了，这是如何做到的？
一切魔力的开始，都是从我们的main函数来的，所以我们再次来看下启动类：

image.png

我们发现特别的地方有两个：

注解：@SpringBootApplication
run方法：SpringApplication.run()

我们分别来研究这两个部分。

4.1 了解@SpringBootApplication

点击进入，查看源码：

这里重点的注解有3个：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

4.1.1 @SpringBootConfiguration

我们继续点击查看源码

通过这段我们可以看出，在这个注解上面，又有一个 @Configuration 注解。通过上面的注释阅读我们知道：这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了 @Configuration 的类，并且读取其中的配置信息。而 @SpringBootConfiguration 是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般我们无需自己添加。

4.1.2 @EnableAutoConfiguration

关于这个注解，官网上有一段说明：

The second class-level annotation is @EnableAutoConfiguration . This annotation tells Spring Boot to “guess” how you want to configure Spring, based on the jar dependencies that you have added. Since spring-boot-starter-web added Tomcat and Spring MVC, the auto-configuration assumes that you are developing a web application and sets up Spring accordingly.

简单翻译一下：

第二级的注解 @EnableAutoConfiguration ，告诉Spring Boot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入了 spring-boot-starter-web ，而这个启动器中帮我们添加了 tomcat 、 SpringMVC的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成了web及SpringMVC的默认配置了！

总结，Spring Boot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效。

所以，我们使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了。除非你不希望使用SpringBoot的默认配置，它也提供了自定义配置的入口。

4.1.3 @ComponentScan

大概的意思：

配置组件扫描的指令。提供了类似与 <context:component-scan> 标签的作用
通过basePackageClasses或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包

而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中。

4.2 默认配置原理

4.2.1 spring.factories

在SpringApplication类构建的时候，有这样一段初始化代码：

跟进去：

这里发现会通过loadFactoryNames尝试加载一些FactoryName，然后利用createSpringFactoriesInstances将这些加载到的类名进行实例化。
继续跟进loadFactoryNames方法：

发现此处会利用类加载器加载某个文件： FACTORIES_RESOURCE_LOCATION ，然后解析其内容。我们找到这个变量的声明：

可以发现，其地址是： META-INF/spring.factories ，我们知道，ClassLoader默认是从classpath下读取文件，因此，SpringBoot会在初始化的时候，加载所有classpath:META-INF/spring.factories文件，包括jar包当中的。

而在Spring的一个依赖包：spring-boot-autoconfigure中，就有这样的文件：
连按两下Shift键搜索spring.factories

以后我们引入的任何第三方启动器，只要实现自动配置，也都会有类似文件。

记住这个依赖包spring-boot-autoconfigure，大有用处！！！

4.2.2 默认配置类

我们打开刚才的spring.factories文件：

可以发现以EnableAutoConfiguration接口为key的一系列配置，key所对应的值，就是所有的自动配置类，可以在当前的jar包中找到这些自动配置类：

非常多，几乎涵盖了现在主流的开源框架，例如：
redis

jms
amqp
jdbc
jackson
mongodb
jpa
solr
elasticsearch
... 等等
我们来看一个我们熟悉的，例如SpringMVC，查看mvc 的自动配置类：

打开WebMvcAutoConfiguration

我们看到这个类上的4个注解：

@Configuration ：声明这个类是一个配置类
@ConditionalOnWebApplication(type = Type.SERVLET)
ConditionalOn，翻译就是在某个条件下，此处就是满足项目的类是是Type.SERVLET类型，也就是一个普通web工程，显然我们就是
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
这里的条件是OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer，其中Servlet只要引入了tomcat依赖自然会有，后两个需要引入SpringMVC才会有。这里就是判断你是否引入了相关依赖，引入依赖后该条件成立，当前类的配置才会生效！
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
这个条件与上面不同，OnMissingBean，是说环境中没有指定的Bean这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个WebMVCConfigurationSupport的类，那么这个默认配置就会失效！
接着，我们查看该类中定义了什么：
视图解析器(viewer)：

处理器适配器（HandlerAdapter）：

这个之前都用到过。
还有很多很多。。。

4.2.3 默认配置属性

另外，这些默认配置的属性来自哪里呢？

我们看到，这里通过@EnableAutoConfiguration注解引入了两个属性：WebMvcProperties和ResourceProperties。这不正是SpringBoot的属性注入玩法嘛。
我们查看这两个属性类：
先看WebMvcProperties

WebMvcProperties

WebMvcProperties的View

找到了内部资源视图解析器的prefix和suffix属性。

而ResourceProperties中主要定义了静态资源（.js,.html,.css等)的路径：

可以看到，classpath有这么多个，spring boot加载资源文件会从这些文件夹找，一般我们把css/html之类的文件都放在static里面。
如果我们要覆盖这些默认属性，只需要在application.properties中定义与其前缀prefix和字段名一致的属性即可。

4.3 小结

如果有一天，我们遇到个没学过的框架，而这个框架整合到了sprinig boot，怎么去取做？一般而言，我们使用框架，只需要修改配置就好了，那怎么知道配置项呢，当我们遇到需要修改的组件的配置项流程为：

以redis为例
idea中打开autoconfigure这个包，找到data->redis->RedisProperties

反正找到Properties结尾的类可以看到以下

这些就是配置参数，我们要修改，就在配置文件（properties或者yml）修改就好了，我们看到这个prefix关键字，我们要修改url就如

spring.redis.url = xxx

总结

SpringBoot为我们提供了默认配置，而默认配置生效的步骤：

@EnableAutoConfiguration注解会去寻找 META-INF/spring.factories 文件，读取其中以EnableAutoConfiguration 为key的所有类的名称，这些类就是提前写好的自动配置类
这些类都声明了 @Configuration 注解，并且通过 @Bean 注解提前配置了我们所需要的一切实例
但是，这些配置不一定生效，因为有 @ConditionalOn 注解，满足一定条件才会生效。比如条件之一：是一些相关的类要存在类要存在，我们只需要引入了相关依赖（启动器），依赖有了条件成立，自动配置生效。
如果我们自己配置了相关Bean，那么会覆盖默认的自动配置的Bean
我们还可以通过配置application.yml文件，来覆盖自动配置中的属性

1）启动器
所以，我们如果不想配置，只需要引入依赖即可，而依赖版本我们也不用操心，因为只要引入了SpringBoot提供的stater（启动器），就会自动管理依赖及版本了。
因此，玩SpringBoot的第一件事情，就是找启动器，SpringBoot提供了大量的默认启动器
2）全局配置
另外，SpringBoot的默认配置，都会读取默认属性，而这些属性可以通过自定义 application.properties 文件来进行覆盖。这样虽然使用的还是默认配置，但是配置中的值改成了我们自定义的。
因此，玩SpringBoot的第二件事情，就是通过 application.properties 来覆盖默认属性值，形成自定义配置。我们需要知道SpringBoot的默认属性key，非常多，可以再idea中自动提示

属性文件支持两种格式，application.properties和application.yml

如果properties和yml文件都存在，如果有重叠属性，默认以Properties优先。