SoFunction
Updated on 2025-03-04

Spring Boot pluggable implementation process drill and principle analysis

introduction

Spring Boot is a project based on the Spring framework. Its design is to simplify the initial construction and development process of Spring applications. Spring Boot reduces a lot of XML configuration and manual settings by providing conventions over configuration, allowing developers to focus more on the implementation of business logic. This article will explore the background history, business scenarios, functional points and underlying principles of Spring Boot in depth, and simulate the startup process of Spring Boot through Java code handwriting, providing developers with a comprehensive understanding.

1. Background history of Spring Boot

1.1 The Origin and Development of Spring Boot

Originally developed by the Pivotal team, Spring Boot officially released version 1.0.0 in April 2014. Spring Boot was born because the Spring framework has a large number of XML configurations and complex dependency management during the development process, resulting in inefficient development. To solve this problem, the Pivotal team proposed the Spring Boot project, aiming to simplify the development and deployment of Spring applications through features such as automatic configuration and starting dependencies.

1.2 Iteration and update of Spring Boot

Since its release, Spring Boot has undergone multiple iterations and updates. For example, Spring Boot 1.2 and 1.3 released in 2015 brings more features and improvements, such as enhanced Actuator and better testing support. The Spring Boot 2.0 version released in 2017 is a major upgrade. It is built on Spring Framework 5, supports Java 8 and above, and introduces new features such as responsive programming.

2. Spring Boot's business scenarios

2.1 Microservice architecture

In the microservice architecture, each service is an independent application that needs to be quickly built and deployed. Spring Boot has become one of the preferred frameworks in microservice architectures by providing the ability to build and deploy quickly. Developers can use Spring Boot to quickly create a fully functional microservice application without paying attention to the configuration details of the underlying framework, thereby improving development efficiency.

2.2 Web application development

Spring Boot provides rich web development features, such as RESTful API, WebSocket, etc. Through automatic configuration and starting dependencies, developers can quickly build a web application without manually configuring components such as Servlet containers, Spring MVC, etc. This makes Spring Boot an ideal choice for web application development.

2.3 Data access and cache management

Spring Boot integrates data access modules such as Spring Data JPA, Spring Data MongoDB, as well as cache management tools such as Ehcache and Redis. Through automatic configuration, developers can easily perform database operations and access, as well as improve application performance and scalability.

3. Spring Boot's functional points

3.1 Automatic configuration

Spring Boot's automatic configuration is one of its core features. By inferring the configuration required by the application, Spring Boot automatically registers the appropriate bean for the application, simplifying the tedious manual configuration process. For example, when a project is introducedspring-boot-starter-webWhen dependencies, Spring Boot will automatically configure components such as Tomcat and Spring MVC.

3.2 Starting dependency

Starting dependencies are a predefined set of dependencies provided by Spring Boot, which contains the dependencies of commonly used libraries and frameworks. Developers can quickly build a complete application by simply adding corresponding starting dependencies to the project. For example,spring-boot-starter-webStarting dependencies include all the basic components required to build a web application.

3.3 Embed server

Spring Boot has built-in multiple servers such as Tomcat, Jetty and Undertow, allowing applications to be packaged into an executable JAR file and run directly without the need for an external web server. This greatly simplifies the deployment process of the application.

3.4 External configuration

Spring Boot supports external configuration, allowing developers to flexibly configure applications through configuration files, environment variables, etc. This makes the configuration of the application more flexible and maintainable, making it easier to deploy and configure in different environments.

3.5 Actuator module

Spring Boot's Actuator module provides a set of predefined REST endpoints for monitoring and managing Spring Boot applications. Actuator allows developers to easily implement application health checks, performance monitoring and other functions, which are very suitable for use in production environments.

4. The underlying principle of Spring Boot

4.1 Core components and annotations

  • @SpringBootApplication: This is a composite annotation, combined with@Configuration、@EnableAutoConfigurationand@ComponentScanThe functions of three annotations. It is usually used on the main boot class to enable automatic configuration and component scanning of Spring Boot.
  • @Configuration: means that this class is a configuration class, which is equivalent to a traditional Spring XML configuration file. In the configuration class, you can use@BeanAnnotation to define and register beans.
  • @EnableAutoConfiguration: Tell Spring Boot to automatically configure projects based on added jar dependencies. For example, ifspring-boot-starter-webDependency, Spring Boot will automatically configure Tomcat and Spring MVC.
  • @ComponentScan: Let Spring Boot automatically scan the current package and its subpackages@Component、@Repository、@Service、@Controlleretc. class annotated and register them as beans.

4.2 SpringApplication Class

SpringApplicationThe class is the startup class of Spring Boot, which is responsible for starting the entire Spring application context. existmainIn the method, by calling(, args)Method to start Spring Boot application.

