springboot学习-1

Spring Framework Overview

Core Container

在 Spring 中，核心容器包括 Beans、Core、SpEL（Spring Expression Language）、Context。这些模块构成了 Spring 框架的核心，并提供了关键的功能来管理对象、处理依赖、执行表达式以及创建应用程序上下文。

Beans:

Beans 模块是 Spring 框架的核心部分，负责管理对象（即 “bean”）。它包含了 IoC（Inverse of Control，控制反转）和 DI（Dependency Injection，依赖注入）的实现。通过 Beans 模块，Spring 能够实例化、装配和管理应用程序中的各种对象，这些对象通常被称为 bean。使用 Beans 模块，开发者可以通过 XML 配置文件或基于注解的方式定义 bean，并让 Spring 容器来管理这些 bean 的生命周期和依赖关系。

Core:

Core 模块提供了 Spring 框架的核心功能和工具类。它包括了核心的工具类和辅助功能，用于处理常用的任务，例如资源加载、类型转换、事件发布等。Core 模块也包含了 Spring 框架中许多基本的类和接口，为其他模块提供基础支持。

SpEL (Spring Expression Language)

SpEL 是一种表达式语言，允许在运行时对 Spring 应用程序上下文中的对象执行评估和操作。它提供了一种强大的方式来引用 bean、调用方法、进行条件判断、进行算术运算等。SpEL 可以用于 XML 配置文件、注解、Spring Security 等各个方面，为开发者提供了灵活且强大的表达式语言功能。

Context

Context 模块是 Spring 框架中最重要的模块之一。它构建在 Beans 和 Core 模块的基础上，提供了创建和管理 bean 的应用程序上下文的能力。ApplicationContext 是 Context 模块的核心接口，它表示整个应用程序的上下文环境。ApplicationContext 负责加载 bean 定义、对 bean 进行实例化、解析依赖、管理 bean 的生命周期等。通过 ApplicationContext，Spring Boot 应用程序能够轻松地管理 bean、处理依赖注入，并提供各种功能，如国际化、事件传播等。

Infrustructure

AOP（Aspect-Oriented Programming）

AOP 是一种编程范式，它允许将跨越应用程序的功能模块化，例如日志记录、事务管理等，这些功能不依赖于应用程序的业务逻辑。AOP 的核心思想是通过定义横切关注点（cross-cutting concerns），将它们从主要的业务逻辑中分离出来，以便在不同的模块中重复使用。在 Spring Boot 中，AOP 允许通过特定注解或配置来创建切面，并通过 advice（通知）和 pointcut（切入点）来定义在何处执行横切逻辑。

Aspects（切面）

在 AOP 中，切面是横切关注点的实现。它定义了 advice 和 pointcut，用于描述在何处执行横切逻辑以及具体的操作。在 Spring Boot 中，开发者可以定义切面，将其应用于应用程序的不同部分，并在特定的连接点（例如方法执行前后、抛出异常时等）执行特定的操作，如日志记录、性能监控、事务管理等。

Instrumentation（仪表化）

仪表化是指对应用程序进行监控、诊断和分析的过程。在 Spring Boot 中，Instrumentation 提供了一些工具和机制来对应用程序进行监控和分析，例如通过使用 Spring Boot Actuator（执行器）来暴露端点以获取应用程序的健康状况、度量信息、审计日志等。这使得开发者能够更好地了解应用程序的运行情况，并进行必要的优化和调整。

Messaging（消息传递）

消息传递是指在应用程序内部或不同应用程序之间进行消息交换的机制。在 Spring Boot 中，Messaging 模块提供了丰富的消息传递功能，包括使用 Spring 的消息中间件支持（如 RabbitMQ、Apache Kafka、ActiveMQ 等），并提供了各种消息处理器、消息监听器和消息通道等组件，使得开发者可以轻松地实现消息驱动的应用程序或微服务。

Data Access Layer

数据访问层（Data Access Layer）是应用程序中负责处理数据存储和检索的模块。这个层级包含了一系列技术和工具，使得应用程序可以与不同类型的数据存储进行交互，包括关系型数据库、对象数据库、消息队列等。

