Spring Boot 快速入门与核心原理详解

🕗 发布于 2024-10-13 15:32 开发语言 java spring

引言

在上一篇文章中，我们详细探讨了 Spring 框架中的事件监听与发布机制。本文将转向 Spring Boot，介绍如何快速入门 Spring Boot，并深入探讨其核心原理。Spring Boot 是由 Pivotal 团队提供的全新框架，旨在简化 Spring 应用的初始搭建以及开发过程。它通过约定大于配置的理念，极大地减少了配置的工作量，使得开发者可以更专注于业务逻辑的实现。

1. Spring Boot 快速入门

1.1 什么是 Spring Boot？

Spring Boot 是 Spring 框架的一个扩展，旨在简化新 Spring 应用的初始搭建和开发过程。它通过自动配置、起步依赖和生产就绪功能，使得开发者可以快速创建独立的、生产级别的基于 Spring 框架的应用程序。

1.2 创建第一个 Spring Boot 应用

1.2.1 使用 Spring Initializr

Spring Initializr 是一个 web 工具，可以帮助开发者快速生成 Spring Boot 项目的初始结构。以下是使用 Spring Initializr 创建项目的步骤：

访问 Spring Initializr。
选择项目的基本信息，如项目类型（Maven 或 Gradle）、语言（Java、Kotlin 或 Groovy）、Spring Boot 版本等。
添加所需的依赖，如 Web、Thymeleaf、JPA 等。
点击“Generate”按钮下载项目压缩包。
解压项目压缩包，并使用 IDE 打开项目。

1.2.2 项目结构

生成的项目结构通常如下所示：

my-spring-boot-app/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/demo/
│   │   │       └── DemoApplication.java
│   │   └── resources/
│   │       ├── application.properties
│   │       └── static/
│   │       └── templates/
│   └── test/
│       └── java/
│           └── com/example/demo/
│               └── DemoApplicationTests.java
├── pom.xml (或 build.gradle)

1.2.3 编写一个简单的 REST API

在 DemoApplication.java 中添加一个简单的 REST 控制器：

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @RestController
    public class HelloController {

        @GetMapping("/hello")
        public String hello() {
            return "Hello, Spring Boot!";
        }
    }
}

运行 DemoApplication 类中的 main 方法，启动 Spring Boot 应用。访问 http://localhost:8080/hello，你应该会看到 "Hello, Spring Boot!" 的响应。

2. Spring Boot 核心原理

2.1 自动配置

Spring Boot 的自动配置功能是其最强大的特性之一。它通过扫描类路径中的 jar 包，自动配置 Spring 应用所需的各种 Bean。自动配置的实现主要依赖于 @SpringBootApplication 注解和 @EnableAutoConfiguration 注解。

2.1.1 `@SpringBootApplication` 注解

@SpringBootApplication 注解是一个组合注解，包含了以下几个注解：

@Configuration：标记当前类为配置类。
@EnableAutoConfiguration：启用自动配置。
@ComponentScan：启用组件扫描，自动发现并注册 Bean。

2.1.2 `@EnableAutoConfiguration` 注解

@EnableAutoConfiguration 注解会触发 Spring Boot 的自动配置机制。Spring Boot 会根据类路径中的 jar 包和 application.properties 文件中的配置，自动配置各种 Bean。例如，如果类路径中存在 H2 数据库的 jar 包，Spring Boot 会自动配置一个嵌入式的 H2 数据库。

2.2 起步依赖

起步依赖（Starter Dependencies）是 Spring Boot 提供的一组依赖管理工具，旨在简化依赖管理。每个起步依赖都包含了一组常用的依赖，开发者只需在项目中声明所需的起步依赖，即可快速引入一组相关的依赖。

例如，要创建一个 Web 应用，只需在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

这将自动引入 Spring MVC、Tomcat、Jackson 等依赖。

2.3 生产就绪功能

Spring Boot 提供了一系列生产就绪功能，如外部化配置、健康检查、度量指标等，这些功能可以帮助开发者更好地管理和监控应用。

2.3.1 外部化配置

Spring Boot 支持多种外部化配置方式，如 application.properties 文件、环境变量、命令行参数等。通过外部化配置，开发者可以轻松地在不同环境中切换配置。

例如，在 application.properties 文件中配置数据库连接：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

2.3.2 健康检查

Spring Boot Actuator 是一个生产就绪功能模块，提供了多种监控和管理端点。通过启用 Actuator，开发者可以轻松地监控应用的健康状况、度量指标等。

