【从零入门spring boot】 - 刘宇帅个人博客

从零入门spring boot

常见技术问题刘宇帅 23天前阅读量: 31

什么是 Spring Boot
为什么使用 Spring Boot
Spring Boot 的特点
环境准备
创建第一个 Spring Boot 项目
Spring Boot 的核心概念
依赖管理与自动配置
数据访问
- 使用 Spring Data JPA
Spring Boot 的测试
部署 Spring Boot 应用
常见问题与解决方法
进一步学习资源

一、什么是 Spring Boot

Spring Boot 是由 Pivotal 团队开发的一个开源框架，旨在简化基于 Spring 的应用程序开发。它通过约定优于配置（Convention over Configuration）的理念，减少了开发者在项目配置上的繁琐步骤，使得构建独立、生产级别的 Spring 应用更加高效和便捷。

Spring Boot 的核心目标：

快速启动：通过内嵌的服务器（如 Tomcat、Jetty）快速启动应用，无需外部部署。
自动配置：根据项目的依赖自动配置 Spring 应用，减少手动配置的工作量。
独立运行：打包成一个可执行的 JAR 文件，包含所有依赖，便于部署和分发。
简化依赖管理：提供一套简化的依赖管理方案，通过 Starter POMs 集成常用的库和框架。

二、为什么使用 Spring Boot

1. 简化配置

传统的 Spring 应用需要大量的 XML 配置或 Java 配置类，Spring Boot 通过自动配置和约定大于配置的理念，大幅减少了配置的复杂性。

2. 快速开发

内嵌服务器和自动配置让开发者能够更专注于业务逻辑，快速构建和测试应用。

3. 独立部署

Spring Boot 应用可以打包成一个独立的 JAR 文件，包含所有必要的依赖和内嵌服务器，简化了部署过程。

4. 广泛的生态系统

Spring Boot 与 Spring 生态系统中的众多项目（如 Spring Data、Spring Security、Spring Cloud）无缝集成，提供丰富的功能扩展。

5. 社区支持

拥有庞大的社区支持和丰富的文档资源，开发者可以轻松获取帮助和最佳实践。

三、Spring Boot 的特点

自动配置：根据项目的依赖和环境自动配置 Spring 应用，减少手动配置。
起步依赖（Starter Dependencies）：通过 Starter POMs 简化依赖管理，快速集成所需的功能。
内嵌服务器：支持内嵌的 Tomcat、Jetty、Undertow 服务器，简化部署。
Actuator：提供生产环境下的监控和管理功能，如健康检查、指标监控等。
命令行接口（CLI）：通过命令行工具快速创建和运行 Spring Boot 应用。
可扩展性：支持自定义配置和扩展，满足复杂应用的需求。

四、环境准备

在开始使用 Spring Boot 之前，需要准备开发环境，包括安装 JDK、构建工具和集成开发环境（IDE）。

1. 安装 JDK

Spring Boot 需要 Java 8 及以上版本。建议安装最新的稳定版本。

下载地址：Oracle JDK 或 OpenJDK

验证安装：

java -version

输出示例：

java version "11.0.10" 2021-01-19 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.10+9-LTS)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.10+9-LTS, mixed mode)

2. 安装 Maven 或 Gradle

Spring Boot 支持 Maven 和 Gradle 作为构建工具。选择其一进行安装和配置。

安装 Maven：
- 下载地址：Apache Maven
- 安装指南：Installing Apache Maven
- 验证安装：
```
mvn -v
```
输出示例：
```
Apache Maven 3.6.3
Maven home: /opt/apache-maven
Java version: 11.0.10, vendor: Oracle Corporation
```

安装 Gradle：

下载地址：Gradle
安装指南：Installing Gradle
验证安装：

gradle -v

输出示例：

------------------------------------------------------------
Gradle 6.8.3
------------------------------------------------------------

Build time:   2021-02-22 16:45:07 UTC
Revision:     58d6ac067c72069f6ac2273a8c778cd5ef7c2b93

Kotlin:       1.4.30
Groovy:       2.5.12
Ant:          Apache Ant(TM) version 1.10.9 compiled on September 27 2020
JVM:          11.0.10 (Oracle Corporation 11.0.10+9-LTS)
OS:           Mac OS X 10.15.7 x86_64

3. 安装集成开发环境（IDE）

推荐使用 IntelliJ IDEA、Eclipse 或 VS Code 等支持 Spring Boot 开发的 IDE。

IntelliJ IDEA：下载地址
Eclipse：下载地址
VS Code：下载地址

4. 安装 Spring Boot CLI（可选）