JDBC（Java Database Connectivity）

JDBC 是 Java 用于与关系型数据库交互的标准 API。它提供了一种标准化的方式来连接、查询和更新数据库。在 Spring Boot 中，JDBC 提供了一些模板和工具类，简化了与数据库的交互，包括对连接管理、SQL 执行、事务处理的支持。Spring Boot 提供的 JdbcTemplate 和 NamedParameterJdbcTemplate 等类可以帮助开发者更轻松地执行 SQL 查询和更新。

ORM（Object-Relational Mapping）

ORM 是一种技术，用于在关系型数据库和面向对象编程语言之间建立映射关系，使得开发者可以使用面向对象的方式操作数据库。在 Spring Boot 中，ORM 框架如 Hibernate、Spring Data JPA 等被广泛使用。这些框架简化了与数据库的交互，允许开发者使用对象来表示数据库中的表和关系，并提供了丰富的功能来执行 CRUD 操作、查询、关联映射等。

Transactions（事务）:

事务是一系列数据库操作的逻辑单元，要么全部成功执行，要么全部回滚到初始状态。Spring Boot 提供了对声明式事务的支持，可以通过注解或 XML 配置的方式来管理事务。这使得开发者可以更容易地控制事务的边界、隔离级别和传播行为，确保数据的完整性和一致性。

OXM（Object XML Mapping）:

OXM 提供了对象与 XML 之间的映射能力。在 Spring Boot 中，它允许将 Java 对象和 XML 数据进行相互转换。Spring Framework 提供了支持，使开发者能够方便地进行对象到 XML 或 XML 到对象的转换，如使用 JAXB（Java Architecture for XML Binding）或其他的 XML 映射工具。

JMS（Java Message Service）

JMS 是 Java 平台上用于实现消息驱动的异步通信的 API。Spring Boot 中的 JMS 支持允许开发者利用消息队列（如 ActiveMQ、RabbitMQ 等）进行异步消息的发送和接收。通过 JMS，应用程序可以更高效地进行解耦和异步通信，从而提高系统的可伸缩性和可靠性。

Web Layer

Web Layer 在 Spring 框架中起着至关重要的作用，它使得开发者能够便捷地处理来自客户端的请求和响应，并通过不同的功能模块（如 Servlet、WebSocket、Web 等）来实现各种类型的 Web 应用程序，包括传统的基于 HTTP 请求响应的网页应用、实时通信应用、RESTful API 服务等。

Servlet：

Servlet 是 Java 平台上用于处理 Web 请求和响应的技术。Spring Boot 基于 Servlet 技术构建了强大的 Web 应用程序。Spring Boot 提供了 Servlet 容器（例如 Tomcat、Jetty、Undertow 等）的嵌入式支持，使得开发者能够以独立于外部容器的方式轻松创建和运行 Web 应用程序。

WebSocket

WebSocket 是一种在客户端和服务器之间建立持久连接的通信协议，它允许在单个 TCP 连接上进行全双工通信。Spring Boot 提供了对 WebSocket 的支持，使得开发者能够实现实时性强、双向通信的功能。通过 Spring 的 WebSocket 支持，开发者可以轻松地构建基于 WebSocket 的应用程序，如聊天应用、实时数据更新等。

Web

Spring Boot 的 Web 模块提供了一系列用于构建 Web 应用程序的功能和工具。它包括了诸如控制器（Controller）、路由（Routing）、请求映射（Request Mapping）、数据绑定、视图解析、拦截器、过滤器等等。通过 Spring Boot 的 Web 支持，开发者可以使用注解（如 @Controller、@RestController）、拦截器、模板引擎（如 Thymeleaf、FreeMarker）等，快速搭建和开发 Web 应用程序。

Test Layer

在 Spring 中，测试层（Test Layer）是用于编写和执行各种类型测试的关键部分，主要包括单元测试（Unit Test）、集成测试（Integration Test）和模拟测试（Mock Test）。这些测试层旨在确保应用程序的各个部分在各种情况下都能够按预期进行工作。

单元测试（Unit Test）:

