Spring Boot详解 SpringBoot基本应用： 约定优于配置：

上面是引自官网的一段话，大概是说： Spring Boot 是所有基于 Spring 开发的项目的起点 Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件 约定优于配置（Convention over Configuration），又称按约定编程，是一种软件设计范式 本质上是说，系统、类库或框架应该假定合理的默认值（之所以是假定，是因为可以不一样），而非要求提供不必要的配置 比如说模型中有 一个名为User的类，那么数据库中对应的表一般就会默认命名为user 虽然可以不同，如对mybatis中只是字段值操作 只有在偏离这一个约定的时候，例如 想要将该表命名为person，才需要写有关这个名字的配置 当然并不是一定要写（如mybatis的类） 比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求进 行开发编码测试之类的 这样就加强了开发效率与审查代码效率 所以说写代码的时候就需要按要求命 名，这样统一规范的代码就有良好的可读性与维护性了 约定优于配置简单来理解，就是遵循约定 SpringBoot概念： Spring优缺点分析： 优点： Spring是Java企业版（Java Enterprise Edition， JEE，也称J2EE）的轻量级代替品，无需开发重量级的 Enterprise Java Bean（EJB）， Spring为企业级Java开发提供了一种相对简单的方法 通过依赖注入和 面向切面编程，用简单的Java对象（Plain Old Java Object， POJO）实现了EJB的功能 缺点： 虽然Spring的组件代码是轻量级的，但它的配置却是重量级的 一开始， Spring用XML配置，而且是很 多XML配 置 Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置 Spring 3.0引入 了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML 所有这些配置都代表了开发时的损耗，因为在思考Spring特性配置和解决业务问题之间需要进行思维切 换 所以编写配置挤占了编写应用程序逻辑的时间，和所有框架一样， Spring实用，但与此同时它要求 的回报也不少 除此之外，项目的依赖管理也是一件耗时耗力的事情，在环境搭建时，需要分析要导入哪些库的坐标 而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本 随之而来的不兼容问题 就会严重阻碍项目的开发进度 SSM整合： Spring、 Spring MVC、 Mybatis、 Spring-Mybatis整合包、数据库驱动，引入依赖的数量繁多、容易存在版本冲突 Spring Boot解决上述spring问题： SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想 可以让开发人员不必在 配置与逻辑 业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中 从而大大提高了开发的 效率，一定程度上缩短 了项目周期 起步依赖 ： 起步依赖本质上是一个Maven项目对象模型(Project Object Model， POM)，定义了对其他库的传递依 赖 这些东西加在一起即支持某项功能 简单的说，起步依赖就是将具备某种功能的依赖坐标打包到一起，并提供一些默认的功能 自动配置： springboot的自动配置，指的是springboot会自动将一些配置类的bean注册进ioc容器 我们可以需 要的地方使用@autowired或者@resource等注解来使用它 "自动"的表现形式就是我们只需要引我们想用功能的包，相关的配置我们完全不用管 springboot会自 动注入这些配置bean，我们直接使用这些bean即可 springboot：简单、快速、方便地搭建项目 对主流开发框架的无配置集成，极大提高了开发、部署效率 Spring Boot入门案例 ： spring的官网：https://spring.io 要学习新的技术，最好是去官网里进行学习 案例需求：请求Controller中的方法，并将返回值响应到页面 依赖管理：

    4.0.0

    com.lagou
    springbootdemo1
    1.0-SNAPSHOT

    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.7.2
    
    
        
        
            org.springframework.boot
            spring-boot-starter-web
            
        
    

    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

启动类操作：

对应的HelloController：

package com.lagou.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("hello")
public class HelloController {


    @RequestMapping("/boot")
    public String helloBoot() {
        return "Hello Spring Boot";
    }

}

真正的启动类：

package com.lagou;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;



//@SpringBootApplication该注解标识当前类为SpringBoot的启动类
//这时，springboot扫描项目时（先进行扫描，后进行启动，这个扫描只找@SpringBootApplication该注解）
//找到该注解，并可以得到对应的包路径
//就会扫描其包及其子包下的其他内容（这个扫描是扫描spring注解的）
@SpringBootApplication
public class SpringBootDome1Application {

    //由于这个是启动类，那么这个main方法，就会进行启动，实际上就是启动这个类，使得启动main方法的
    //就如命令启动一样，使用java 类名启动时，会执行main方法，所有可以说成手动或者自动的执行启动命令
    //一般打包后就是自动
    //自动的是找到该@SpringBootApplication注解，执行该类，然后启动springboot，然后他在找这个注解
    //手动少了前面的执行该类以及找注解
    public static void main(String[] args) {
        //样板代码
        //你只是定义注解并可以操作找到启动类的路径，但是springboot并没有真正的执行
        //也就是说，该注解并没有起作用
        //需要使用这个方法才可，并传入启动类的字节码文件，及其对应main方法的参数
        //执行后springboot会找到帮助@SpringBootApplication注解
        //并根据该注解进行扫描他的包及其子包
        //那么springboot就会使得帮我们准备所有的环境，包括server，监听器，装配spring的上下文等等
        SpringApplication.run(SpringBootDome1Application.class,args);

    }
}

至此，我们手动执行main方法，执行后，访问http://localhost:8080/hello/boot，发现返回了数据，那么操作成功 我们可以看到，若是以前，我们需要web.xml中的前端控制器，而这里他帮我们配置好了 因为无论是web.xml的操作还是这里，总体来说都是操作类 只是以前的jar包操作不了web.xml而已（因为他在web项目对应的文件夹下），而只有资源文件夹下的才可以操作 其他的基本直接忽略，如java文件夹下，若有xml文件，直接忽略，即其他的基本只能存放java类（资源文件夹下除外） 即springboot的确帮我们进行了配置，即操作了自动配置 接下来在知道他自动配置的情况下，若没扫描是如何：

将包路径改变，使得扫描不了其他spring注解，再次启动，发现，访问时，没有对应的网页

