【SpringBoot】概述（面试常问）与运行原理

Biehmltym2025-03-03 17:23

目录标题

一，概述

1、SpringBoot 简介 - 八股文常问

1 回顾什么是Spring

Spring是一个开源的Java应用框架，由Rod Johnson在2003年创建，旨在解决企业级Java应用开发的复杂性问题。Spring框架提供了一个轻量级的容器 和一套完整的编程和配置模型，支持多种应用场景。

核心理念：Spring是为了解决企业级应用开发的复杂性而创建的，简化开发。

2 Spring框架的核心特性


  • 依赖注入(DI)和控制反转(IoC)：管理对象的创建和依赖关系
  • 面向切面编程(AOP)：将横切关注点(如日志、事务)从业务逻辑中分离
  • 数据访问抽象：简化数据库操作
  • 事务管理：提供统一的事务管理机制
  • MVC Web框架：用于构建Web应用
  • 安全框架：提供认证和授权功能

3 Spring是如何简化Java开发的

Spring通过以下几种方式简化了Java开发：

1.起步依赖

2.自动配置

3.其他特性

内嵌的Tomcat、Jetty（无需部署WAR文件）

外部化配置

不需要XML配置(properties/yml)

  1. 减少样板代码：通过依赖注入减少了对象创建和查找的代码
  2. 松散耦合：通过IoC容器管理依赖关系，使组件之间松散耦合
  3. 声明式编程：使用注解或XML配置替代代码实现，尤其是在事务、安全等方面
  4. 框架整合：提供与其他框架(如Hibernate、MyBatis)的无缝集成
  5. 测试便利性：支持单元测试和集成测试的便捷方式
  6. 一致的异常处理：提供统一的非检查异常体系

4 什么是SpringBoot

SpringBoot是一个基于Spring框架的快速开发工具，它遵循"约定大于配置"的原则，能够帮助开发者快速构建独立的、生产级别的Spring应用。

  • SpringBoot的出现是Java Web开发框架演进的自然结果，从最初的Servlet到Struts，再到SpringMVC，最后到SpringBoot，体现了框架不断简化开发流程的趋势。

  • SpringBoot并不是一个全新的框架，而是Spring生态系统的一部分，它通过默认配置 和自动装配大大简化了Spring应用的开发过程。正如官方所说，它让你能够"just run"，几行代码就能开发一个HTTP接口。

  • 技术框架的发展遵循一条主线：从复杂场景到规范框架，再到轻量级框架，最终到"约定大于配置"的一站式解决方案。这正是Java企业级应用→J2EE→Spring→SpringBoot的发展历程。

  • 随着Spring框架不断扩展，项目整合变得越来越复杂，配置文件越来越多，被称为"配置地狱"。SpringBoot正是在这样的背景下诞生的，它的目标是让Spring更易用，更容易集成各种中间件和开源软件。

5 Spring Boot与Spring框架的关系

SpringBoot是Spring框架的扩展，而非替代。它基于Spring核心功能构建，通过自动配置和默认设置简化了Spring应用的开发流程：

  • SpringBoot利用了Spring的核心特性（如IoC、AOP），但通过自动配置减少了开发者的工作量
    - 可以理解为：如果Maven整合了所有的jar包，那么SpringBoot就整合了所有的框架
  • SpringBoot于2014年首次发布，由Pivotal团队开发，目的是加速基于Spring的应用开发

6 Spring Boot的核心特性

  1. 自动配置：根据项目依赖自动配置Spring应用，减少手动配置。例如，添加JDBC依赖后，SpringBoot会自动配置数据源
  2. 起步依赖（Starter Dependencies） ：提供针对不同功能场景的依赖集合，如spring-boot-starter-web包含了构建RESTful应用所需的所有依赖
  3. 嵌入式服务器：内置Tomcat、Jetty或Undertow服务器，让应用可以独立运行，无需外部应用服务器
  4. 命令行界面：提供Spring Boot CLI，支持使用Groovy脚本快速开发
  5. Actuator：提供生产级别的监控、健康检查和管理功能
  6. 无XML配置：使用Java配置和注解替代传统XML配置
  7. 外部化配置：支持从多种外部源（属性文件、YAML、环境变量、命令行参数等）获取配置