单元测试是针对应用程序中的最小单元（通常是方法或类）进行的测试。在 Spring Boot 中，使用 JUnit 或 TestNG 等单元测试框架编写单元测试是常见的做法。单元测试的目的是验证代码的各个单元是否按预期工作，通常会对方法进行测试，确保其行为符合预期，并能够正确处理各种输入。

集成测试（Integration Test）

集成测试是验证应用程序不同组件之间的交互是否正确的测试。在 Spring Boot 中，集成测试涉及多个模块、组件或服务的交互。这种测试可以用于确保不同层次（如控制器、服务、数据库访问层等）之间的整合是正确的，确保整个应用程序在集成的情况下能够正常工作。

模拟测试（Mock Test）

模拟测试是一种在测试过程中模拟外部依赖或行为的测试方式。在 Spring Boot 中，使用 Mockito、EasyMock 或 PowerMock 等框架来模拟依赖、服务或对象的行为是常见的做法。模拟测试允许开发者隔离测试环境，减少对外部依赖的影响，同时专注于测试代码本身的逻辑。

项目初配置

虽然跟着视频或者书本一步一步做下来，但还是踩了不少坑，所以记录一下。

Gradle和Maven都是用于构建和管理Java项目的工具。如果没有它们，我们就需要手动把一个个Jar包都下载下来，特别麻烦。有了他们我们就可以通过对某一文件进行修改，让它们管理这些Jar包。(类比于npm 和 pip)

Maven：

• Maven 是一个基于项目对象模型（Project Object Model，POM）的项目管理工具。它使用 XML 格式的 POM 文件来描述项目结构、依赖关系和构建过程。

• Maven 提供了一种标准化的方式来构建项目、管理依赖、运行测试、生成文档和发布项目。它有一组约定的目录结构和生命周期阶段，简化了项目的构建和管理。

• Maven 的中心仓库存储了大量的开源库和依赖项，允许开发者通过声明依赖关系来获取所需的库。
• 构建过程： 当你使用 Maven 构建（build）应用程序时，Maven会负责管理构建路径和类路径。这意味着 Maven 将自动执行以下操作：
  • 依赖处理： 根据你项目配置文件（pom.xml）中定义的依赖，Maven将自动下载所需的 JAR 文件并将其添加到项目的构建路径中。
  • 编译和打包： Maven 将负责编译你的代码，并将其打包成目标文件（如 JAR、WAR 等）。
• 类路径管理： Maven会根据项目的需要自动管理类路径。当你运行（run）应用程序时，Maven会确保应用程序能够访问并使用所需的类和依赖。这包括添加所需的 JAR 文件到类路径，以便你的应用程序可以正确地加载和运行。

Maven运行策略

当 Maven 开始构建项目时，它会根据项目配置文件中的信息，检查本地仓库，如果本地仓库没有依赖包，就会检查中央仓库，获取项目所需的所有依赖，并将这些包下载到本地仓库作为缓存。然后，它将这些依赖整合到项目的构建过程中，进行编译、测试和打包等操作。

Pom文件架构

POM 文件的结构通常包括以下主要部分：

1. Project Metadata（项目元数据）:
   • <modelVersion>：POM 文件的模型版本。
   • <groupId>、<artifactId>、<version>：定义了项目的坐标信息，用于唯一标识和定位项目。
   • <packaging>：定义项目的打包方式，如 jar、war、pom 等。
   • <name>、<description>：项目名称和描述信息。
   • <url>：项目主页的 URL。

示例：

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-project</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <name>My Project</name>
    <description>This is a sample Maven project</description>
    <url>https://github.com/example/my-project</url>
    <!-- ...其他配置... -->
</project>

1. Dependencies（依赖项）: <dependencies> 部分用于声明项目所依赖的外部库、框架或模块。每个依赖都包含 <groupId>、<artifactId> 和 <version> 三个元素，指定了所需的依赖库、版本等信息。

示例：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.8</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
    <!-- ...其他依赖... -->
</dependencies>

1. Plugins（插件）: <build> 部分可以包含 <plugins> 元素，用于配置构建过程所需的插件。这些插件可以执行编译、测试、打包、部署等各种构建任务。