所以，虽然他帮我们进行了配置，但也要有扫描，否则对应的注解是不会起作用的，自然也找不到网页 所有至此，他的自动配置和扫描都操作完毕，且也确实如此 由原来的web.xml以及其他spring配置文件的操作，实现的类的操作，都由springboot来进行操作，使得对应类也操作 从而与war包启动一样，jar的启动也可以操作前端请求了 当然，由于启动类操作的是8080端口，那么再次启动其他启动类时或者本身（不同包也是如此） 基本都会提示关闭之前的启动类或者启动失败，虽然一样的类名会自动在后面加上别名，如"(1)"，从1开始，然后是2，以此类推 一般后启动的相同名称则会加上对应的别名，具体看右上角的运行名称 如果我们在启动后，且访问了，再次将他关闭会怎么样： 会访问失败，虽然他自动配置了，但是却需要服务器来操作我们的访问，就如war包一样，虽然有配置，但需要服务器来操作请求 即这里springboot可以看成他本身也是操作服务器的 即他虽然自动进行配置且扫描，但对应的项目是在他身上运行的（服务器） 若关闭他，那么相当于会关闭服务器，实际上也会使得全部都没有了，即访问失败 至此，入门的第一个案例操作成功 SpringBoot 快速构建： 案例需求：请求Controller中的方法，并将返回值响应到页面 使用Spring Initializr方式构建Spring Boot项目 ： 本质上说， Spring Initializr是一个Web应用，它提供了一个基本的项目结构，能够帮助我们快速构 建一个基础的Spring Boot项目

新的版本的idea一般会显示如下：

对应的地址直接写在了最上面 Project SDK（上面就是Module SDK）用于设置创建项目使用的JDK版本，这里，使用之前初始化设置好的JDK版本即可 在Choose Initializr Service URL（选择初始化服务地址）下使用默认的初始化服务地址"https://start.spring.io" 进行Spring Boot项目创建（注意使用快速方式创建Spring Boot项目时，所在主机须在联网状态下） 当然下面的是老版本的idea，但总体的流程都是差不多的

Spring Boot项目就创建好了，创建好的Spring Boot项目结构如图：

使用Spring Initializr方式构建的Spring Boot项目会默认生成项目启动类，存放前端静态资源和页面的文件夹 编写项目配置的配置文件以及进行项目单元测试的测试类 实际上我们只需要保留src里面的main和test包（包括两者里面的内容）即可 其他的基本都可以删除（但也要注意，一般情况下会出现iml文件，最好不要删除），子项目（模块）一般不会出现 比如我的：

创建一个用于Web访问的Controller ： com.lagou包下创建名称为controller的包，在该包下创建一个请求处理控制类HelloController 并编写一个请求处理方法 （注意：将项目启动类SpringBootDemoApplication移动到com.lagou包下）

package com.lagou.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("hello")
public class HelloController {


    @RequestMapping("/boot")
    public String helloBoot() {
        return "Hello Spring Boot";
    }

}

再次启动对应的启动类，访问，若要数据返回，则操作成功 实际上他默认的是8080端口，但我们可以进行修改，找到配置文件application.properties： 添加如下内容：

server.port=8888

再次启动，查看启动日志，发现，端口改变了（springboot操作的服务器端口改变） 访问http://localhost:8888/hello/boot，若有数据，则的确改变了 实际上就算使用对应的插件来打包操作web项目也是需要对应类的操作，即需要web.xml，那么也要上war包才可 而springboot则只需要jar包就可以了，这里他启动时并没有打包到maven里面 因为我们是直接的执行（target包下有对应的class，及其资源文件） 单元测试与热部署 ： 单元测试 ： 开发中，每当完成一个功能接口或业务方法的编写后，通常都会借助单元测试验证该功能是否正确 Spring Boot对项目的单元测试提供了很好的支持 在使用时，需要提前在项目的pom.xml文件中添加spring-boot-starter-test测试依赖启动器 快速构建springboot项目一般会加上该依赖 即使用Spring Initializr方式搭建的Spring Boot项目，会自动加入spring-boot-starter-test测试依赖启动器，无需再手动添加 然后可以通过相关注解实现单元测试 演示： 添加spring-boot-starter-test测试依赖启动器： 在项目的pom.xml文件中添加spring-boot-starter-test测试依赖启动器，示例代码如下 ：

 
     
            org.springframework.boot
            spring-boot-starter-test
            test
        
  
      
            junit
            junit
            test
        

对应测试的启动类Springbootdome2ApplicationTests：

package com.lagou;

import com.lagou.controller.HelloController;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.junit4.SpringRunner;

//RunWith：运行器，参数一般指定的是测试环境，在什么项目下
//一般需要指定对应项目的运行环境（环境对应的操作不匹配，会报错），如spring需要读取配置类或者配置文件等等
//否则一般默认的是JUnit4.class，即可以不写@RunWith(JUnit4.class)，虽然写了也没有问题
//若操作junit，则是junit环境
//@RunWith(JUnit4.class)
//一般spring操作时需要SpringJUnit4ClassRunner.class，因为spring整合junit的依赖，即spring-test依赖
//这个依赖spring-boot-starter-test里面有，所有直接写上即可
//@RunWith(SpringJUnit4ClassRunner.class)
//若要使用springboot项目的测试，一般需要springboot的测试环境，也在对应的spring-test依赖里面
//所有直接写即可
@RunWith(SpringRunner.class)
//标记当前类为SpringBoot测试类，会加载得到项目的ApplicationContext上下文环境（相当于会执行启动类）
@SpringBootTest
class Springbootdome2ApplicationTests {

    

    //springboot帮我们扫描了
    @Autowired
    private HelloController helloController;

    @Test
    public void contextLoads() {
        String s = helloController.helloBoot();
        System.out.println(s); //Hello Spring Boot
    }


    //上面的操作，可以想象成一个springmvc的项目，我们扫描后，进行注入，然后操作，只是这里并没有指定配置文件
    //因为@SpringBootTest操作了对应的扫描的结果
    //一般项目启动时对应的扫描的结果一般放在全局的servletContext里面，使得被操作
    //即ApplicationContext对象被操作，但这里他正好直接加载，而不从全局取出，实际上该对象就是对应的如类似于
    
    //得到classPathXmlApplicationContext的值，即ApplicationContext对象
    //一般只要操作对应的配置即可，无论web项目还是springboot项目


}