Spring Boot 提供了命令行工具（CLI）用于快速创建和运行应用。

安装指南：Spring Boot CLI
验证安装：
```
spring --version
```
输出示例：
```
Spring CLI v2.5.4
```

五、创建第一个 Spring Boot 项目

有多种方式创建 Spring Boot 项目，以下介绍使用 Spring Initializr 和 IDE 内置工具创建项目的方法。

方法一：使用 Spring Initializr 网站

访问 Spring Initializr：https://start.spring.io/
配置项目参数：
- Project：选择 Maven Project 或 Gradle Project
- Language：Java
- Spring Boot：选择最新稳定版本（如 3.1.0）
- Project Metadata：
  - Group：com.example
  - Artifact：demo
  - Name：demo
  - Description：Demo project for Spring Boot
  - Package name：com.example.demo
  - Packaging：Jar
  - Java：11 或更高版本
添加依赖：

点击 "Add Dependencies"，选择 "Spring Web"。
生成项目：

点击 "Generate"，下载生成的 ZIP 文件。
导入项目到 IDE：
- 解压下载的 ZIP 文件。
- 打开 IDE，选择 "Import Project"，选择解压后的项目目录，按照提示完成导入。

方法二：使用 IDE 内置工具

以 IntelliJ IDEA 为例：

启动 IntelliJ IDEA。
创建新项目：
- 点击 "New Project"。
- 选择 "Spring Initializr"。
- 点击 "Next"。
配置项目参数：
- Group：com.example
- Artifact：demo
- Name：demo
- Description：Demo project for Spring Boot
- Package name：com.example.demo
- Packaging：Jar
- Java：11 或更高版本
- 点击 "Next"。
选择依赖：
- 搜索并添加 "Spring Web" 依赖。
- 点击 "Next"。
完成创建：
- 选择项目保存位置。
- 点击 "Finish"。

运行项目

定位主类：

在项目结构中找到 DemoApplication.java，通常位于 src/main/java/com/example/demo 目录下。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

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

}

运行应用：
- 右键点击 DemoApplication.java，选择 "Run 'DemoApplication'"。
- 或者在终端中导航到项目根目录，执行以下命令：
```
mvn spring-boot:run
```
  或使用 Gradle：
```
gradle bootRun
```
访问应用：

应用默认运行在 http://localhost:8080。可以在浏览器中访问该地址，若无特殊配置，会看到默认的错误页面，因为还未配置任何控制器。

六、Spring Boot 的核心概念

Spring Boot 通过简化配置和集成 Spring 生态系统的各种组件，提供了一套完整的开发框架。以下是 Spring Boot 的几个核心概念和组件。

1. 控制器（Controller）

控制器负责处理 HTTP 请求，定义应用的路由和业务逻辑。

示例：创建一个简单的控制器

package com.example.demo.controller;

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, Spring Boot!";
    }
}

说明：

@RestController：标识这是一个 REST 控制器，返回的数据会自动序列化为 JSON 或其他格式。
@GetMapping("/hello")：定义一个 GET 请求的路由为 /hello，当访问该路由时，会执行 hello() 方法。

访问效果：

访问 http://localhost:8080/hello，浏览器将显示：

Hello, Spring Boot!

2. 服务（Service）

服务层负责处理业务逻辑，通常用于封装复杂的业务操作，控制器通过调用服务来完成任务。

示例：创建一个服务类

package com.example.demo.service;

import org.springframework.stereotype.Service;

@Service
public class GreetingService {

    public String getGreeting() {
        return "Hello from GreetingService!";
    }
}

说明：

@Service：标识这是一个服务组件，Spring 会自动扫描并管理该类的实例。

在控制器中使用服务

package com.example.demo.controller;

import com.example.demo.service.GreetingService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    @Autowired
    private GreetingService greetingService;

    @GetMapping("/greet")
    public String greet() {
        return greetingService.getGreeting();
    }
}

说明：

@Autowired：自动注入 GreetingService 的实例，供控制器使用。

访问效果：

访问 http://localhost:8080/greet，浏览器将显示：

Hello from GreetingService!

3. 仓库（Repository）

仓库层负责与数据源（如数据库）进行交互，执行 CRUD（创建、读取、更新、删除）操作。Spring Data JPA 提供了便捷的仓库接口，简化数据访问层的开发。

示例：创建实体类和仓库接口

实体类：

package com.example.demo.model;

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 id;

    private String name;
    private String email;

    // 构造方法、Getter 和 Setter 略
}

仓库接口：

package com.example.demo.repository;

import com.example.demo.model.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByEmail(String email);
}