示例：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.8.1</version>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.5.4</version>
        </plugin>
        <!-- ...其他插件... -->
    </plugins>
</build>

这些部分构成了 Maven POM 文件的基本结构，通过定义项目的元数据、依赖项、插件信息，Maven 能够根据 POM 文件来管理项目的构建、依赖和发布等工作。

Maven Dependency Coordinates

Maven 项目中依赖坐标（Dependency Coordinates）的重要性和构成要素，以及在添加依赖时的最佳实践。

1. Dependency Coordinates（依赖坐标）：
   • 依赖坐标是 Maven 中用于唯一标识和定位项目依赖的信息。它由 Group ID、Artifact ID 和 Version 组成。
   • Group ID（组织ID）：指定了依赖所属的组织或机构。
   • Artifact ID（构件ID）：指定了依赖项目的名称。
   • Version（版本）：可选的，用于指定依赖的版本。建议在依赖中包含版本号，这有助于实现可重复的构建（repeatable builds）。
2. 添加依赖：
   • 要添加给定的依赖项目到 Maven 项目中，需要了解该依赖项目的 Group ID 和 Artifact ID。版本号是可选的，但最好也包含以实现可重复的构建。
   • 最佳实践是在添加依赖时包含版本号，这有助于确保构建的一致性和可重复性，因为不同版本的依赖可能会导致不同的行为或问题。
3. DevOps（开发运维）：
   • 在 DevOps 中，强调包括依赖版本号是一个良好的实践，有助于确保构建的一致性和可重复性。
   • 依赖坐标（Group ID、Artifact ID 和 Version）一起被称为 GAV。

具体操作

maven项目导入到idea之后，会自动开始下载内容。但是，可能网络超时报错，导致一些包无法下下来。此时我们需要修改maven的settings.xml文件

我是mac系统，用homebrew下载的maven。在idea中，默认的settings.xml文件路径找不到这个文件的如下：

因此，我们需要在终端输入mvn -v 来确认maven的安装路径：

然后，进入这个安装路径，settings.xml就在里面的conf文件夹中.现在，我们需要把idea中默认的路径覆盖掉。然后重新加载maven，就可以正常下载、运行文件了。

第二天再打开发现很多annotation都变成红色的了，可能是项目没加载完全，需要重启IDea或者重新下载Maven源文件。

Gradle

• Gradle 是一个基于 Groovy 和 Kotlin 的构建工具。它使用了一种基于DSL（领域特定语言）的方式来描述项目构建。
• Gradle 提供了灵活性和强大的定制能力，允许开发者使用 Groovy 或 Kotlin 编写脚本来定义构建过程，处理依赖关系和任务。
• 它支持增量构建，能够智能地识别需要重新构建的部分，提高了构建效率。

在导入gradle项目之后，idea也会自动下载，但是我出现了超时无法下载的情况。此时我应该修改两处地方：

在gradle文件夹下的gradle-wrapper.prperties,将distributionUrl改为国内镜像

在build.gradle中，把repository改为国内镜像

改完后，重新构建gradle，就可以正常下载运行了

添加REST Controller

我们可以新建一个rest文件夹，在里面创建RESTful API，如下：

package com.jasoncode.springboot.demo.myapp.rest;

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

@RestController
public class FunRestcontroller {
    @GetMapping("/")
    public String sayHello(){
        return "Hello world!";
    }
}

这段代码是一个简单的Spring Boot应用程序中的REST Controller示例。在这个示例中，我们创建了一个名为 FunRestController 的类，并使用 @RestController 注解标记它，表示这是一个REST控制器。

其中包含一个 sayHello() 方法，它使用 @GetMapping("/") 注解，指示当收到根路径的GET请求时，将执行该方法。在这个示例中，sayHello() 方法返回一个简单的字符串 “Hello world!”。

这段代码的作用是，当你访问该应用程序的根路径时，它会响应一个 “Hello world!” 的字符串。这是一个最基本的REST端点示例，返回一个静态的问候语作为响应。

Maven项目结构