启动后，执行方法，若返回正确的数据，则操作成功 热部署： 在开发过程中，通常会对一段业务代码不断地修改测试，在修改之后往往需要重启服务，有些服务需要加载很久才能启动成功 这种不必要的重复操作极大的降低了程序开发效率 为此， Spring Boot框架专门提供了进行热部署的依赖启动器，用于进行项目热部署 而无需手动重启项目（也就是重新执行启动类，或者说重新执行启动类的main方法） 简单来说，热部署就是：在修改完代码之后（无论是配置文件还是类，基本只要是项目的进行了修改就会更新） 不需要重新启动容器，就可以实现更新，但是需要等待他更新 等日志出现，那么才会真正的部署，中途再次改变，会影响日志的出现 一般会迟一点，因为有缓冲等待（大概等几秒才更新），防止你频繁的更新（每次的改变，基本会重置该等待） 使用步骤： 1：添加SpringBoot的热部署依赖启动器 2：开启Idea的自动编译 3：开启Idea的在项目运行中自动编译的功能 添加spring-boot-devtools热部署依赖启动器： 在Spring Boot项目进行热部署测试之前，需要先在项目的pom.xml文件中添加spring-boot-devtools热部署依赖启动器:

    
        
            org.springframework.boot
            spring-boot-devtools
        

由于使用的是IDEA开发工具，添加热部署依赖后可能没有任何效果，接下来还需要针对IDEA开发工具进行热部署相关的功能设置 IDEA工具热部署设置： 选择IDEA工具界面的【File】 ->【Settings】选项，打开Compiler面板设置页面

选择Build下的Compiler选项，在右侧勾选"Build project automatically"选项将项目设置为自动编译 但有时候我们的启动一般都会去编译，所以他一般用在热部署 单击【Apply】→【OK】按钮保存设置 在项目任意页面中使用组合快捷键"Ctrl+Shift+Alt+/"打开Maintenance选项框，选中并打开Registry页面：

列表中找到"compiler.automake.allow.when.app.running"，将该选项后的Value值勾选 用于指定IDEA工具在程序运行过程中自动编译，最后单击【Close】按钮完成设置 注意：在高版本的idea，可能找不到这个选项，那是因为对应的选项不在这里，在如下：

点击这个使得变成勾勾即可 总体来说，就是打开自动编译，并使得可以在项目运行时自动编译，而对应的依赖使得进行更新（修改的部分） 热部署效果测试： 执行http://localhost:8888/hello/boot，一般页面返回是

修改对应的类： 页面原始输出的内容是"Hello Spring Boot" 为了测试配置的热部署是否有效，接下来，在不关闭当前项目的情况下 将HelloController类中的请求处理方法helloBoot()进行改变，如下：

package com.lagou.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("hello")
public class HelloController {


    @RequestMapping("/boot")
    public String helloBoot() {
        return "Hello Spring Boot 哈哈哈"; //修改成这个
    }

}

查看控制台信息会发现项目能够自动构建和编译（一般需要等待一会，就会出现对应的日志），说明项目热部署生效 接着访问如下：

可以看出，浏览器输出了"Hello Spring Boot 哈哈哈"，说明项目热部署配置成功 可以试着将上面三个步骤随便取消一个，一般都不会进行更新，所以这三个步骤必须要，才基本可以热部署 实际上热部署就是自动的部署，因为我们需要改变内存里的内容，一般我们都是手动的重新部署的 实际上对于浏览器来说可能会有缓存，为了避免浏览器的缓存 我们会使用ctrl+f5进行强制刷新（不使用缓存的刷新，笔记本一般需要加上fn，且对应的浏览器有这个功能才可） 全局配置文件 ： 全局配置文件能够对一些默认配置值进行修改 Spring Boot使用一个application.properties或者application.yaml的文件作为全局配置文件 该文件存放在src/main/resource目录或者类路径的/config，一般会选择resource目录 接下来，将针对这两种全局配置文件进行讲解 ： Spring Boot配置文件的命名及其格式： application.properties，application.yaml，application.yml（前面一个的简写，相当于是一样的） application.properties配置文件 ： 使用Spring Initializr方式构建Spring Boot项目时，会在resource目录下自动生成一个空的application.properties文件 Spring Boot项目启动时会自动加载application.properties文件 我们可以在application.properties文件中定义Spring Boot项目的相关属性 当然，这些相关属性可以是系统属性、环境变量、命令参数等等信息，也可以是自定义配置文件名称和位置 比如：

#修改tomcat的端口号（有些时候也可以说是版本号）
server.port=8888
#定义数据库的连接信息  JdbcTemplate
#mysql-connector-java中5的版本就不加cj，6的版本需要加（高的版本一般也要加）
#这里是6.0.6的版本，所以需要加，因为版本不同，类结构可能也是不同的，不加的话，可能会报错
#由于这是全局配置，spring boot在操作对应的数据库信息时，会使用下面这些参数当成对应数据库信息的参数
#然后自动配置，若没有，则一般使用默认的值（只有用户名和密码有默认值，前面两个必须写，否则一般会报错）
#这个报错会使得访问不了，即后面的springmvc的操作停止，相当于没有自动配置了

#注意：
#spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#后面不能有空格，否则报错，这是一个特殊的地方，当然可以不写，会根据驱动默认加上的
#其他的基本都可以有空格（且空格无影响，相当于没有什么，基本不会参与到数值里面去）
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/lagou
spring.datasource.username=root
spring.datasource.password=123456

操作了对应的数据库，那么一般需要对应的驱动包 spring boot的依赖中并不是所有的包都有传递，有些需要自己加上，如这个驱动包：

 
            mysql
            mysql-connector-java
            6.0.6 
     
        

还需要如下的包：

  
            org.springframework.boot
            spring-boot-starter-jdbc
            2.7.1
      
        

至此我们可以操作如下：

package com.lagou.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("hello")
public class HelloController {


    @RequestMapping("/boot")
    public String helloBoot() {
        return "Hello Spring Boot 哈哈哈";
    }

    @Autowired
    private JdbcTemplate jdbcTemplate; //可能会报红，但这时idea检查的操作，运行时不会出错的

    @RequestMapping("/jdbc")
    public String jdbc(){
        return jdbcTemplate.toString();
        //org.springframework.jdbc.core.JdbcTemplate@239a95aa（我这里是，不同的执行结果一般是不同的）
        //就如创建对象的地址，再次创建时，对应的地址值基本也是不一样的
        //除了自带的，如String，如相同取一个地址
        //还有对应规定的，如数组，如基本第一（几）个类型的数组地址是固定
    }
}