说明：

@Entity：标识这是一个 JPA 实体，对应数据库表。
UserRepository 继承自 JpaRepository，提供了基本的 CRUD 操作。
可以根据命名规范定义查询方法，如 findByEmail。

在服务中使用仓库

package com.example.demo.service;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User createUser(String name, String email) {
        User user = new User();
        user.setName(name);
        user.setEmail(email);
        return userRepository.save(user);
    }

    public User getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }
}

在控制器中使用服务

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    public User createUser(@RequestParam String name, @RequestParam String email) {
        return userService.createUser(name, email);
    }

    @GetMapping
    public User getUser(@RequestParam String email) {
        return userService.getUserByEmail(email);
    }
}

说明：

@RequestMapping("/users")：定义基础路由为 /users。
@PostMapping：处理 POST 请求，用于创建用户。
@GetMapping：处理 GET 请求，用于获取用户信息。

访问效果：

创建用户：

使用工具（如 Postman）发送 POST 请求到 http://localhost:8080/users，带上参数 name 和 email。
获取用户：

发送 GET 请求到 http://localhost:8080/users?email=example@example.com，获取对应用户的信息。

七、依赖管理与自动配置

1. 依赖管理

Spring Boot 提供了一套 Starter POMs，简化了依赖管理。通过引入 Starter，可以自动添加一组相关的依赖，避免手动添加和版本冲突。

常用的 Starter 依赖：

spring-boot-starter-web：用于构建 Web 应用，包含 Spring MVC、Tomcat 等。
spring-boot-starter-data-jpa：用于数据访问，包含 Spring Data JPA、Hibernate 等。
spring-boot-starter-security：用于安全性，包含 Spring Security 等。
spring-boot-starter-test：用于测试，包含 JUnit、Mockito 等。

示例：pom.xml 中添加 Starter 依赖

<dependencies>
    <!-- Spring Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Data JPA Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- Spring Boot Test Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 自动配置

Spring Boot 的自动配置机制会根据项目的依赖和配置，自动配置 Spring 应用的各个部分。例如，添加 spring-boot-starter-web 依赖后，自动配置了 Spring MVC 和内嵌的 Tomcat 服务器。

启用自动配置

通过在主类上添加 @SpringBootApplication 注解，启用自动配置、组件扫描和 Spring 配置支持。

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

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

}

解释：

@SpringBootApplication 包含了以下注解：
- @SpringBootConfiguration：标识这是一个 Spring Boot 配置类。
- @EnableAutoConfiguration：启用自动配置。
- @ComponentScan：启用组件扫描，自动发现和注册 Spring 组件。

八、数据访问

Spring Boot 支持多种数据访问技术，其中最常用的是 Spring Data JPA。本文将介绍如何使用 Spring Data JPA 进行数据库操作。

1. 集成 Spring Data JPA

添加依赖

在 pom.xml 中添加 spring-boot-starter-data-jpa 和数据库驱动（如 H2、MySQL、PostgreSQL 等）的依赖。

<dependencies>
    <!-- Spring Data JPA Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- H2 Database -->
    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. 配置数据库

在 src/main/resources/application.properties 文件中配置数据库连接信息。

示例：使用 H2 内存数据库

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
spring.h2.console.enabled=true

说明：

spring.datasource.url：数据库连接 URL。
spring.datasource.driverClassName：数据库驱动类名。
spring.datasource.username 和 spring.datasource.password：数据库用户名和密码。
spring.jpa.database-platform：JPA 方言，用于生成 SQL。
spring.h2.console.enabled：启用 H2 数据库控制台，方便调试。

3. 创建实体类

前面已经介绍了 User 实体类，这里再提供一个示例。

package com.example.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity // 标识为 JPA 实体
public class Product {

    @Id // 主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) // 自增策略
    private Long id;

    private String name;
    private Double price;

    // 构造方法、Getter 和 Setter 略
}

4. 创建仓库接口

package com.example.demo.repository;

import com.example.demo.model.Product;
import org.springframework.data.jpa.repository.JpaRepository;

public interface ProductRepository extends JpaRepository<Product, Long> {
    // 自定义查询方法
    Product findByName(String name);
}

5. 使用服务层进行数据操作

package com.example.demo.service;

import com.example.demo.model.Product;
import com.example.demo.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class ProductService {

    @Autowired
    private ProductRepository productRepository;

    // 创建产品
    public Product createProduct(String name, Double price) {
        Product product = new Product();
        product.setName(name);
        product.setPrice(price);
        return productRepository.save(product);
    }

    // 获取所有产品
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }

    // 根据名称获取产品
    public Product getProductByName(String name) {
        return productRepository.findByName(name);
    }
}