一个典型的 Maven 项目结构包括以下部分：

1. pom.xml 文件：

   • Maven 项目的核心文件，称为 Project Object Model（POM）。它描述了项目的元数据信息，包括项目坐标、依赖、插件配置等。
   • pom.xml 文件位于项目根目录下，是 Maven 构建过程的核心配置文件。

2. src 目录：

   • src 目录是 Maven 项目的源代码和资源文件的根目录。

3. src/main 目录：

   • src/main 目录包含主要的项目源代码和资源文件。

4. src/main/java 目录：

   • src/main/java 目录是存放 Java 源代码的主目录。

5. src/main/resources 目录：

   • src/main/resources 目录用于存放项目的资源文件，如配置文件、静态文件等。

   • 在 Spring Boot 中，application.properties 文件是常用的外部配置文件，它允许开发者将各种配置信息集中在一个文件中，方便进行配置和管理。

     • server.port=8484 配置了应用程序的端口号为 8484。

     • 有时候我们需要自定义APP的环境变量，可以借助 Application Properties File 来实现

• 自定义属性：可以在 application.properties 文件中定义任何自定义属性。这为应用程序配置提供了灵活性。

• 属性访问：在 Spring Boot 应用程序可以使用 @Value 注解直接访问这些属性。这样可以方便地获取配置值，无需额外的编码或配置。

  • coach.name=Mickey Mouse 和 team.name=The Mouse Crew 配置了教练名称和团队名称。

  • 注入属性值到应用程序中：

    • Spring Boot 提供了 @Value 注解，允许开发者将属性值注入到应用程序中的 Java 类中。比如 FunRestController 类使用了 @Value 注解，将 coach.name 和 team.name 的值注入到 coachName 和 teamName 字段中

    @RestController
    public class FunRestcontroller {
        @Value("${coach.name}")
        private String coachName;
    }

1. src/test 目录：

   • src/test 目录包含测试代码和资源文件。

2. src/test/java 目录：

   • src/test/java 目录存放测试用的 Java 源代码。

3. src/test/resources 目录：

   • src/test/resources 目录包含测试用的资源文件。

4. target 目录：

   • target 目录是 Maven 构建过程的输出目录，包含编译后的类文件、打包后的 JAR/WAR 文件等。这是 Maven 默认的输出目录。

5. mvnw 和 mvnw.cmd 文件：

• mvnw 和 mvnw.cmd 是 Maven Wrapper 的脚本文件，用于在没有全局 Maven 安装的情况下，使用项目中的 Maven 版本。这些文件能够确保项目在不同环境下使用相同的 Maven 版本，不受全局 Maven 版本的影响。

1. 警告告诉开发者不要使用 src/main/webapp 目录来存放静态资源，特别是当应用程序打包为 JAR 文件时。虽然 src/main/webapp 是 Maven 标准目录，但它仅适用于 WAR 打包，当生成 JAR 文件时，大多数构建工具会忽略该目录。

Spring Boot starters

在 Spring Boot 中，Starters（启动器）是预配置的 Maven 依赖项集合，旨在简化和加快特定功能的项目启动和配置过程。Starters 可以快速启用一组相关的库和依赖项，使得开发者能够更容易地构建特定类型的应用程序。

每个 Starter 都是一组预配置的依赖项，它们旨在实现特定功能或引入特定技术栈。Starters 的命名通常以 spring-boot-starter- 为前缀，后面跟着特定功能或技术的名称。

一些常见的 Spring Boot Starters 包括：

1. spring-boot-starter-web：
   • 用于构建 Web 应用程序的 Starter，包括了 Spring MVC、Tomcat（或其他嵌入式 Servlet 容器）等。
2. spring-boot-starter-data-jpa：
   • 针对使用 JPA 进行数据持久化的应用程序的 Starter，包含了 Spring Data JPA、Hibernate 等。
3. spring-boot-starter-security：
   • 用于构建安全性功能的 Starter，包括了 Spring Security、OAuth2 等。
4. spring-boot-starter-test：
   • 用于测试应用程序的 Starter，包含了 JUnit、Mockito、Spring Test 等测试框架和工具。