7 Spring Boot的优势

  1. 简化配置：减少手动配置，特别是常用的标准配置
  2. 快速开发：通过起步依赖和自动配置，大幅减少项目设置时间
  3. 独立应用：创建可独立运行的应用，非常适合微服务架构
  4. 生产就绪：内置健康检查、指标收集和外部化配置，便于生产环境部署和管理
  5. 完整生态：与Spring Cloud等其他Spring项目无缝集成，支持微服务架构开发

总结：SpringBoot通过"约定优于配置"的理念，让开发者能够专注于业务逻辑开发，而非基础设施配置，从而显著提高开发效率。

2、第一个SpringBoot程序

2.1、准备工作

我们将学习如何快速的创建一个Spring Boot应用，并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解，并体验其结构简单、开发快速的特性。

我的环境准备：

  • jdk1.8

  • Maven-3.6.1

  • SpringBoot 最新版

  • IDEA

2.2、创建基础项目说明

Spring官方提供了非常方便的工具让我们快速构建应用

Spring Initializr：https://start.spring.io/

**项目创建方式一：**在官网使用Spring Initializr 的 Web页面创建项目

1、打开 https://start.spring.io/

2、填写项目信息

3、点击"Generate Project"按钮生成项目；下载此项目

4、解压项目包，并用IDEA以Maven项目导入，一路下一步即可，直到项目导入完毕。

5、如果是第一次使用，可能速度会比较慢，包比较多、需要耐心等待一切就绪。

**项目创建方式二：**使用 IDEA 直接创建项目

1、创建一个新项目

2、选择spring initalizr ， 可以看到默认就是去官网的快速构建工具那里实现

3、填写项目信息

4、选择初始化的组件（初学勾选 Web 即可）

5、填写项目路径

6、等待项目构建成功

项目结构分析：

通过上面步骤完成了基础项目的创建。就会自动生成以下文件。

1、程序的主启动类

2、一个 application.properties 配置文件

3、一个 测试类

4、一个 pom.xml

2.3、pom.xml 分析

打开pom.xml，看看Spring Boot项目的依赖：

xml 复制代码 
<!-- 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- web场景启动器 -->
    <!--web依赖：tomcat,dispatcherServlet，xml...-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--spring-boot-starter：所有的springboot依赖都是使用这个开头的-->
    <!-- springboot单元测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <!-- 剔除依赖 -->
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- 打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

如上所示，主要有四个部分：

  • 项目元数据：创建时候输入的Project Metadata部分，也就是Maven项目的基本元素，包括：groupId、artifactId、version、name、description等

  • parent：继承spring-boot-starter-parent的依赖管理，控制版本与打包等内容

  • dependencies：项目具体依赖，这里包含了spring-boot-starter-web用于实现HTTP接口（该依赖中包含了Spring MVC），官网对它的描述是：使用Spring MVC构建Web（包括RESTful）应用程序的入门者，使用Tomcat作为默认嵌入式容器。spring-boot-starter-test用于编写单元测试的依赖包。更多功能模块的使用将在后面逐步展开。

  • build：构建配置部分。默认使用了spring-boot-maven-plugin，配合spring-boot-starter-parent就可以把Spring Boot应用打包成JAR来直接运行。

2.4、编写一个http接口

1、在主程序的同级目录下，新建一个controller包，一定要在同级目录下，否则识别不到

2、在包中新建一个HelloController类

java 复制代码 
@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World";
    }
    
}

3、编写完毕后，从主程序启动项目，浏览器发起请求，看页面返回；控制台输出了 Tomcat 访问的端口号！

简单几步，就完成了一个web接口的开发，SpringBoot就是这么简单。所以我们常用它来建立我们的微服务项目！

2.5、将项目打成jar包，点击 maven的 package

  • 如果打包成功，则会在target目录下生成一个 jar 包

  • 如果遇到以上②的错误，可以配置打包时跳过项目运行测试用例

    xml 复制代码 
    <!--
    在工作中,很多情况下我们打包是不想执行测试用例的
    可能是测试用例不完事,或是测试用例会影响数据库数据
    跳过测试用例执
-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <!--跳过项目运行测试用例-->
        <skipTests>true</skipTests>
    </configuration>
</plugin>

  • 打成了jar包后，就可以在任何地方运行了！OK

    浏览器运行结果（上图第⑤步）：