例如，启用健康检查端点：

import org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.web.server.ManagementPortType;
import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
import org.springframework.boot.actuate.endpoint.web.EndpointLinksResolver;
import org.springframework.boot.actuate.endpoint.web.EndpointMapping;
import org.springframework.boot.actuate.endpoint.web.EndpointMediaTypes;
import org.springframework.boot.actuate.endpoint.web.ExposableWebEndpoint;
import org.springframework.boot.actuate.endpoint.web.WebEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.annotation.ControllerEndpoint;
import org.springframework.boot.actuate.health.HealthEndpoint;
import org.springframework.boot.actuate.health.HealthEndpointGroup;
import org.springframework.boot.actuate.health.HealthEndpointGroups;
import org.springframework.boot.actuate.health.HealthEndpointWebExtension;
import org.springframework.boot.actuate.health.ReactiveHealthContributorRegistry;
import org.springframework.boot.actuate.health.ReactiveHealthIndicator;
import org.springframework.boot.actuate.health.StatusAggregator;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.http.MediaType;
import org.springframework.util.Assert;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
@ConditionalOnClass({ ReactiveHealthContributorRegistry.class, HealthEndpoint.class })
@ConditionalOnProperty(prefix = "management.health", name = "enabled", matchIfMissing = true)
@EnableConfigurationProperties({ HealthEndpointProperties.class, WebEndpointProperties.class, CorsEndpointProperties.class })
public class HealthEndpointConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public HealthEndpoint healthEndpoint(HealthContributorRegistry healthContributorRegistry,
                                         StatusAggregator statusAggregator) {
        return new HealthEndpoint(healthContributorRegistry, statusAggregator);
    }

    @Bean
    @ConditionalOnMissingBean
    public HealthEndpointWebExtension healthEndpointWebExtension(HealthEndpoint healthEndpoint,
                                                                 HealthEndpointProperties properties,
                                                                 Environment environment,
                                                                 EndpointMediaTypes endpointMediaTypes,
                                                                 CorsEndpointProperties corsProperties,
                                                                 WebEndpointProperties webEndpointProperties,
                                                                 List<ReactiveHealthIndicator> reactiveHealthIndicators,
                                                                 List<HealthEndpointGroup> groups) {
        Map<String, HealthEndpointGroup> groupMap = groups.stream()
                .collect(Collectors.toMap(HealthEndpointGroup::getName, (group) -> group));
        HealthEndpointGroups healthEndpointGroups = new HealthEndpointGroups(groupMap);
        ReactiveHealthContributorRegistry registry = new ReactiveHealthContributorRegistry(reactiveHealthIndicators);
        return new HealthEndpointWebExtension(healthEndpoint, properties, environment, endpointMediaTypes,
                corsProperties, webEndpointProperties, healthEndpointGroups, registry);
    }

    @ControllerEndpoint(id = "health")
    public static class HealthController {

        private final ExposableWebEndpoint endpoint;

        public HealthController(ExposableWebEndpoint endpoint) {
            Assert.notNull(endpoint, "Endpoint must not be null");
            this.endpoint = endpoint;
        }

        public Mono<Map<String, Object>> health(ServerWebExchange exchange) {
            return this.endpoint.invoke(exchange).map((response) -> (Map<String, Object>) response.getBody());
        }
    }
}

3. Spring Boot 最佳实践

3.1 保持项目结构清晰

保持项目结构清晰有助于提高代码的可读性和可维护性。建议按照以下结构组织项目：

src/
├── main/
│   ├── java/
│   │   └── com/example/demo/
│   │       ├── controller/
│   │       ├── service/
│   │       ├── repository/
│   │       ├── config/
│   │       └── DemoApplication.java
│   └── resources/
│       ├── application.properties
│       └── static/
│       └── templates/
└── test/
    └── java/
        └── com/example/demo/
            ├── controller/
            ├── service/
            ├── repository/
            └── DemoApplicationTests.java

3.2 使用配置文件管理环境变量

使用 application.properties 文件管理环境变量，可以轻松地在不同环境中切换配置。建议为不同的环境创建不同的配置文件，如 application-dev.properties、application-prod.properties 等。

3.3 使用 Actuator 监控应用

启用 Actuator 可以帮助开发者更好地监控和管理应用。建议启用以下端点：

/actuator/health：健康检查
/actuator/metrics：度量指标
/actuator/info：应用信息

3.4 使用 Docker 部署应用

使用 Docker 部署应用可以提高部署的可靠性和一致性。建议为应用创建一个 Dockerfile，并使用 Docker Compose 管理多服务应用。