5. spring-boot-starter-logging：
   • 用于日志记录的 Starter，包含了 Spring Boot 默认的日志框架（如 Logback、Log4j2）。

使用 Starter 的好处在于它们提供了一种快速启用和配置特定功能的方式，而不需要开发者手动管理大量的依赖项。通过引入相应的 Starter，Spring Boot 能够自动配置应用程序所需的依赖项和功能，减少了开发者的配置工作，同时保证了一致性和可维护性。

Springboot starter parent

spring-boot-starter-parent 是 Spring Boot 提供的一个特殊的 Maven 父项目（Parent Project），作为 Spring Boot 应用程序的父项目，其他 Spring Boot 项目可以继承它来获得许多默认配置和依赖项的管理。

spring-boot-starter-parent 的好处包括：

1. 默认配置：
   • 包含了许多常用的 Maven 插件配置和默认的依赖项管理。通过继承 spring-boot-starter-parent，开发者可以省去大量常用插件和依赖项的配置工作。
2. 版本管理：
   • 管理了大量 Spring Boot 相关依赖库的版本。使用它作为父项目，可以确保所使用的 spring-boot-starter-*相关库的版本是兼容的，避免版本冲突问题。

Springboot Devtools

1. 自动应用重启：
   • 当应用程序的类文件发生变化时，DevTools 可以监控并自动触发应用程序的重启，从而使开发者无需手动重启应用程序。这大大加快了开发调试过程，节省了重启应用程序的时间。
2. 自动加载静态资源：
   • 在开发过程中，当静态资源（如 HTML、CSS、JavaScript 文件）发生变化时，DevTools 可以自动加载这些资源，无需手动刷新浏览器。这样可以减少刷新页面的频率，提高开发效率。

它需要在 pom.xml 中写入

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

此外，要实现实时编译，需要在idea中开启这两个开关：

Springboot Actuator

https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#actuator

Spring Boot Actuator 是 Spring Boot 框架的一个模块，用于向开发者暴露用于监控和管理应用程序的端点（endpoints）。它提供了一组 RESTful 风格的端点，可以通过 HTTP 请求来查看应用程序的运行状态、健康状况、性能指标等信息，同时也提供了对应用程序进行管理的端点，如关闭应用程序、查看线程堆栈等。

Spring Boot Actuator 的主要好处和解决的问题包括：

1. 监控和管理应用程序：
   • Actuator 暴露了一系列端点（endpoints），用于监控和管理应用程序。这些端点包括健康检查、信息展示、环境配置、配置属性、日志记录级别等，为开发者提供了便捷的监控和管理功能。
2. DevOps 功能：
   • Actuator 提供了一种简便的方式来获取 DevOps 功能。通过 Actuator 的端点，可以轻松地获取有关应用程序运行状态和配置的信息，有助于 DevOps 工作的进行。
3. 无需额外编码：
   • 只需将 Actuator 的依赖添加到项目的 POM 文件中，就可以获得大量监控和管理端点的功能。不需要开发者手动编写代码，这些端点会自动添加到应用程序中。
4. 免费的新端点：
   • 集成 Actuator 后，开发者无需编写任何代码即可获得一系列新的端点。这些端点提供了大量有用的信息和功能，如监控指标、应用程序配置、日志级别等，而无需开发者额外投入工作来编写这些功能。
   • 默认只暴露/actuator/health , 如果希望暴露所有端点，需要在application.properties中加入 management.endpoints.web.exposure.include=*

Info Endpoint

这是 Spring Boot Actuator 暴露的端点之一，用于展示应用程序的自定义信息。

• 通过配置 application.properties 文件中的 info 前缀的属性，可以定义应用程序的一些自定义信息，如应用名称、描述和版本号。还需要在该文件中设置：management.info.env.enabled=true

1. 配置信息示例：
   • 在 src/main/resources/application.properties 文件中，通过配置 info.app.name、info.app.description 和 info.app.version 属性，设置了应用程序的名称、描述和版本号。
