企业官网建设流程全解析

• 文档
• 知识库
• 教程
• 开发工具

本篇技术指南以开源仓库 jaywcjlove/reference 中的 Spring Boot 备忘清单 为骨架，系统梳理 Spring Boot 应用从项目创建、核心配置、依赖管理，到 Web 开发、JPA 数据访问、单元测试与打包部署的完整实战路径。阅读完成后，你将掌握一套可直接照抄照用的 Spring Boot 开发速查体系，覆盖application.yml全部常用配置项、Starter 依赖与 BOM 版本管理机制，以及一个可运行的 CRUD 应用与 MockMvc 测试范例。

该文档属于该仓库「编程」分类下的 Java 技术栈速查表，与仓库中的 Java 备忘清单、YAML 配置速查、MySQL 速查、JSON 速查 相互配套。开发 Spring Boot 需要具备基本的 Java 基础和 Maven 基础，可先翻阅 Java 备忘清单 复习语言要点。

入门：Spring Boot 是什么与项目创建

介绍

Spring Boot 是一个用于简化 Spring 应用程序开发的框架。它提供了一种简单的方式来创建、运行和部署 Spring 应用程序，并简化了配置和依赖管理。其核心设计理念可以概括为两点：

• 约定优于配置：绝大多数场景下开箱即用，开发者无需手工编写繁琐的 XML 配置文件；
• 自动配置：根据类路径中的依赖项自动装配应用上下文，让「依赖即功能」成为可能。

项目创建与配置

推荐使用 Spring Initializr 生成项目骨架，两种渠道可选：

• 官方渠道：访问 start.spring.io，选择构建工具（Maven/Gradle）、语言（Java）、Spring Boot 版本以及所需依赖；
• 国内加速渠道：访问 start.aliyun.com（阿里云镜像），同样可以选择依赖项（如 Web、JPA、Security）和 Spring Boot 版本，下载速度更快。

拿到骨架后，还需要完成两个关键动作：

• 将所需依赖项添加到pom.xml（Maven）或build.gradle（Gradle）文件中，依赖的具体写法见下文「依赖管理」一节；
• 在src/main/resources目录下创建application.properties或application.yml文件，用于配置数据库连接信息、端口号等应用程序属性。

配置：YAML 配置文件全解

配置文件说明

在 Spring Boot 应用程序中，通常使用 YAML 格式（.yml文件）来配置应用程序的属性和设置。相比传统的.properties文件，YAML 格式更加清晰易读，并且支持层级结构和列表等复杂数据类型。关于 YAML 的完整语法（缩进、注释、锚点、多行字符串等），可参考仓库中的 YAML 速查清单。

以下是一些常用的 Spring Boot YAML 配置字段速查表：

1. 应用程序配置

spring: application: name: my-application

spring.application.name是应用程序的名称。在集成服务发现（如 Eureka、Nacos）和配置管理（如 Spring Cloud Config）时特别有用，同时也会影响 Actuator 端点的路径——例如启用 Actuator 后，/actuator端点前缀中会带上应用名信息。

2. 服务器端口配置

server: port: 8080

server.port指定应用程序监听的 HTTP 端口号，默认为 8080，可根据需要修改。例如在本地同时运行多个服务时，常改为9090、18080等避免冲突。

3. 数据源配置

spring: datasource: url: jdbc:mysql://localhost:3306/mydatabase username: root password: password driver-class-name: com.mysql.cj.jdbc.Driver # 这里是 MySQL8.0 版本配置，5.0 则是 com.mysql.jdbc.Driver

说明：

• spring.datasource.url：数据库连接 URL，注意其中包含的库名要与实际数据库一致；
• spring.datasource.username和spring.datasource.password：数据库的用户名和密码；
• spring.datasource.driver-class-name：数据库驱动类名。MySQL 8.0 使用com.mysql.cj.jdbc.Driver，MySQL 5.x 使用com.mysql.jdbc.Driver，混用会导致驱动加载失败。更完整的 MySQL 连接参数与 SQL 用法可参考仓库中的 MySQL 备忘清单。

4. JPA 配置

spring: jpa: show-sql: true hibernate: ddl-auto: update

说明：

• spring.jpa.show-sql：是否在控制台显示 SQL 语句，开发阶段建议开启便于调试；
• spring.jpa.hibernate.ddl-auto：Hibernate 自动建表策略，可选update、create、create-drop、validate。其中update会对比实体类自动更新表结构，validate只校验不修改，create-drop常在测试环境中使用（会话结束即删除表）。

5. 日志配置

