SoFunction
Updated on 2025-04-26

Three minutes to understand the principle of springboot

Introduction to Spring Boot

What is Spring Boot?

Spring Boot is an open source Java fast development framework based on Spring Framework, developed by the Pivotal team. It aims to simplify the initial construction and development process of Spring applications. The core goal of Spring Boot is to enable developers to get started quickly, reduce configuration, and quickly start and run a Spring-based application.

The main features of Spring Boot

Run independently: Spring Boot applications have Tomcat, Jetty, or Undertow embedded as web containers, and run them directly without deploying WAR files.

Automatic configuration: Spring Boot automatically configures Spring and related projects based on added dependencies. For example, after adding spring-boot-starter-web dependencies, Spring Boot will automatically configure Tomcat and Spring MVC.

No XML configuration required: Spring Boot advocates the use of Java configuration instead of traditional XML configuration, making the configuration more concise and easy to understand.

Microservice support: Spring Boot is deeply integrated with Spring Cloud, supporting the development of microservice architecture, and conveniently building distributed systems.

Health Checks and Monitoring: Spring Boot provides a wealth of monitoring and health checking functions, and the operation status of the application can be easily monitored through the actuator module.

Detailed explanation of the Spring Boot principle

Spring Boot is a fast development tool based on the Spring framework. It simplifies the development process of Spring applications through automatic configuration and conventions on the principles of superior configuration. The following is a detailed analysis of the working principle of Spring Boot from the aspects of core principles, startup process, automatic configuration mechanism, etc.

1. The core principle of Spring Boot

Conventions are better than configuration

  • Spring Boot reduces the developer's configuration workload through default configurations, such as the default embedded Tomcat server, the default configuration file path, etc.
  • Developers can use configuration files (e.g.or) Override the default configuration.

Auto-Configuration

  • Spring Boot automatically configures Spring applications based on project dependencies. For example, if the project has been introducedspring-boot-starter-web, Spring Boot will automatically configure Spring MVC and embedded Tomcat.
  • Automatic configuration pass@EnableAutoConfigurationAnnotation implementation.

Starter Dependencies

  • Spring Boot offers a range ofstarterDepend on, eachstarterAll contain a set of related dependency libraries. For example,spring-boot-starter-webIncludes Spring MVC, Tomcat, Jackson and other dependencies.
  • By starting dependencies, developers do not need to manually manage dependency versions, avoiding dependency conflicts.

Embedded server

  • Spring Boot integrates embedded servers (such as Tomcat, Jetty, and Undertow) by default. Developers do not need to deploy applications separately, and can directly run the JAR package to start applications.

2. Spring Boot startup process

The startup process of Spring Boot is mainly divided into the following steps:

Loading SpringApplication

  • pass()Method to start the application.
  • SpringApplicationThe class is responsible for initializing the application context, loading configuration, starting an embedded server, etc.

Loading the configuration file

  • Spring Boot will loadorConfiguration file and parse it intoEnvironmentObject.

Create an application context

  • Spring Boot creates corresponding application contexts based on application types (such as Servlets, Reactive) (such asAnnotationConfigServletWebServerApplicationContext）。

Perform automatic configuration

  • Spring Boot By@EnableAutoConfigurationAnnotation triggers automatic configuration mechanism, scanMETA-INF/The configuration class in the file and decide whether to load according to the conditions.

Start an embedded server

  • Spring Boot starts an embedded server (such as Tomcat) based on configuration and deploys the application to the server.

Publish application startup events

  • After the application starts, Spring Boot will be releasedApplicationStartedEventEvents, developers can execute custom logic by listening to the event.

3. Automatic configuration mechanism of Spring Boot

The automatic configuration of Spring Boot is one of its core features, and its principles are as follows:

@EnableAutoConfiguration annotation

  • @EnableAutoConfigurationAnnotations trigger Spring Boot's automatic configuration mechanism.
  • The annotation passed@Import()Import the automatic configuration class.

document

  • Spring Boot's automatic configuration class is defined inMETA-INF/in the file.
  • For example,spring-boot-autoconfigureIn the moduleThe file defines a large number of automatic configuration classes.

Conditional annotation

  • Spring Boot usage condition annotations (e.g.@ConditionalOnClass、@ConditionalOnMissingBean) to control the loading of the automatic configuration class.
  • For example,DataSourceAutoConfigurationClass is only inIt will only be loaded when it exists in the classpath.

Automatic configuration example

  • For example, when a project is introducedspring-boot-starter-webWhen dependencies, Spring Boot automatically configures the following:
    • Embedded Tomcat Server
    • The default configuration of Spring MVC (such as view parser, message converter)
    • Static resource processing (e.g.classpath:/staticTable of contents)

4. The core annotations of Spring Boot

@SpringBootApplication

  • This annotation is the entry annotation of Spring Boot application, and contains the functions of the following three annotations:
    • @Configuration: Identify this class as a configuration class.
    • @ComponentScan: Enable component scanning and automatically register beans.
    • @EnableAutoConfiguration: Enable automatic configuration.

@Configuration

  • Identify this class as a configuration class and you can define a bean.

@Bean

  • Used to define Bean objects in configuration classes.

@ConditionalOnClass

  • The configuration is loaded only when the specified class exists in the classpath.

@ConditionalOnMissingBean

  • The configuration is loaded only when the specified bean does not exist in the container.

5. Spring Boot configuration file

Configuration file format

  • Spring Boot SupportpropertiesandymlTwo configuration file formats.
  • For example:
=8080
=jdbc:mysql://localhost:3306/mydb
server:
  port: 8080
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb

Configuration file loading order

Spring Boot loads the configuration files in the following order:

  • In the project root directory/configTable of contents.
  • Project root directory.
  • classpath:/configTable of contents.
  • classpath:/Table of contents.

Multi-environment configuration

  • passapplication-{profile}.propertiesorapplication-{profile}.ymlFiles implement multi-environment configuration.
  • For example:
# 
=8081
# 
=80

6. Detailed explanation of Spring Boot's expansion mechanism

Customize Starter

  • Developers can create custom onesstarter, define automatic configuration classes and start dependencies.
  • CustomizestarterNeed to providefile, and define the automatic configuration class in it.

Custom annotations

  • Developers can create custom annotations based on Spring Boot's conditional annotations to achieve more flexible conditional control.

Custom Banner

  • Bysrc/main/resourcesCreated in the directoryFile, you can customize the banner at Spring Boot startup.

7. Pros and cons of Spring Boot

advantage

  • Quickly build independent Spring applications.
  • Provides default configurations to reduce development workload.
  • Integrate embedded servers to simplify deployment process.
  • Provide rich starting dependencies and simplify dependency management.

shortcoming

  • For beginners, the automatic configuration mechanism may not be transparent enough.
  • In large projects, the default configuration may need to be adjusted manually.

Summarize

Spring Boot greatly simplifies the development and deployment process of Spring applications through features such as automatic configuration, start-up dependencies and embedded servers. Its core principles include automatic configuration mechanism, conditional annotations, configuration file loading order, etc. By gaining a deep understanding of how Spring Boot works, developers can better leverage their features to build efficient, maintainable applications.

This is the end of this article about three minutes to help you understand the principles of springboot. For more related content on Spring Boot, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!