进行访问，若有对应的数据，那么注入完成，即操作完成 接下来，通过一个案例对Spring Boot项目中application.properties配置文件的具体使用进行讲解 演示： 预先准备了两个实体类文件，后续会演示将application.properties配置文件中的自定义配置属性注入到Person实体类的对应属性中 先在项目（快速构建的那个项目）的com.lagou包下创建一个pojo包，并在该包下创建两个实体类Pet和Person：

package com.lagou.pojo;


public class Pet {
    private String type; //品种
    private String name; //名称

    @Override
    public String toString() {
        return "Pet{" +
                "type='" + type + ''' +
                ", name='" + name + ''' +
                '}';
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.lagou.pojo;

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

import java.util.Arrays;
import java.util.List;
import java.util.Map;


@Component //记得要被spring boot扫描到
//将配置文件中所有以person开头的配置信息注入到当前类中
//前提1：必须保证配置文件中person.xxx的xxx要与Person类的setxxx中的xxx一致（首字母可以忽略大小写）
//前提2：必须保证当前Person中的属性都具有set方法，因为是使用setxxx方法进行注入的
//若没有，如没有满足对应的存在（首字母可以忽略大小写，则代表没有，那么会报错）
@ConfigurationProperties(prefix = "person")
public class Person {

    private int id; //id
    private String name; //名称
    private List hobby; //爱好
    private String[] family; //家庭成员
    private Map map;
    private Pet pet; //宠物
    
    
    

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + ''' +
                ", hobby=" + hobby +
                ", family=" + Arrays.toString(family) +
                ", map=" + map +
                ", pet=" + pet +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List getHobby() {
        return hobby;
    }

    public void setHobby(List hobby) {
        this.hobby = hobby;
    }

    public String[] getFamily() {
        return family;
    }

    public void setFamily(String[] family) {
        this.family = family;
    }

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Pet getPet() {
        return pet;
    }

    public void setPet(Pet pet) {
        this.pet = pet;
    }
}

@ConfigurationProperties(prefix = “person”)注解的作用： 将配置文件中以person开头的属性值通过setXX()方法注入到实体类对应属性中 @Component注解的作用是将当前注入属性值的Person类对象作为Bean组件放到Spring容器中 只有这样才能被@ConfigurationProperties注解进行赋值，就如@Value一样需要对应的实例 但是若@ConfigurationProperties注解和@Value共存，那么@ConfigurationProperties注解会覆盖@Value注解的操作 若@Value注解报错，那么启动基本就会报错，使得访问不了 打开项目的resources目录下的application.properties配置文件，在该配置文件中编写需要对Person类设置的配置属性

#自定义配置信息注入到Person对象中
person.id=100
person.name=哈哈
#list
person.hobby=喝水，吃早餐 
#String[]
person.family=儿子，老婆
#集合和对象，一般都需要多一个层（多了.）
#Map
person.map.k1=v1
person.map.k2=v2
#Pet对象
person.pet.type=狗
person.pet.name=旺财
#他们可以使用@Value注解来进行注入（对应的参数获取），因为他们是全局的

查看application.properties配置文件是否正确，同时查看属性配置效果 打开通过IDEA工具创建的项目测试类，在该测试类中引入Person实体类Bean，并进行输出测试

 @Autowired
    private Person person;

    @Test
    public void configurationTest(){
        System.out.println(person);
        
    }

若返回数据则代表注入成功，即操作成功 但是这里可能会出现乱码问题，因为properties对应操作特殊字符时（如中文）时 不会使用设置的编码，而是使用ISO 8859-1来解码，这就导致了无论你怎么设置编码（在能操作中文的编码的情况下） 对应的基本都是乱码，因为我们编码的一般不可能是ISO 8859-1，因为要操作中文，他基本不能解析该中文 那么对应编码也是有问题的（就算是同样的该编码，可能也是乱码） 那么如何不让他进行默认的ISO 8859-1来解码呢，点击如下：

只要右边的勾勾，勾上了即可，代表操作我们的格式，因为对应的编码一般从全局得到，左边的一般是显示的文件编码 好像并不会参与程序里面的编码，只是用来看的，最好其他的配置都是UTF-8，以防万一

至此我们可以在对应的HelloController类里加上如下代码：

 @Autowired
    private Person person;

    @RequestMapping("person")
    public String showPerson(){
        return person.toString();
    }

至此我们再次观看对应的返回数据，若有，则代表真正的操作成功 但是这时可能也有乱码，一般是tomcat和对应的http编码，可以加上如下代码：

#解决中文乱码
#server.tomcat.uri-encoding=UTF-8
#spring.http.encoding.force=true
#spring.http.encoding.charset=UTF-8
#spring.http.encoding.enabled=true
#上面spring boot版本高的一般不能操作，与如下的作用基本类似
#一般是如下
#解决中文乱码
#tomcat编码，得到的请求数据以下面的编码格式进行操作，一般浏览器可以操作中文，（所以可以不用设置）
#如操作请求过来的参数，但也有可能url出现乱码，一般是js的操作，到那时一般需要使用encodeURI来进行传输
server.tomcat.uri-encoding=UTF-8 
#对请求或者响应的编码设置（使得数据被操作），一般是解决post的，操作过滤
#因为不操作过滤，那么已经变化了，再次设置编码就并没有作用了（如springmvc就需要过滤，而不是去方法里面设置编码）
server.servlet.encoding.force=true
server.servlet.encoding.charset=UTF-8
server.servlet.encoding.enabled=true

application.yaml（yml）配置文件： YAML文件格式是Spring Boot支持的一种JSON文件格式，相较于传统的Properties配置文件， YAML文件以数据为核心 是一种更为直观且容易被电脑识别的数据序列化格式 application.yaml配置文件的工作原理和application.properties是一样的，只不过yaml格式配置文件看起来更简洁一些 YAML文件的扩展名可以使用.yml或者.yaml application.yml文件使用 "key:（空格） value"格式配置属性，使用缩进控制层级关系 SpringBoot的三种配置文件是可以共存的，也就是说，可以写这三个配置文件，都会进行读取：

 

          **/application*.yml
          **/application*.yaml
          **/application*.properties
        

这里，针对不同数据类型的属性值，介绍一下YAML value值为普通数据类型（例如数字、字符串、布尔等） 当YAML配置文件中配置的属性值为普通数据类型时，可以直接配置对应的属性值 同时对于字符串类型的属性值，不需要额外添加引号，示例代码如下

server:  
#记得":"后面需要空格，当你删除空格后，会发现属性的port颜色变了，即配置出现错误
#当有其他当前的直接级别（在级别的级别里面，并不会影响不是当前级别的其他级别），有正常配置时，会启动报错
#除非什么都不加上
#且层级关系要正确，如port与server同一级，那么读取时，会报错（因为该级别基本没有port，除非有，那么不会报错）
#如context-path，可以与server和servlet同一级，因为有该级别，且区分级别时，只要有空格即可，无论该空格是多少
	port: 8080  
	#设置起始路径，需要在项目前面加上hello才可，即访问http://localhost:8081/hello/hello/boot
	servlet:    
		#一般我们设置为/，大型的项目情况下可能会进行操作其他路径
		context-path: /hello

value值为数组和单列集合： 当YAML配置文件中配置的属性值为数组或单列集合类型时，主要有两种书写方式：缩进式写法和行内式写法 其中，缩进式写法还有两种表示形式，示例代码如下

person:   
	hobby:     
		- play    
		- read
         - sleep 
         
#好像也可以这样
person:   
	hobby:     
	- play    
	- read
	- sleep 
#"-"可以与hobby同级，假设是这样
person:   
	hobby:     
	- play    
	 - read
	- sleep 
#那么返回是数据是[play - read, sleep]，数组长度为2
#也就是说不是同一级的，当成一体，知道看到同一级的，但是却不能这样
person:   
	hobby:     
	  - play    
	  - read
	- sleep 
#只能与第一个的级别相同或者小级别，否则报错
#若是这样
person:   
	hobby:     
	  - play    
	   - read
	    - sleep 
#那么返回，因为都是小级别[play - read - sleep]，数组长度为1，与自己的小级别一体

或者使用如下示例形式：

person:  
	hobby:    
		play,    
		read,    
		sleep
#后面的值，不能与hobby同一级，但他们之间的级别不做要求，即可以这样
person:  
	hobby:    
	  play,    
		read,    
		sleep

上述代码中，在YAML配置文件中通过两种缩进式写法对person对象的单列集合（或数组）类型的爱好hobby 赋值为play、read和sleep，其中一种形式为"-（空格）属性值" 另一种形式为多个属性值之前加英文逗号分隔（注意，最后一个属性值后不要加逗号） 行内式写法：

person:   
	hobby: [play,read,sleep]
#也可以这样
person:   
	hobby: play,read,sleep
#这个相当于
person:  
	hobby:    
		play,    
		read,
		sleep
#至此我们发现之所以加上,(逗号)，是为了进行分开，而之所以不在最后加上逗号，是为了防止出现空数据
#因为在最后加上逗号，那么默认该逗号后面有数据，如果不加，那么就是空的数据，相当于字符串里面的""
#但是若使用[]进行包括，最后的逗号写不写都一样，只要后面没有数据，那么该都会会自动的删除（只对[]来说）
#所以最后的逗号对于[]来说没有""数据，其中两个逗号之间不写，会报错（启动报错），而不是[]的会认为是空数据

通过上述示例对比发现，YAML配置文件的行内式写法更加简明、方便 另外，包含属性值的中括号"[]"还可以进一步省略，在进行属性赋值时，程序会自动匹配和校对 我们发现无论是什么样的操作":"后面都需要一个空格，这是规定，也是为了好观察 value值为Map集合和对象： 当YAML配置文件中配置的属性值为Map集合或对象类型时 YAML配置文件格式同样可以分为两种书写方式：缩进式写法和行内式写法 其中，缩进式写法的示例代码如下：

person:  
	map:     
		k1: v1    
		k2: v2

对应的行内式写法示例代码如下 ：

person:  
	map: {k1: v1,k2: v2}

在YAML配置文件中，配置的属性值为Map集合或对象类型时，缩进式写法的形式按照YAML文件格式编写即可 而行内式写法的属性值要用大括号"{}"包含 接下来，在Properties配置文件演示案例基础上，通过配置application.yaml配置文件对Person对象进行赋值，具体使用如下 在项目的resources目录下，新建一个application.yaml配置文件，在该配置文件中编写为Person类设置的配置属性

#对实体类对象Person进行属性配置
person:  
	id: 1  
	name: 王二麻子  
	family:    
		- 妻    
		- 妾  
	hobby:    
		- play    
		- read    
		- sleep  
	map:    
		k1: value1    
		k2: value2  
	pet:    
		type: 狗    
		name: 哈士奇
#该设置若在properties里面，不会有任何的作用，但并不会报错，因为在properties里面，不会识别的那么就会跳过
#yaml和yml（前面的简写）的格式基本都是一致的，即都可以这样写

再次执行测试： 若返回数据，则操作成功 好像这时候更加的操作@Value()注解都只能操作单独的类型了（数组，集合，类好像都不能操作），你可以百度进行查找对应操作 大概是对应的@ConfigurationProperties(prefix = “person”)注解存在使得移除了吧 最后注意一下：使用spring boot时，对应的url访问不能出现多余的/，也就是说 //斜杠的访问不会被后端（以前说是浏览器的作用，实际上是因为浏览器访问后端造成的）解析成一个/ 这时就会出现访问不了，或者网页不存在 配置文件属性值的注入： 使用Spring Boot全局配置文件设置属性时： 如果配置属性是Spring Boot已有属性，例如服务端口server.port 那么Spring Boot内部自动扫描并读取这些配置文件时，对应的属性值覆盖默认属性 如果配置的属性是用户自定义属性，例如刚刚自定义的Person实体类属性，则不会自动的覆盖，因为没有 那么他只是定义，并没有操作，需要我们在程序中手动注入这些配置属性方可操作，而不是自动的使用（因为定义） 那么实际上也可以这样的操作：如@Value(“${server.port}”)，那么可以注入对应的端口值 因为虽然他覆盖了对应的默认属性，但他任然是定义的，既然是定义的，就可以使用 总体而言：该配置在spring boot中多了一个已有属性进行覆盖，其余的与普通的配置存放信息文件是一样的 需要被使用（如properties文件，以前有操作数据库的信息，那时就是被使用） 然后使用注解注入对应的实例，当然若没有对应的注入配置属性，那么对应的实例自然是使用默认的值的 当然他们注入的方式基本都是扫描时进行操作的，只有扫描时，对应的注解操作才会进行 而对应的配置文件信息（写的信息）实际上也是使用后的再扫描的（在spring中也有注解和配置文件操作他，他基本是全局的） Spring Boot支持多种注入配置文件属性的方式，下面来介绍如何使用注解@ConfigurationProperties和@Value注入属性 使用@ConfigurationProperties注入属性： Spring Boot提供的@ConfigurationProperties注解 用来快速、方便地将配置文件中的自定义属性值批量注入到某个Bean对象的多个对应属性中 前面的操作中，我们就使用了这个注解并说明了，所以这里就不作说明 实际上上面的注解方式不够灵活，要想要更加的灵活，一般使用如下方式进行注入属性值 使用@Value注入属性： @Value注解是Spring框架提供的，用来读取配置文件中的属性值并逐个注入到Bean对象的对应属性中 Spring Boot框架从Spring框架中对@Value注解进行了默认继承 所以在Spring Boot框架中还可以使用该注解读取和注入配置文件属性值，使用@Value注入属性的示例代码如下

@Value("${person.id}")    
private int id;

上述代码中，使用@Component和@Value注入Person实体类的id属性 其中，@Value不仅可以将配置文件的属性注入Person的id属性，还可以直接给id属性直接的赋值，如@Value(“1”)，直接赋值为1 这点是@ConfigurationProperties不支持的，因为他只能去配置文件里加上对应的属性及其值才可 不够灵活，且使得配置文件信息变多 演示@Value注解读取并注入配置文件属性的使用： 在com.lagou.pojo包下新创建一个实体类Student，并使用@Value注解注入属性

package com.lagou.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;


@Component
public class Student {
    @Value("${person.id}")
    private int id;
    @Value("${person.name}")
    private String name; //名称

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + ''' +
                '}';
    }
}

Student类使用@Value注解将配置文件的属性值读取和注入 从上述示例代码可以看出 使用@Value注解方式需要对每一个属性注入设置（相当于直接的赋值，反射可以赋值private，在其他地方） 同时又免去了属性的setXX()方法 再次打开测试类进行测试：