logging: level: org.springframework: INFO com.example: DEBUG

说明：

• logging.level：日志级别配置，可以针对不同的包或类设置不同的日志级别，如TRACE、DEBUG、INFO、WARN、ERROR。上面的示例将 Spring 框架自身的日志设为INFO，而将业务包com.example设为更详细的DEBUG，从而在避免刷屏的同时保留业务调试信息。

6. Spring Security 配置

spring: security: user: name: user password: password basic: enabled: true

说明：

• spring.security.user.name和spring.security.user.password：基本认证的用户名和密码；
• spring.security.basic.enabled：是否启用基本认证（Basic Auth）。引入spring-boot-starter-security后默认即会对所有端点启用认证，此配置可快速指定默认账号。

7. Actuator 配置

management: endpoints: web: exposure: include: health, info

说明：

• management.endpoints.web.exposure.include：暴露给外部的 Actuator 端点列表，可设置为*来暴露所有端点（生产环境需谨慎）。常见端点包括health（健康检查）、info（应用信息）、metrics（指标）、env（环境属性）等。

8. 多环境配置

spring: profiles: active: dev

说明：

• spring.profiles.active：指定当前激活的环境配置文件。Spring Boot 支持application-{profile}.yml的命名约定，例如application-dev.yml、application-prod.yml，激活某个 profile 后会自动加载对应文件，实现开发、测试、生产环境的配置隔离。

9. 自定义属性配置

myapp: custom: property: value

说明：

• 自定义应用程序属性，可以在应用程序中通过@Value注解或Environment对象访问。例如@Value("${myapp.custom.property}")即可注入该值；更推荐的做法是配合@ConfigurationProperties将一组自定义属性绑定到 POJO，实现类型安全的配置管理。

依赖管理

依赖管理介绍

在 Spring Boot 中，依赖管理是非常重要的一部分。它通过简化依赖项的引入和版本管理，大大简化了项目的构建和维护过程。Spring Boot 采用了Starter 依赖项的概念，通过提供预配置的依赖项集合来简化项目的初始化和配置。

Starter 依赖项

Spring Boot 的 Starter 依赖项是预先配置的一组依赖项集合，它们以spring-boot-starter-*的命名格式提供。这些 Starter 依赖项可以按照功能领域进行分类，常用的包括：

引入 Starter 依赖项可以快速添加特定功能，Spring Boot 会自动配置所需的组件和设置，减少手动配置工作量。

自动依赖解析和版本管理

Spring Boot 的 BOM（Bill of Materials，物料清单）集中管理各个 Starter 依赖项的版本。通过在pom.xml（Maven）或build.gradle（Gradle）中引入 BOM，可以简化依赖项版本管理。例如，在 Maven 项目中：

<dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-dependencies</artifactId> <version>2.6.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>

这样一来，当你在项目中引入 Spring Boot 的 Starter 依赖项时，不需要显式声明版本号，Maven 会自动使用 BOM 中指定的版本。文档示例使用2.6.0版本，实际使用时请以你通过 Spring Initializr 选择的稳定版本为准。

自定义依赖管理

尽管 Spring Boot 提供了丰富的 Starter 依赖项和依赖管理功能，但有时你可能需要自定义特定的依赖项或版本。在这种情况下，你可以在pom.xml或build.gradle中显式声明所需的依赖项，而不使用 Starter 依赖项。

例如，在 Maven 项目中，你可以这样声明一个依赖项：

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

这样做可以覆盖 Spring Boot BOM 中指定的版本，允许你使用特定版本的依赖项——显式声明版本的优先级高于 BOM 管理。

排除和冲突解决

在实际项目中，可能会遇到依赖项之间的冲突或不兼容性问题。Spring Boot 允许你通过<exclusions>标签来排除 Starter 依赖项中的某些传递性依赖，以解决冲突问题。

例如，在 Maven 项目中排除传递性依赖（将内嵌的 Tomcat 容器换为 Jetty 或 Undertow 时非常常见）：

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

这种排除机制使得你可以更精确地控制项目中依赖项的版本和组合，以避免不必要的冲突。

Spring Boot 核心功能

依赖注入（Dependency Injection）

依赖注入是 Spring 框架的核心概念之一，它通过控制反转（IoC，Inversion of Control）的方式管理对象之间的依赖关系，从而实现松耦合、可测试和可维护的代码结构。Spring Boot 通过自动配置的方式支持依赖注入，以下是一些关键点：

自动装配（Auto-configuration）