4. Spring Boot 面试题解析

4.1 什么是 Spring Boot？

答案：Spring Boot 是 Spring 框架的一个扩展，旨在简化新 Spring 应用的初始搭建和开发过程。它通过自动配置、起步依赖和生产就绪功能，使得开发者可以快速创建独立的、生产级别的基于 Spring 框架的应用程序。

4.2 Spring Boot 的核心特性有哪些？

答案：

自动配置：根据类路径中的 jar 包和 application.properties 文件中的配置，自动配置各种 Bean。
起步依赖：简化依赖管理，通过声明起步依赖快速引入一组相关的依赖。
生产就绪功能：提供一系列生产就绪功能，如外部化配置、健康检查、度量指标等。

4.3 `@SpringBootApplication` 注解的作用是什么？

答案：@SpringBootApplication 注解是一个组合注解，包含了以下几个注解：

@Configuration：标记当前类为配置类。
@EnableAutoConfiguration：启用自动配置。
@ComponentScan：启用组件扫描，自动发现并注册 Bean。

4.4 如何启用 Actuator 端点？

答案：在 pom.xml 中添加 spring-boot-starter-actuator 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

然后在 application.properties 文件中启用所需的端点，例如：

management.endpoints.web.exposure.include=health,info,metrics

4.5 如何使用 Docker 部署 Spring Boot 应用？

答案：首先，创建一个 Dockerfile 文件，内容如下：

FROM openjdk:11-jre-slim
COPY target/my-spring-boot-app.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

然后，构建 Docker 镜像并运行容器：

docker build -t my-spring-boot-app .
docker run -p 8080:8080 my-spring-boot-app

5. 总结

通过本文，我们详细介绍了 Spring Boot 的快速入门方法，并深入探讨了其核心原理，包括自动配置、起步依赖和生产就绪功能。理解这些核心原理对于开发高效、可靠的 Spring Boot 应用非常重要。希望本文对你有所帮助，欢迎继续关注后续文章！

6. 扩展阅读

官方文档：Spring Boot Reference Guide
Spring Boot 官网：Spring Boot Official Website
书籍推荐：《Spring Boot in Action》、《Spring Boot Recipes》

如果你有任何疑问或建议，欢迎在评论区留言交流！

原文地址：https://blog.csdn.net/pjx987/article/details/142880025

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【Java】jvisualvm工具
下一篇：谷歌-BERT-第一步：模型下载

Linux内核 -- 内核热重启之 kexec 工具的使用
在嵌入式设备上使用kexec进行热重启可以有效减少设备重启时间。这对于一些需要高可用性的系统非常有用，比如路由器、工业控制设备等。本教程将介绍如何在嵌入式设备上使用kexec，并详细说明可能出现的错误
阅读更多2024-10-15
数据分析基本架构知识点
可以是数据库（如MySQL、Oracle等）、文件（如CSV、Excel文件）、日志文件（记录系统活动）、网络数据（如网页抓取）等。- 是一个集成的、面向主题的、相对稳定的、反映历史变化的数据集合，如
阅读更多2024-10-15
【修订中】ffmpeg 知识点
brew install ffmpeg 时间有点长需要挂上代理。
阅读更多2024-10-15
服务器虚拟化
#热点
阅读更多2024-10-15
Harmony OS原生端渲染RTMP流功能实现
鸿蒙XComponent控件渲染rtmp流实现
阅读更多2024-10-15
unity 调整skinweight (皮肤权重)，解决：衣服穿模问题
最近遇到一个问题，人物模型的衣服穿模（就是露肉了），找了很久这个问题。好记性不如烂笔头！
阅读更多2024-10-15
使用tgz包下载安装clickhouse低版本
再次使用journalctl -u clickhouse-server查看是否有错误，发现又缺个目录。发现缺失了目录/var/log/clickhouse-server，我们直接创建目录并且赋权限。使
阅读更多2024-10-15
你知道C++多少——栈和队列
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。
阅读更多2024-10-15
鸿蒙开发案例：通过三杯猜球学习显示动画
表演者会将一个小球放在一个杯子下面，然后将三个杯子快速地交换位置，参与者则需要猜出最终哪个杯子下面有小球。本文将介绍如何使用HarmonyOS NEXT技术，如装饰器、状态管理和动画，来实现一个基于浏
阅读更多2024-10-15
【Linux基础】03 Linux环境基础开发工具使用
yumyum。
阅读更多2024-10-15