2. 访问 Info Endpoint：
   • 访问 Info Endpoint 的 URL 是 localhost:8080/actuator/info。这个端点暴露了应用程序的信息，并且展示了配置文件中以 info 开头的属性值。

beans Endpoint

• 端点用于展示应用程序中当前可用的 Spring Beans（Spring 容器管理的对象）信息。
• 访问该端点将返回关于 Spring 应用程序上下文中所有 Bean 的详细信息，包括 Bean 的名称、类型、作用域、是否为单例等。
• 这个端点对于开发者了解应用程序中所有注册的 Bean 非常有用，可以帮助排查 Bean 是否正确加载、是否存在冲突等问题。

threaddump Endpoint

/actuator/threaddump 端点是 Spring Boot Actuator 提供的一个端点，用于获取应用程序的线程转储信息（Thread Dump）。线程转储是指在特定时间点捕获应用程序所有线程的状态信息，包括每个线程的堆栈跟踪信息，以便分析线程的运行状态和问题。

访问 /actuator/threaddump 端点将返回一个包含所有线程当前状态的文本或 JSON 格式的数据。这些信息可以帮助开发者或运维人员分析应用程序的运行情况，尤其是在处理一些复杂的并发问题或线程阻塞时非常有用。

mappings

• /actuator/mappings 端点用于显示应用程序中的 URL 映射信息，即展示请求 URL 与处理该 URL 的处理程序（Handler）之间的映射关系。
• 该端点返回了一个包含请求路径映射关系的 JSON 结构，包括每个 URL 路径与对应的处理方法、控制器类等信息。
• 这个端点对于开发者在调试、查看 URL 映射以及检查请求路径与处理方法的关系时非常有帮助。

Security

我们可以在pom中加入：

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

来保护actuator的端点，使他们需要登录才可以查看。

并且我们可以在application.properties 中加入：

management.endpoints.web.exposure.exclude=health,info 来让这两个端点免于保护，所有人都能访问到

重新启动后在终端会自动生成一个安全密码，每次启动的密码都是不一样的：

我们用用户名user和这个密码就能访问到被保护的端点。

使用命令行运行springboot项目

Spring Boot 应用程序是自包含的，这意味着它们可以独立运行，而不需要额外的服务器或软件

比如打包成 app.jar , 这种打包方式省去了安装额外服务器（如Tomcat）的需求，因为JAR文件已经包含了所需的一切，包括应用程序代码和服务器代码。总的来说，Spring Boot 使得部署和运行应用程序变得更加简单和高效，因为所有必需的组件都被打包在一个文件中。

• 方法1，使用java -jar name.jar 来运行项目
• 方法2，使用maven工具

<build>
    <plugins>
       <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
       </plugin>
    </plugins>
</build>

使用 Spring Boot Maven 插件的主要点如下：

1. Maven Wrapper (mvnw): Maven Wrapper 允许您运行 Maven 项目，即使没有在计算机上安装 Maven 或者 Maven 不在环境变量路径中。这是通过使用 mvnw（对于 Windows 是 mvnw.cmd，对于 Linux/Mac 是 mvnw.sh）实现的。
2. 便利性：使用 Maven Wrapper 的好处在于，如果您的计算机上没有找到正确版本的 Maven，它会自动下载正确的版本并运行 Maven。
3. 项目结构：您提到了 pom.xml 文件，这是 Maven 项目的核心，包含了项目配置和依赖信息。
4. 构建和测试命令：可以通过命令 mvnw clean compile test 在项目目录中执行清理、编译和测试步骤。这条命令适用于所有操作系统，只是在 Linux/Mac 系统中前缀为 ./（如 ./mvnw clean compile test）。
5. 跨平台脚本：提供了两个文件，mvnw.cmd 用于 Windows 系统，mvnw.sh 用于 Linux 或 Mac 系统，以支持不同操作系统的 Maven 项目构建。
6. 可以使用mvnw spring-boot:run 启动maven项目

打包

如果已经装好了maven，那么就可以直接用mvn package 打包项目，如果没有，就运行 ./mvnw package ，它会帮我们自动下载maven

Spring Boot Properties

Spring Boot 还有很多Properties，可以参考这个网站