Spring Boot 根据类路径中的依赖项自动配置应用程序上下文。这包括自动扫描和注册带有特定注解（如@Component、@Service、@Repository等）的 Bean，以及自动解析和注入这些 Bean 之间的依赖关系。这也是 Starter 依赖「开箱即用」的底层原因——类路径上存在某个依赖，对应的自动配置类即生效。

Bean 的声明和管理

开发者可以使用@Autowired注解在需要依赖注入的地方注入其他 Bean，Spring Boot 会自动解析和注入所需的依赖。例如：

@RestController public class MyContr { private final MyService myService; @Autowired public MyContr(MyService myService) { this.myService = myService; } // Controller methods }

在上面的例子中，MyContr中的MyService依赖通过构造函数注入完成。现代 Spring 实践中更推荐构造器注入（而非字段注入），因为依赖关系更明确、更利于单元测试。

条件化注入

Spring Boot 支持根据条件选择性地注入 Bean。例如，可以使用@Conditional注解或@ConditionalOnProperty注解根据特定的条件决定是否创建和注入 Bean。@ConditionalOnProperty可以配合配置文件中的属性开关使用，例如仅当myapp.feature.enabled=true时才注册某个 Bean。

面向切面编程（Aspect-Oriented Programming）

面向切面编程是一种软件开发方法，用于分离横切关注点（cross-cutting concerns），例如日志、事务管理、安全性等，以便更好地模块化和管理应用程序。Spring Boot 通过整合 Spring AOP 框架支持面向切面编程。

切面（Aspect）

切面是一个模块化的类，它包含了横切关注点的逻辑。在 Spring Boot 中，可以使用@Aspect注解标记一个类作为切面，并通过@Before、@After、@Around等注解定义切面的具体行为。

切点（Pointcut）

切点定义了在应用程序中哪些位置应用切面逻辑。切点表达式使用execution关键字指定要拦截的方法调用。例如：

@Aspect @Component public class LoggingAspect { @Before("execution(* com.example.service.*.*(..))") public void beforeServiceMethods(JoinPoint joinPoint) { // Advice logic before service method execution } // Other advices (e.g., @After, @Around) can be defined similarly }

通知（Advice）

通知是在切点处执行的具体逻辑，包括@Before、@AfterReturning、@AfterThrowing、@Around等。例如，在上面的例子中，beforeServiceMethods方法就是一个@Before通知，它在目标方法执行之前执行。

配置和启用

Spring Boot 通过自动配置和注解扫描使得使用 AOP 变得非常简单。通常情况下，只需在切面类上加上@Aspect注解，并确保它被 Spring Boot 的组件扫描机制扫描到即可——即类位于主启动类所在包（或子包）下，并被@Component标注。

Web 开发：从零搭建 Hello World

1. 创建一个新的 Spring Boot 项目

你可以使用 Spring Initializr 创建一个新的 Spring Boot 项目。访问 start.spring.io 并按照以下配置创建项目：

• Project：Maven 或 Gradle（选择你的构建工具）
• Language：Java
• Spring Boot：选择最新的稳定版本
• Project Metadata：
  • Group：com.example（或者你喜欢的 Group ID）
  • Artifact：helloworld（或者你喜欢的 Artifact ID）
  • Dependencies：选择 "Spring Web"

点击 "Generate" 下载项目的 zip 文件。

2. 将项目导入到你的 IDE 中

解压下载的文件并导入到你喜欢的 IDE 中（如 IntelliJ IDEA、Eclipse 等）。

3. 实现 Hello World Controller

在 IDE 中打开你的项目，导航到src/main/java/com/example/helloworld。你会看到一个名为HelloworldApplication.java的类文件，这是 Spring Boot 应用程序的入口类。

在这个类的同级目录下创建一个新的 Java 类文件，例如HelloController.java，并添加以下内容：

package com.example.helloworld; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloController { @GetMapping("/") public String hello() { return "Hello, World!"; } }

@RestController将类标记为 REST 控制器，@GetMapping("/")将根路径的 GET 请求映射到hello()方法。

4. 运行应用程序

使用 Maven 或 Gradle 构建项目并启动应用程序。可以通过 IDE 的运行功能或者命令行执行以下命令：

mvn spring-boot:run

或者

./gradlew bootRun

mvn spring-boot:run由spring-boot-maven-plugin提供，无需先打包即可直接启动应用。

5. 访问 Hello World 页面

在浏览器中访问http://localhost:8080/，你应该能够看到显示 "Hello, World!" 的页面。

这样，你就成功创建了一个简单的 Spring Boot Web 应用程序，并实现了一个基本的 "Hello, World!" 示例。

数据访问：Spring Data JPA 完整 CRUD

1. 创建过程

创建过程和 Web 项目示例一样，通过 Spring Initializr 生成项目。注意：需要选择 JPA 和对应数据库的驱动（如 MySQL Driver、H2 等）。

2. 配置数据库连接

默认情况下，Spring Boot 使用 H2 Database 作为内嵌数据库（无需额外安装，适合快速体验）。如果你想使用其他数据库，可以在application.properties（或application.yml）文件中配置数据库连接信息。

例如，使用 H2 Database 的默认配置：

# application.properties spring.datasource.url=jdbc:h2:mem:testdb spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=username spring.datasource.password=password spring.jpa.database-platform=org.hibernate.dialect.H2Dialect # Hibernate ddl auto (create, create-drop, validate, update) spring.jpa.hibernate.ddl-auto=update

jdbc:h2:mem:testdb表示使用内存数据库，应用重启后数据即清空，适合开发与测试阶段。

3. 创建实体类User

在src/main/java/com/example/userdemo目录下创建一个名为User的实体类：

package com.example.userdemo; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; @Entity public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long userId; private String username; private Integer age; private String sex; // Constructors, getters, and setters 省略 }

@Entity标注该类为 JPA 实体并映射到数据库表，@Id指定主键，@GeneratedValue(strategy = GenerationType.IDENTITY)使用数据库自增主键。注意需要补充对应的 getter/setter 方法供后续 CRUD 使用。

4. 创建 UserRepository 接口

在同样的目录下创建一个接口UserRepository，继承自JpaRepository<User, Long>，这样 Spring Data JPA 将会自动实现一些基本的数据库操作方法。

package com.example.userdemo; import org.springframework.data.jpa.repository.JpaRepository; public interface UserRepository extends JpaRepository<User, Long> { }

接口中无需编写任何方法实现——JpaRepository已内置findAll()、findById()、save()、deleteById()等常用方法，Spring Data JPA 会在运行时自动生成代理实现。

5. 创建控制器来测试

创建一个简单的控制器UserController，用来处理 HTTP 请求，并操作UserRepository来访问数据库。

package com.example.userdemo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/users") public class UserController { @Autowired private UserRepository userRepository; // 获取所有用户 @GetMapping("/") public List<User> getAllUsers() { return userRepository.findAll(); } // 通过 id 获取用户 @GetMapping("/{id}") public User getUserById(@PathVariable("id") Long id) { return userRepository.findById(id).orElse(null); } // POST 创建新用户 @PostMapping("/") public User addUser(@RequestBody User user) { return userRepository.save(user); } // PUT 更新用户 @PutMapping("/{id}") public User updateUser(@PathVariable("id") Long id, @RequestBody User userDetails) { User user = userRepository.findById(id).orElse(null); if (user != null) { user.setUsername(userDetails.getUsername()); user.setAge(userDetails.getAge()); user.setSex(userDetails.getSex()); return userRepository.save(user); } return null; } // DELETE 删除用户 @DeleteMapping("/{id}") public void deleteUser(@PathVariable("id") Long id) { userRepository.deleteById(id); } }

6. 运行应用程序并测试

使用 Maven 或 Gradle 构建并运行你的应用程序。然后，可以使用 Postman 或浏览器访问以下 API 来测试你的应用程序：

POST / PUT 请求体使用 JSON 格式，例如{"username":"alice","age":18,"sex":"female"}，JSON 语法细节可参考仓库中的 JSON 速查清单。

测试：使用 MockMvc 编写接口测试

1. 创建一个简单的项目

在src/main/java/com/example/demo目录下创建一个名为HelloController.java的类：

package com.example.demo; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class HelloController { @GetMapping("/hello") public String hello() { return "Hello, World!"; } }

创建过程同 Web 项目创建。

2. 编写测试类

在src/test/java/com/example/demo目录下创建一个名为HelloControllerTest.java的测试类：

package com.example.demo; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit.jupiter.web.SpringJUnitWebConfig; import org.springframework.test.web.servlet.MockMvc; import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; import org.springframework.test.web.servlet.result.MockMvcResultMatchers; import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print; @SpringBootTest @AutoConfigureMockMvc public class HelloControllerTest { @Autowired private MockMvc mockMvc; @Test public void helloTest() throws Exception { mockMvc.perform(MockMvcRequestBuilders.get("/hello")) .andExpect(MockMvcResultMatchers.status().isOk()) .andExpect(MockMvcResultMatchers.content().string("Hello, World!")) .andDo(print()); } }

3. 解释测试类的关键点

• @SpringBootTest：这个注解告诉 Spring Boot 在测试时启动整个 Spring 应用程序上下文；
• @AutoConfigureMockMvc：这个注解确保在测试中自动配置 MockMvc 实例，用于模拟 HTTP 请求；
• @Autowired private MockMvc mockMvc：注入 MockMvc 实例，用于执行 HTTP 请求并验证响应；
• @Test public void helloTest()：这是一个 JUnit 测试方法，用来测试HelloController中的hello()方法；
• mockMvc.perform(...)：执行一个 GET 请求到/hello接口；
• andExpect(MockMvcResultMatchers.status().isOk())：预期响应的状态码是 200 OK；
• andExpect(MockMvcResultMatchers.content().string("Hello, World!"))：预期响应的内容是 "Hello, World!"；
• andDo(print())：打印请求和响应的详细信息，方便调试。

4. 运行测试

使用 Maven 执行mvn test（或通过 IDE 直接运行测试类），确保程序正确。

部署与扩展

1. 打包方式

Spring Boot 应用程序可以打包为以下几种方式之一：

可执行 JAR 文件

• 最常见的方式是将 Spring Boot 应用程序打包成一个可执行的 JAR 文件（Java Archive）；
• JAR 文件中包含了所有的依赖项，可以通过java -jar命令来运行，无需外部容器。

WAR 文件

• 如果你需要将 Spring Boot 应用程序部署到外部的 Servlet 容器（如 Tomcat、Jetty 等），你可以将应用程序打包成一个 WAR 文件（Web Application Archive）；
• WAR 文件适合传统的 Java Web 应用程序部署方式，需配合外置容器使用。

2. 打包工具

通常使用以下两种构建工具来打包 Spring Boot 应用程序：

Maven

• 使用 Maven 的mvn package命令可以将应用程序打包为 JAR 或 WAR 文件；
• 在pom.xml文件中，Spring Boot 应用程序通常会依赖于spring-boot-starter-parent父项目，这简化了 Maven 配置和依赖管理。

Gradle

• 使用 Gradle 的gradle build或./gradlew bootJar命令完成类似打包，构建产物同样输出到build/libs目录。

3. 打包过程概述

当你运行 Maven 的构建命令时，它们会执行以下几个主要步骤来打包你的应用程序：

1. 依赖项解析和下载：构建工具会检查你项目中的依赖项，下载缺失的依赖并构建整个依赖树；
2. 编译代码：构建工具会编译你的 Java 代码、资源文件等；
3. 运行测试：通常会执行单元测试和集成测试，确保代码质量和功能正确性；
4. 打包应用程序：
   • 对于可执行 JAR 文件：构建工具会将编译后的类文件、资源文件和依赖项打包到一个 JAR 文件中。同时，它会生成一个MANIFEST.MF文件，指定应用程序的入口点（main class）；
   • 对于 WAR 文件：构建工具会将编译后的类文件、资源文件和依赖项打包成一个 WAR 文件，包括WEB-INF目录和其他必要的内容；
5. 输出结果：构建工具会在指定的目录下生成打包好的 JAR 或 WAR 文件，通常位于target目录下（Maven）。

在你的 Spring Boot 项目中，通常有一个入口类（如Application.java或者根据你的项目命名）。这个类使用@SpringBootApplication注解标记，它包含了main方法用来启动应用程序——它同时组合了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解的功能。

4. 示例

假设你有一个简单的 Spring Boot 应用程序，并且已经配置好了 Maven 或 Gradle。运行以下命令即可进行打包：

• Maven：mvn clean package

构建工具会执行以上步骤，生成可执行的 JAR 文件或 WAR 文件，你可以根据需要进行部署和运行。生成的 JAR 可通过java -jar target/xxx.jar直接启动；如需容器化部署，可参考仓库中的 Dockerfile 速查清单 编写镜像构建脚本。

在仓库中继续深入

本文内容整理自仓库中的 Spring Boot 备忘清单（位于docs/springboot.md）。该仓库（jaywcjlove/reference）是一份面向开发者的快速参考备忘清单集合，全部速查表以 Markdown 编写，支持通过npm install && npm start本地渲染为 HTML 页面（参见仓库根目录 package.json 中的脚本配置）。如果你希望为这份清单贡献内容或修正错误，可以阅读 CONTRIBUTING.md 与 Quick Reference 排版说明 了解文档规范。与本文配套的速查表还包括 Java、YAML、MySQL、JSON、Markdown 与 Dockerfile 等，可按需查阅。

• 文档
• 知识库
• 教程
• 开发工具