3、彩蛋

  1. 更改端口号


properties 复制代码 
# 更改项目的端口号
server.port=8081

  1. 如何更改启动时显示的字符拼成的字母，SpringBoot呢？也就是 banner 图案；

    只需一步：到项目下的 resources 目录下新建一个banner.txt 即可。

    图案可以到：https://www.bootschool.net/ascii 这个网站生成，然后拷贝到文件中即可！

​

二，运行原理探究

我们之前写的HelloSpringBoot，到底是怎么运行的呢，Maven项目，我们一般从pom.xml文件探究起；

1、父依赖

pom.xml

  • spring-boot-dependencies：核心依赖在父工程中！
  • 我们在写或者引入一些Springboot依赖的时候，不需要指定版本，就因为有这些版本仓库

1、其中它主要是依赖一个父项目，主要是管理项目的资源过滤及插件！

xml 复制代码 
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
    <relativePath/> 
    <!-- lookup parent from repository -->
</parent>

2、点进去，发现还有一个父依赖

xml 复制代码 
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.1.RELEASE</version>
</parent>

3、这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心；

4、以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本了；

2、启动器 spring-boot-starter

  • 依赖

    xml 复制代码 
    <dependency>        								
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter</artifactId>
</dependency>

  • springboot-boot-starter-xxx，说白了就是Springboot的启动场景

  • 比如spring-boot-starter-web，他就会帮我们自动导入web的所有依赖

  • springboot会将所有的功能场景，都变成一个个的启动器

  • 我们要使用什么功能，就只需要找到对应的启动器就好了start

3、主程序

3.1、默认的主启动类

java 复制代码 
//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {
   public static void main(String[] args) {
     //以为是启动了一个方法，没想到启动了一个服务
      SpringApplication.run(SpringbootApplication.class, args);
   }
}

但是**一个简单的启动类并不简单！**我们来分析一下这些注解都干了什么

3.2、注解（@SpringBootApplication）

  • 作用：标注在某个类上说明这个类是SpringBoot的主配置

  • SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；

  • 进入这个注解：可以看到上面还有很多其他注解！

    java 复制代码 
    @SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    // ......
}
@ComponentScan

  • 这个注解在Spring中很重要 ,它对应XML配置中的元素。

  • 作用：自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

@SpringBootConfiguration

  • 作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；

  • 我们继续进去这个注解查看

    java 复制代码 
    // 点进去得到下面的 @Component
@Configuration
public @interface SpringBootConfiguration {}

@Component
public @interface Configuration {}

  • 这里的 @Configuration ，说明这是一个spring的配置类 ，配置类就是对应Spring的xml 配置文件；

  • @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

  • 我们回到 SpringBootApplication 注解中继续看。

@EnableAutoConfiguration

  • 开启自动配置功能

    • 以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；
    • @EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

    点进注解接续查看：

  • @AutoConfigurationPackage ：自动配置包

    java 复制代码 
    @Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

    • @import ：Spring底层注解@import ， 给容器中导入一个组件

    • Registrar.class 作用：自动配置包注册，将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

    • 这个分析完了，退到上一步，继续看

  • @Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；

    • AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

      java 复制代码 
      // 获取所有的配置
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);

    • 获得候选的配置

      java 复制代码 
      protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // 和下面的方法对应
    //这里的getSpringFactoriesLoaderFactoryClass（）方法
    //返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration
  List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
}