6. 在控制器中使用服务层

package com.example.demo.controller;

import com.example.demo.model.Product;
import com.example.demo.service.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/products")
public class ProductController {

    @Autowired
    private ProductService productService;

    // 创建产品
    @PostMapping
    public Product createProduct(@RequestParam String name, @RequestParam Double price) {
        return productService.createProduct(name, price);
    }

    // 获取所有产品
    @GetMapping
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    // 根据名称获取产品
    @GetMapping("/search")
    public Product getProductByName(@RequestParam String name) {
        return productService.getProductByName(name);
    }
}

7. 访问 H2 数据库控制台

启用 H2 控制台

在 application.properties 中已启用 H2 控制台：
```
spring.h2.console.enabled=true
```
访问控制台

启动应用后，访问 http://localhost:8080/h2-console。
配置连接
- JDBC URL：jdbc:h2:mem:testdb
- User Name：sa
- Password：留空
使用控制台

可以通过 H2 控制台查看和操作数据库中的数据，如查询 Product 表。

九、Spring Boot 的测试

Spring Boot 提供了丰富的测试支持，包括单元测试、集成测试等。以下介绍如何编写和运行测试。

1. 添加测试依赖

Spring Boot 项目通常包含 spring-boot-starter-test 依赖，用于测试支持。

<dependencies>
    <!-- Spring Boot Test Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 编写单元测试

使用 JUnit 5 编写单元测试。

示例：测试 GreetingService

package com.example.demo.service;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class GreetingServiceTest {

    private GreetingService greetingService = new GreetingService();

    @Test
    public void testGetGreeting() {
        String greeting = greetingService.getGreeting();
        assertEquals("Hello from GreetingService!", greeting);
    }
}

3. 编写集成测试

使用 Spring Boot 提供的测试支持，编写集成测试，测试应用的整体功能。

示例：测试 UserController

package com.example.demo.controller;

import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
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.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;

// 加载完整的 Spring 应用上下文
@SpringBootTest
// 自动配置 MockMvc
@AutoConfigureMockMvc
public class UserControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private UserRepository userRepository;

    @BeforeEach
    public void setup() {
        userRepository.deleteAll();
        User user = new User();
        user.setName("John Doe");
        user.setEmail("john@example.com");
        userRepository.save(user);
    }

    @Test
    public void testGetUser() throws Exception {
        mockMvc.perform(get("/users")
                .param("email", "john@example.com")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(status().isOk())
                .andExpect(content().json("{\"id\":1,\"name\":\"John Doe\",\"email\":\"john@example.com\"}"));
    }
}

说明：

@SpringBootTest：加载完整的应用上下文，进行集成测试。
@AutoConfigureMockMvc：自动配置 MockMvc，用于模拟 HTTP 请求。
MockMvc：模拟 HTTP 请求和响应，用于测试控制器。
@BeforeEach：在每个测试方法之前执行，初始化测试数据。

4. 运行测试

在 IDE 中，右键点击测试类或测试方法，选择 "Run" 运行测试。也可以在终端中使用 Maven 或 Gradle 运行测试。

使用 Maven：
```
mvn test
```
使用 Gradle：
```
gradle test
```

十、部署 Spring Boot 应用

Spring Boot 应用可以轻松地部署到各种环境，包括本地服务器、云平台（如 AWS、Azure、GCP）、容器（如 Docker）等。以下介绍几种常见的部署方式。

1. 打包为可执行 JAR

Spring Boot 应用可以打包成一个独立的可执行 JAR 文件，包含所有依赖和内嵌服务器。

使用 Maven 打包

mvn clean package

生成的 JAR 文件位于 target 目录下，如 demo-0.0.1-SNAPSHOT.jar。

运行 JAR 文件

java -jar target/demo-0.0.1-SNAPSHOT.jar

2. 部署到云平台

以 Heroku 为例：

安装 Heroku CLI：下载地址
登录 Heroku：
```
heroku login
```
创建 Heroku 应用：
```
heroku create your-app-name
```

推送代码到 Heroku：

git add .
git commit -m "Deploy to Heroku"
git push heroku main

访问应用：
```
heroku open
```

3. 使用 Docker 部署

创建 Dockerfile

在项目根目录下创建 Dockerfile：

# 使用官方 OpenJDK 镜像作为基础镜像
FROM openjdk:11-jdk-slim

# 设置应用的 JAR 文件名称
ARG JAR_FILE=target/demo-0.0.1-SNAPSHOT.jar