 @Autowired
    private Student student;
    @Test public void studentTest() {
        System.out.println(student); //Student{id=1, name='王二麻子'}
    }

若返回数据，则操作成功 可以看出，测试方法studentTest()运行成功，同时正确打印出了Student实体类对象 需要说明的是，本示例中只是使用@Value注解对实例中Student对象的普通类型属性进行了赋值演示 而@Value注解对于properties配置文件的格式属性中包含了Map集合、对象的不支持@Value注入 而YAML（YML）文件格式的配置文件的属性list（其他集合基本也是）集合和数组，map集合，对象等注入都不支持 上面不支持的，如果赋值会出现错误 这就是他的缺点（以前好像可以） 自定义配置： spring Boot免除了项目中大部分的手动配置，对于一些特定情况，我们可以通过修改全局配置文件以适应具体生产环境 可以说，几乎所有的配置都可以写在application.yml文件中 Spring Boot会自动加载全局配置文件从而免除我们手动加载的烦恼（因为设置好的三个） 但是，如果我们自定义配置文件，Spring Boot是无法识别这些配置文件的（因为只有那三个可以），此时就需要我们手动加载 接下来，将针对Spring Boot的自定义配置文件及其加载方式进行讲解 使用@PropertySource加载配置文件 对于这种加载自定义配置文件的需求，可以使用@PropertySource注解来实现 @PropertySource注解用于指定自定义配置文件的具体位置和名称 当然，如果需要将自定义配置文件中的属性值注入到对应类的属性中 可以使用@ConfigurationProperties或者@Value注解进行属性值注入 因为自定义配置文件与其他三个配置文件一样，都被读取操作了，自然结果是一样的 只是不会自动读取操作该自定义的配置文件而已，需要手动读取操作 演示： 打开Spring Boot项目的resources目录 在项目的类路径下新建一个test.properties自定义配置文件，在该配置文件中编写需要设置的配置属性

#对实体类对象MyProperties进行属性配置
test.id=110
test.name=test

在com.lagou.pojo包下新创建一个配置类MyProperties 提供test.properties自定义配置文件中对应的属性，并根据@PropertySource注解的使用进行相关配置

package com.lagou.pojo;



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

@Component  // 自定义配置类
@PropertySource("classpath:test.properties")  // 指定自定义配置文件位置和名称，该文件的类型好像并不做要求
//好像只要对应的文件名称对应即可，到那时，一般是
//在扫描时，一般会先操作该@PropertySource注解，然后再操作其他的注解，使得可以操作属性值
@ConfigurationProperties(prefix = "test") // 指定配置文件注入属性前缀
public class MyProperties {
    private int id;
    private String name;