4.3 Startup process

The startup process of Spring Boot can be summarized into the following steps:

  • Read configuration files: Spring Boot will be inresourcesRead under folderorConfiguration files, These configuration files contain various configuration information of the application.
  • Initialize Spring application context:existmainIn the method, by calling(, args)Method to initialize Spring application context. This process includes assembly parameters and environment, creationApplicationContext, register various components, etc.
  • Automatic configuration: Spring Boot will automatically configure the project based on the added jar dependencies and information in the configuration file. This process is done through@EnableAutoConfigurationImplemented by annotation, it will automatically configure the project based on the jar dependencies in the classpath.
  • Component scanning and registration：@ComponentScanAnnotations will let Spring Boot automatically scan the annotation classes in the current package and its subpackages and register them as beans. These beans will be stored in Spring's IoC container for subsequent use.
  • Publish an event: During Spring Boot startup, multiple events will be published, such asApplicationStartedEvent、ApplicationEnvironmentPreparedEvent、ApplicationPreparedEventandApplicationReadyEventwait. These events can be captured and processed by custom listeners to implement some custom startup logic.

4.4 Conditional annotation

Spring Boot provides multiple conditional annotations to enable or disable automatic configuration under specific conditions:

  • @ConditionalOnClass: The corresponding automatic configuration will only be enabled when the specified class exists in the classpath.
  • @ConditionalOnMissingBean: The configuration will only be applied when there is no specified bean in the container.
  • @ConditionalOnProperty: Decide whether to load the configuration based on whether a property in the configuration file is enabled.

5. Handwriting simulation of Spring Boot startup process

5.1 Create a Spring Boot Project

First, we need to create a Spring Boot project. Here we use Maven to manage project dependencies.

<project xmlns="/POM/4.0.0"
xmlns:xsi="http:///2001/XMLSchema-instance"
xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.">
<modelVersion>4.0.0</modelVersion>
<groupId></groupId>
<artifactId>springboot-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId></groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.5.0</version>
</parent>
<dependencies>
<dependency>
<groupId></groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
</project>

5.2 Create the main startup class

Next, we create a main startup class and use@SpringBootApplicationAnnotation to identify it.

package ;
import ;
import ;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
        (, args);
    }
}

5.3 Create a controller class

To verify the startup of the Spring Boot application, we create a simple controller class to handle HTTP requests.

package ;
import ;
import ;
@RestController
public class HelloController {
@GetMapping("/hello")
public String sayHello() {
return "Hello, Spring Boot!";
    }
}

5.4 Run the project

Now we can runDemoApplicationClassicmainMethod to start Spring Boot application. After the startup is successful, we can access ithttp://localhost:8080/helloTo verify that the application is working properly.

6. Automatic configuration function of handwriting simulation Spring Boot

6.1 Creating an automatic configuration class

In order to simulate the automatic configuration function of Spring Boot, we need to create an automatic configuration class. This class will use conditional annotations to determine whether to load certain configurations based on dependencies in the classpath and properties in the configuration file.

package ;
import ;
import ;
import ;
import ;
@Configuration
public class MyAutoConfiguration {
@Bean
@ConditionalOnClass(name = "")
@ConditionalOnMissingBean(name = "myService")
public MyService myService() {
return new MyService();
    }
}

6.2 Create a service class

Next, we create a service class that will be instantiated and registered as a bean in the autoconfiguration class.

package ;
public class MyService {
public void doSomething() {
        ("Doing something...");
    }
}

6.3 Register automatic configuration class

In order for the automatic configuration class to take effect, we need to register it in the Spring Boot startup class. This can be done by@SpringBootApplicationAdded in the annotationscanBasePackagesto implement the properties, or to import the automatic configuration class by creating a new configuration class.

package ;
import ;
import ;
import ;
import ;
@SpringBootApplication
@Import()
public class DemoApplication {
public static void main(String[] args) {
        (, args);
    }
}

6.4 Verify automatic configuration

Finally, we can verify that the automatic configuration is in effect by running the Spring Boot application. If everything is configured correctly,MyServiceThe class will be instantiated and registered as a bean, which we can use through dependency injection after the application is started.

7. Summary

This article provides developers with a comprehensive understanding by deeply exploring the background history, business scenarios, functional points and underlying principles of Spring Boot, and simulates the startup process and automatic configuration functions of Spring Boot through Java code handwriting. Spring Boot greatly simplifies the development and deployment process of Spring applications by providing conventions that outperform configuration and rich starting dependencies. I hope this article can help developers better master Spring Boot usage skills and improve development efficiency.

This is the article about Spring Boot pluggable implementation process drills and principle analysis. For more relevant Spring Boot pluggable content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!