# 将 JAR 文件复制到容器中
COPY ${JAR_FILE} app.jar

# 运行应用
ENTRYPOINT ["java","-jar","/app.jar"]

构建 Docker 镜像

docker build -t demo-app .

运行 Docker 容器

docker run -d -p 8080:8080 demo-app

说明：

-d：后台运行容器。
-p 8080:8080：将容器的 8080 端口映射到主机的 8080 端口。

访问应用

访问 http://localhost:8080，即可访问运行在 Docker 容器中的 Spring Boot 应用。

十一、常见问题与解决方法

1. 应用启动失败

可能原因：

端口被占用。
配置文件错误。
缺少依赖。

解决方法：

检查端口占用，修改 application.properties 中的端口配置：
```
server.port=9090
```
检查配置文件是否正确，特别是数据库连接等关键配置。
确认 pom.xml 或 build.gradle 中的依赖是否完整，执行 mvn clean install 或 gradle build 重新构建。

2. 无法连接数据库

可能原因：

数据库未启动或连接信息错误。
数据库驱动缺失。
防火墙阻止连接。

解决方法：

确认数据库服务已启动，并检查连接信息（URL、用户名、密码）是否正确。
确认项目中已添加相应的数据库驱动依赖。
检查防火墙设置，确保允许应用程序连接到数据库端口。

3. 依赖冲突

可能原因：

不同 Starter 依赖中包含冲突的版本。
自定义依赖版本与 Spring Boot 管理的版本不兼容。

解决方法：

使用 mvn dependency:tree 或 gradle dependencies 查看依赖树，识别冲突。

在 pom.xml 中使用 dependencyManagement 管理依赖版本，确保统一。

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

4. 静态资源未加载

可能原因：

静态资源放置的位置不正确。
配置错误导致资源路径不对。

解决方法：

确认静态资源（如 CSS、JS、图片）放置在 src/main/resources/static 目录下。
检查控制器是否正确映射静态资源路径。

5. 跨域请求被阻止

可能原因：

前端应用与后端服务不在同一域，浏览器阻止了跨域请求。

解决方法：

在控制器或全局配置中启用 CORS（跨域资源共享）。

示例：在控制器中启用 CORS

@RestController
@RequestMapping("/api")
@CrossOrigin(origins = "http://localhost:3000")
public class ApiController {
  // 控制器方法
}

示例：全局配置 CORS

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig {

  @Bean
  public WebMvcConfigurer corsConfigurer() {
      return new WebMvcConfigurer() {
          @Override
          public void addCorsMappings(CorsRegistry registry) {
              registry.addMapping("/**")
                      .allowedOrigins("http://localhost:3000")
                      .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
                      .allowedHeaders("*")
                      .allowCredentials(true);
          }
      };
  }
}

十二、进一步学习资源

1. 官方文档

2. 书籍推荐

《Spring Boot 实战》（Craig Walls 著）
《Spring in Action》（Craig Walls 著）

3. 在线课程

4. 社区与论坛

5. 实践项目

博客系统：构建一个简单的博客系统，涵盖用户管理、文章发布、评论等功能。
电商平台：开发一个电商平台，集成商品管理、购物车、订单处理等模块。
社交网络：创建一个基础的社交网络应用，实现用户注册、好友添加、消息发送等功能。

6. 工具与插件

Spring Boot DevTools：用于开发过程中的热重载和快速调试。

添加依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-devtools</artifactId>
  <scope>runtime</scope>
  <optional>true</optional>
</dependency>

Lombok：简化 Java 代码，通过注解自动生成 Getter、Setter、构造方法等。

添加依赖
```
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
  <version>1.18.20</version>
  <scope>provided</scope>
</dependency>
```
注意：需要在 IDE 中安装 Lombok 插件，并启用注解处理器。

总结

通过本文的介绍，你已经了解了 Spring Boot 的基本概念、安装配置、创建项目、核心组件的使用以及常见问题的解决方法。Spring Boot 以其简化配置、快速开发和强大的生态系统，成为现代 Java 开发的首选框架。持续的学习和实践，将帮助你更好地掌握 Spring Boot，并构建高效、可维护的应用程序。

学习建议：

动手实践：通过构建实际项目，巩固所学知识。
阅读源码：深入理解 Spring Boot 的内部机制和实现原理。
参与社区：加入 Spring 社区，参与讨论，获取最新资讯和最佳实践。
持续学习：关注 Spring Boot 的更新和新特性，保持技术前沿。

祝你在 Spring Boot 的学习和开发之旅中取得成功！

点赞打赏

0条评论

未登录

暂无评论～