    @Override
    public String toString() {
        return "MyProperties{" +
                "id=" + id +
                ", name='" + name + ''' +
                '}';
    }

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

主要是一个自定义配置类，通过相关注解引入了自定义的配置文件，并完成了自定义属性值的注入 针对示例中的几个注解，具体说明如下 @PropertySource(“classpath:test.properties”)注解指定了自定义配置文件的位置和名称 此示例表示自定义配置文件为classpath类路径下的test.properties文件，也就是项目下的（打包后可以看到对应的classes） @ConfigurationProperties(prefix = “test”)注解将上述自定义配置文件test.properties中以test开头的属性值注入到该配置类属性中 进行测试：

@Autowired
    private MyProperties myProperties;
    
    @Test
    public void myPropertiesTest() {

        System.out.println(myProperties);
        //MyProperties{id=110, name='test'}
    }

若有对应的数据，则操作成功 注意：在properties里面，注释基本只能占一行（虽然也是一行一行的读取，那么其对应的不加注释也可） 否则要么是注释，要么当成值，要么没有注释，虽然与普通的文件类似，他都是一行一行的读取 其他的可以注释的自然省略，但是使用@PropertySource读取的文件基本都看成普通文件，那么是一行一行的读取 普通的文件基本没有注释一说，只要有一行是对应的属性值对应，那么就可以操作，比如：

对实体类对象MyProperties进行属性配置
test.id=110
test.name=test

这时无论他是什么类型的，都可以 使用@Configuration编写自定义配置类： 在Spring Boot框架中，推荐使用配置类的方式向容器中添加和配置组件 在Spring Boot框架中，通常使用@Configuration注解定义一个配置类 Spring Boot会自动扫描和识别配置类，从而替换传统Spring框架中的XML配置文件 当定义一个配置类后，还需要在类中的方法上使用@Bean注解进行组件配置，将方法的返回对象注入到Spring容器中 并且组件名称默认使用的是方法名，当然也可以使用@Bean注解的name或value属性自定义组件的名称 演示： 在项目下新建一个com.lagou.config包，并在该包下新创建一个类MyConfig，该类中不需要编写任何代码 而该类目前没有添加任何配置和注解，因此还无法正常被Spring Boot扫描和识别 创建了一个com.lagou.service包，里面创建空的MyService类，用来操作 接下来使用@Configuration注解将该MyConfig类声明一个配置类，内容如下：

package com.lagou.config;

import com.lagou.service.MyService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration // 定义该类是一个配置类
public class MyConfig {

    @Bean    // 将返回值对象作为组件添加到Spring容器中，该组件id默认为方法名
    //当然也可以自己指定，如@Bean("myService2")
    public MyService myService(){
        return new MyService();
    }

}

MyConfig是@Configuration注解声明的配置类（类似于声明了一个XML配置文件） 该配置类会被Spring Boot自动扫描识别，使用@Bean注解的myService()方法 其返回值对象会作为组件添加到了Spring容器中（类似于XML配置文件中的标签配置），并且该组件的id默认是方法名myService 测试类：

 @Autowired
    private MyService myService;
    @Autowired
    private MyConfig myConfig; //配置类也是会变成实例被使用的（加入对应的对象）

    @Test
    public void iocTest() {
        //返回结果，每次的运行一般都不会相同，因为对象（后面的就不在说明了）
        System.out.println(myService); //com.lagou.service.MyService@23564dd2
        System.out.println(myConfig);  	
        //com.lagou.config.MyConfig$$EnhancerBySpringCGLIB$$d53e0fdf@54895681
      
    }

若返回数据，则代表注入成功，当然也可以操作如下：

@Autowired
//包记得要对应，import org.springframework.context.ApplicationContext;
    private ApplicationContext applicationContext; 
//使用测试的注解，即测试的读取配置文件或者配置类（这里实际上也是），一般会将IOC容器本身放入自己的IOC容器中
//那么也就可以得到对应的ApplicationContext了（本身，即自己）

    @Test
    public void Test() {
        System.out.println(applicationContext.getBean("myService2"));
        System.out.println(applicationContext.containsBean("myService2")); //查看是否有该key
        
        
    }

上述代码中，先通过@Autowired注解引入了Spring容器实例ApplicationContext 然后在测试方法Test()中测试查看该容器中是否包括id为myService2的组件（也就是实例），若有对应的数据，则操作成功 从测试结果可以看出，测试方法Test()运行成功，且返回了true 表示Spirng的IOC容器中也已经包含了id为myService2的实例对象组件 说明使用自定义配置类的形式完成了向Spring容器进行组件的添加和配置 SpringBoot原理深入及源码剖析： 传统的Spring框架实现一个Web服务，需要导入各种依赖JAR包，然后编写对应的XML配置文件等，相较而言 Spring Boot显得更加方便、快捷和高效 那么，Spring Boot究竟如何做到这些的呢： 接下来分别针对Spring Boot框架的依赖管理、自动配置通过源码进行深入分析 依赖管理： 问题1：为什么导入dependency时不需要指定版本： 在Spring Boot入门程序中，项目pom.xml文件有两个核心依赖 分别是spring-boot-starter-parent和spring-boot-starter-web，关于这两个依赖的相关介绍具体如下： spring-boot-starter-parent依赖： 在项目中的pom.xml文件中找到spring-boot-starter-parent依赖，示例代码如下:

        org.springframework.boot
        spring-boot-starter-parent
        2.7.2
         
    

点击spring-boot-starter-parent（ctrl+鼠标左键进入）

上述代码中，将spring-boot-starter-parent依赖作为Spring Boot项目的统一父项目依赖管理 并将项目版本号统一为2.7.2.RELEASE，该版本号根据实际开发需求是可以修改的 使用"Ctrl+鼠标左键"进入并查看spring-boot-starter-parent底层源文件 发现spring-boot-starter-parent的底层有一个父依赖spring-boot-dependencies，核心代码具体如下

        org.springframework.boot
        spring-boot-dependencies
        2.7.2
    

继续查看spring-boot-dependencies底层源文件，核心代码具体如下：

    5.16.5
    2.7.7
    ...
   
    

从spring-boot-dependencies底层源文件可以看出，该文件通过标签对一些常用技术框架的依赖文件进行了统一版本号管理 例如activemq、spring、tomcat等，都有与Spring Boot 2.7.2版本相匹配的版本 这也是pom.xml引入依赖文件不需要标注依赖文件版本号的原因 需要说明的是，如果pom.xml引入的依赖文件不是 spring-boot-starter-parent管理的 那么在pom.xml引入依赖文件时，需要使用标签指定依赖文件的版本号，这是肯定的，因为有限 问题2： spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理，那么项目运行依赖的JAR包是从何而来的： spring-boot-starter-web依赖： 查看spring-boot-starter-web依赖文件源码，核心代码具体如下：

    
      org.springframework.boot
      spring-boot-starter
      2.7.2
      compile
    
    
      org.springframework.boot
      spring-boot-starter-json
      2.7.2
      compile
    
    
      org.springframework.boot
      spring-boot-starter-tomcat
      2.7.2
      compile
    
    
    
        
      org.springframework
      spring-web
      5.3.22
      compile
    
    
        
      org.springframework
      spring-webmvc
      5.3.22
      compile
    
  

从上述代码可以发现，spring-boot-starter-web依赖启动器的主要作用是提供Web开发场景所需的底层所有依赖 正是如此，在pom.xml中引入spring-boot-starter-web依赖启动器时，就可以实现Web场景开发 而不需要额外导入Tomcat服务器以及其他Web依赖文件等 当然，这些引入的依赖文件的版本号还是由spring-boot-starter-parent父依赖进行的统一管理 有哪些starter（有starter代表是依赖的集合，即多个依赖，且starter一般操作的是spring boot项目）： https://github.com/spring-projects/spring-boot/tree/v2.1.0.RELEASE/spring-boot-project/spring-boot-starters https://mvnrepository.com/search?q=starter 上面的这些网站里面有对应的spring boot的依赖 Spring Boot除了提供有上述介绍的Web依赖启动器外，还提供了其他许多开发场景的相关依赖 我们可以打开Spring Boot官方文档，搜索"Starters"关键字查询场景依赖启动器 Spring Boot除了提供有上述介绍的Web依赖启动器外，还提供了其他许多开发场景的相关依赖 我们可以打开Spring Boot官方文档，搜索"Starters"关键字查询场景依赖启动器（也就是上面的第一个网站） 列出了Spring Boot官方提供的部分场景依赖启动器 这些依赖启动器适用于不同的场景开发，使用时只需要在pox.xml文件中导入对应的依赖启动器即可 需要说明的是，Spring Boot官方并不是针对所有场景开发的技术框架都提供了场景启动器 例如数据库操作框架MyBatis、阿里巴巴的Druid数据源等，Spring Boot官方就没有提供对应的依赖启动器 为了充分利用Spring Boot框架的优势，在Spring Boot官方没有整合这些技术框架的情况下 MyBatis、Druid等技术框架所在的开发团队主动与Spring Boot框架进行了整合，实现了各自的依赖启动器 例如mybatis-spring-boot-starter、druid-spring-boot-starter等 我们在pom.xml文件中引入这些第三方的依赖启动器时，切记要配置对应的版本号（因为一般spring boot的对应没有该版本的配置） 自动配置： 概念：能够在我们添加jar包依赖的时候，自动为我们配置一些组件的相关配置 我们无需配置或者只需要少量配置就能运行编写的项目 问题：Spring Boot到底是如何进行自动配置的，都把哪些组件进行了自动配置： Spring Boot应用的启动入口是@SpringBootApplication注解标注的类中的main()方法

package com.lagou;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Springbootdome2Application {

    public static void main(String[] args) {

        SpringApplication.run(Springbootdome2Application.class, args);
    }

}

进入到@SpringBootApplication内，观察其做了哪些工作（部分，前面的导入和包就省略了，后面也是如此）：

@Target({ElementType.TYPE}) //注解的适用范围,Type表示注解可以描述在类、接口、注解或枚举中
@Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期，Runtime（RUNTIME）表示运行时
@Documented //表示注解可以记录在javadoc中
@Inherited //表示可以被子类继承该注解
@SpringBootConfiguration // 标明该类为配置类
@EnableAutoConfiguration // 启动自动配置功能
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    // 根据class来排除特定的类，使其不能加入spring容器，传入参数value类型是class类型
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class[] exclude() default {};

    // 根据classname 来排除特定的类，使其不能加入spring容器，传入参数value类型是class的全类名字符串数组
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    // 指定扫描包，参数是包名的字符串数组
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    // 扫描特定的包，参数类似是Class类型数组
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class[] scanBasePackageClasses() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "nameGenerator"
    )
    Class nameGenerator() default BeanNameGenerator.class;

    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

从上述源码可以看出，@SpringBootApplication注解是一个组合注解，前面 4 个是注解的元数据信息 我们主要看后面 3 个注解：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个核心注解 关于这三个核心注解的相关说明具体如下（第三个： @SpringBootConfiguration注解： @SpringBootConfiguration：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类 查看@SpringBootConfiguration注解源码，核心代码具体如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration // 配置类的作用等同于配置文件，配置类也是容器中的一个对象
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

从上述源码可以看出，@SpringBootConfiguration注解内部有一个核心注解@Configuration 该注解是Spring框架提供的，表示当前类为一个配置类（XML配置文件的注解表现形式），并可以被组件扫描器扫描 由此可见，@SpringBootConfiguration注解的作用与@Configuration注解相同，都是标识一个可以被组件扫描器扫描的配置类 只不过@SpringBootConfiguration是被Spring Boot进行了重新封装命名而已，这样会使得该类可以被获取调用（底层获取执行） 从而执行main方法 虽然我们也可以再次进行获取，但也要注意，同一个类里面，多个不同的变量，基本是能注入同一个对象的 @EnableAutoConfiguration注解： @EnableAutoConfiguration：开启自动配置功能，以前由我们需要配置的东西，现在由SpringBoot帮我们自动配置 这个注解就是Springboot能实现自动配置的关键 同样，查看该注解内部查看源码信息，核心代码具体如下 ：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 自动配置包
@AutoConfigurationPackage
// Spring的底层注解@Import，给容器中导入一个组件
// 导入的组件是AutoConfigurationPackages.Registrar.class
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    // 返回不会被导入到 Spring 容器中的类
    Class[] exclude() default {};

    // 返回不会被导入到 Spring 容器中的类名
    String[] excludeName() default {};
}

可以发现它是一个组合注解， Spring 中有很多以Enable开头的注解 其作用就是借助@Import来收集并注册特定场景相关的Bean，并加载到IOC容器 @EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到IoC容器 下面，对这两个核心注解@AutoConfigurationPackage和@Import分别进行讲解： @AutoConfigurationPackage注解： 查看@AutoConfigurationPackage注解内部源码信息，核心代码具体如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class}) // 导入Registrar中注册的组件（实例）
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

    Class[] basePackageClasses() default {};
}

从上述源码可以看出，@AutoConfigurationPackage注解的功能主要是由@Import注解实现的 它是spring框架的底层注解，它的作用就是给容器中导入某个组件（组件可以说是实例）类 例如@Import(AutoConfigurationPackages.Registrar.class)，它就是将Registrar这个组件类导入到容器中 可查看Registrar类中registerBeanDefinitions方法 这个方法就是导入组件类的具体实现（ctrl+鼠标左键点击Registrar.class中的Registrar）：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry 
                                            registry) {
            AutoConfigurationPackages.register(registry, (String[])(
                new AutoConfigurationPackages.PackageImports(metadata)).
                                               getPackageNames().toArray(new String[0]));
            //低版本一般是
            
        }
    public Set