//和上面的类的方法loadFactoryNames里面的第一个参数对应
//这里的getSpringFactoriesLoaderFactoryClass（）方法
//返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration
 protected Class<?> getSpringFactoriesLoaderFactoryClass() {
     return EnableAutoConfiguration.class;
 }

    • 这个方法getCandidateConfigurations()又调用了 SpringFactoriesLoader 类的静态方法！我们进入SpringFactoriesLoader类loadFactoryNames() 方法，获取所有的加载配置

      java 复制代码 
      public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    //这里它又调用了 loadSpringFactories 方法
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

    • 我们继续点击查看 loadSpringFactories 方法

      • 项目资源:META-INF/spring.factories
      • 系统资源:META-INF/spring.factories
      • 从这些资源中配置了所有的nextElement（自动配置），分装成properties
      java 复制代码 
      //将所有的资源加载到配置类中（将下面的抽离出来分析，第15行）
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
      java 复制代码 
      private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    //获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            //去获取一个资源 "META-INF/spring.factories"
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();
            //判断有没有更多的元素，将读取到的资源循环遍历，封装成为一个Properties
            while(urls.hasMoreElements()) {
              URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();
                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryClassName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;
                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryName = var9[var11];
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

    • 发现一个多次出现的文件：spring.factories，全局搜索它

3.3、spring.factories

我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

WebMvcAutoConfiguration

我们在上面的自动配置类随便找一个打开看看，比如 ：WebMvcAutoConfiguration

可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean，可以找一些自己认识的类，看着熟悉一下！

所以，自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 ，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类 ， 然后将这些都汇总成为一个实例并加载到IOC容器中。

4、结论：

  1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
  2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
  3. 以前我们需要自动配置的东西，现在springboot帮我们做了
  4. 整合JavaEE，整体解决方案和自动配置的东西都在springboot-autoconfigure的jar包中；
  5. 它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器中
  6. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并自动配置，@Configuration（javaConfig） ；
  7. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

现在大家应该大概的了解了下，SpringBoot的运行原理，后面我们还会深化一次！

启动

1、不简单的方法

我最初以为就是运行了一个main方法，没想到却开启了一个服务；

java 复制代码 
@SpringBootApplication
public class Springboot01HellowordApplication {

    public static void main(String[] args) {
       	//该方法返回一个ConfigurableApplicationContext对象
 		//参数一：应用入口的类； 参数二：命令行参数  
        SpringApplication.run(Springboot01HellowordApplication.class, args);
    }

}

SpringApplication.run分析

  • 分析该方法主要分两部分
  • 一是SpringApplication的实例化，
  • 二是run方法的执行；

2、SpringApplication

这个类主要做了以下四件事情：

  1. 推断应用的类型是普通的项目还是Web项目

  2. 查找并加载所有可用初始化器 ， 设置到initializers属性中

  3. 找出所有的应用程序监听器，设置到listeners属性中

  4. 推断并设置main方法的定义类，找到运行的主类

查看构造器：

java 复制代码 
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // ......
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    this.setInitializers(this.getSpringFactoriesInstances();
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = this.deduceMainApplicationClass();
}

3、run方法流程分析

跟着源码和这幅图就可以一探究竟了！

4、关于SpringBoot，谈谈关于你的理解;

  • 自动装配
  • run()
  • 全面接管SpringMVC的配置
相关推荐
天天摸鱼的java工程师9 分钟前
介绍 Java 中的线程池实现原理及自定义线程池的场景
后端
AI小智11 分钟前
AI竟会敲诈人类？16款主流模型压力测试揭露惊人风险
后端
小诸葛的博客11 分钟前
go语言实现进度条
开发语言·后端·golang
秋天的一阵风28 分钟前
GeekGeekRun：求职路上的开源神器🚀🚀🚀
前端·面试·求职
还是鼠鼠42 分钟前
SpringBoot-准备工作-工程搭建
java·数据库·spring boot·后端·spring·maven·mybatis
武子康1 小时前
Java-51 深入浅出 Tomcat 手写 Tomcat 类加载机制 双亲委派机制 生命周期 插件化
java·开发语言·spring boot·后端·spring·tomcat·springcloud
Derek_Smart1 小时前
基于Netty与Spring Integration的高并发工业物联网网关架构设计与实现
spring boot·物联网·netty
呆呆的小鳄鱼3 小时前
leetcode:面试题 08.06. 汉诺塔问题
leetcode·面试·职场和发展
LUCIAZZZ4 小时前
项目拓展-Spring实现策略类统一管理
java·jvm·spring boot·后端·spring·操作系统
zhendeWD4 小时前
springboot 提供的可扩展接口
java·spring boot·后端·spring
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解03Coze扣子平台完整体验和实践（附国内和国际版对比）0438、基于卷积神经网络(CNN)的车牌自动识别系统(matlab)05DeepSeek各版本说明与优缺点分析06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07C# 项目：导线计算 / 坐标转换 / 曲线放样 / 水准网 / 导线网平差08AI Agent | Coze 插件使用指南：从功能解析到实操步骤09YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】10Windows 本地部署MinerU详细教程