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 的应用程序，如聊天应用、实时数据更新等。

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。
     • 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中开启这两个开关：