Spring Boot 是一个简化 Spring 应用开发的框架，通过自动配置和约定优于配置的方式，使得开发者可以快速搭建和开发项目。本文提供了 Spring Boot 项目开发的相关资料，包括项目搭建、核心配置、常用功能实现以及实战案例。Spring Boot 项目开发资料涵盖了从环境搭建到功能实现的全过程。

Spring Boot 是什么

Spring Boot 是一个基于 Spring 框架的框架，旨在简化新 Spring 应用的初始搭建以及开发过程。它通过约定优于配置的方式，使得 Spring 应用的开发更加简单快捷。Spring Boot 可以自动配置 Spring 应用所需的各种组件，使得开发者可以专注于业务逻辑的实现，而不需要过多地关注配置细节。

Spring Boot 的特点和优势

1. 自动配置：Spring Boot 会根据项目中的依赖自动进行配置，如数据库连接、模板引擎、日志系统等。
2. 起步依赖：通过 spring-boot-starter-* 形式的依赖，可以快速引入所需的组件。
3. 命令行界面：Spring Boot 提供了 spring-boot-maven-plugin 和 spring-boot-gradle-plugin 插件，可以方便地运行和打包应用。
4. 嵌入式容器：Spring Boot 可以嵌入 Tomcat、Jetty 或 Undertow 等 Web 服务器，简化了部署步骤。
5. 生产就绪特性：支持健康检查、性能监控、外部配置等生产环境所需的特性。
6. 无需 XML 配置：尽可能地减少 XML 配置，通过 Java 配置和注解来替代传统的 XML 配置。
7. 快速起步：通过 Maven 和 Gradle 工具，可以快速搭建项目。

Spring Boot 的适用场景

• 微服务开发：Spring Boot 与 Spring Cloud 结合，可以快速搭建微服务应用。
• 独立应用：可以独立运行，无需部署到应用服务器。
• 快速原型开发：适用于快速原型开发，减少配置工作量。
• 简化传统应用：可将传统 Spring 应用转换为 Spring Boot 应用，提高开发效率。
• 前后端分离：通过 RESTful API 实现前后端分离，提高开发效率。

使用 Spring Initializr 快速搭建项目

Spring Initializr 是一个在线工具，可以帮助开发者快速搭建 Spring Boot 项目。访问 https://start.spring.io ，根据提示选择项目基本信息和依赖项，生成项目代码。

步骤

1. 打开 https://start.spring.io。
2. 选择项目基本信息（如项目名、语言、打包方式等）。
3. 选择所需的依赖项（如 Web、JPA、Thymeleaf 等）。
4. 点击生成项目，下载压缩包并解压。

示例代码

生成项目后，目录结构如下：

- src
  - main
    - java
      - com.example.demo
        - DemoApplication.java
    - resources
      - application.properties
- pom.xml

Maven 和 Gradle 构建工具的使用简介

Maven 和 Gradle 是两个常用的构建工具，可以用来管理项目的依赖和构建过程。

Maven

使用 Maven 时，需要在项目根目录下创建 pom.xml 文件，配置项目的依赖和构建信息。

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
    </dependencies>
</project>

Gradle

使用 Gradle 时，需要在项目根目录下创建 build.gradle 文件，配置项目的依赖和构建信息。

plugins {
    id 'org.springframework.boot' version '2.7.5'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'com.h2database:h2'
}

项目的基本结构和目录介绍

一个典型的 Spring Boot 项目结构如下：

- src
  - main
    - java
      - com.example.demo
        - DemoApplication.java
    - resources
      - application.properties
- pom.xml

目录说明

• src/main/java：存放 Java 源代码。
• src/main/resources：存放配置文件，如 application.properties。
• pom.xml：Maven 构建文件。
• build.gradle：Gradle 构建文件。

application.properties 和 application.yml 配置文件详解

Spring Boot 使用 application.properties 或 application.yml 文件来存储各种配置信息。这些配置文件可以存放在 resources 目录下，也可以通过环境变量或命令行参数覆盖。

application.properties 示例

# 应用加载模式
spring.profiles.active=dev
# 数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# JPA 配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
# 端口号
server.port=8080

application.yml 示例

spring:
  profiles:
  active: dev
  datasource:
    url: jdbc:mysql://localhost:3306/dbname
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
server:
  port: 8080

常用的内置配置属性

Spring Boot 提供了大量的内置配置属性，可以在 application.properties 或 application.yml 文件中直接使用。

常用属性

• spring.datasource.url: 数据库连接地址。
• spring.datasource.username: 数据库用户名。
• spring.datasource.password: 数据库密码。
• spring.jpa.hibernate.ddl-auto: 设置 Hibernate 的数据库模式生成策略。
• spring.jpa.show-sql: 显示 SQL 语句。
• server.port: 应用运行端口。
• spring.profiles.active: 激活的环境配置文件。

自定义配置的添加和使用

可以通过自定义配置类来加载和使用自定义配置。

自定义配置类

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {

    private String name;
    private String version;

    // Getters and Setters
}

使用自定义配置

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AppController {

    @Autowired
    private AppProperties appProperties;

    @GetMapping("/app-info")
    public String getAppInfo() {
        return "App Name: " + appProperties.getName() + ", Version: " + appProperties.getVersion();
    }
}

配置文件添加自定义属性

# application.properties
app.name=MyApp
app.version=1.0.0

# application.yml
app:
  name: MyApp
  version: 1.0.0

RESTful 接口的开发

RESTful 接口是一种基于 HTTP 协议的 API 设计风格，适用于前后端分离的架构。Spring Boot 提供了便捷的方式来开发 RESTful API。

创建 RESTful 接口

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

@RestController
public class UserController {

    @GetMapping("/users")
    public List<User> getUsers() {
        // 业务逻辑
        return List.of(new User("1", "Alice"), new User("2", "Bob"));
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable String id) {
        // 业务逻辑
        return new User(id, "Alice");
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        // 业务逻辑
        return user;
    }
}

class User {
    private String id;
    private String name;

    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getters and Setters
}

数据库的集成与操作（JPA/Hibernate）

Spring Boot 使用 JPA（Java Persistence API）或 Hibernate 来简化数据库操作。

配置数据源和 JPA

在 application.properties 文件中配置数据源和 JPA：

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

创建实体类

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;

    // Getters and Setters
}

创建 Repository 接口

import org.springframework.data.repository.CrudRepository;

public interface UserRepository extends CrudRepository<User, Long> {
}

使用 Repository 进行数据库操作

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> getUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}

日志的配置和使用

Spring Boot 使用 SLF4J 作为日志 API，可以方便地切换不同的日志框架。默认情况下，Spring Boot 使用 Logback 作为日志框架。

日志配置

可以在 application.properties 文件中配置日志输出级别：

logging.level.root=WARN
logging.level.com.example.demo=DEBUG

自定义日志输出

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LogController {

    private static final Logger logger = LoggerFactory.getLogger(LogController.class);

    @GetMapping("/log")
    public String logMessage() {
        logger.info("This is an info log");
        logger.debug("This is a debug log");
        logger.warn("This is a warn log");
        logger.error("This is an error log");
        return "Logs generated";
    }
}

项目打包与部署

Spring Boot 支持多种方式进行打包和部署，常见的有 Maven 和 Gradle。

Maven 打包

mvn clean package

Gradle 打包

./gradlew clean build

运行打包后的 jar 文件

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

Actuator 监控端点的使用

Spring Boot Actuator 提供了多种生产环境监控工具，通过这些工具可以监控应用的状态和资源使用情况。

启用 Actuator

在 pom.xml 或 build.gradle 中添加 Actuator 依赖：

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

implementation 'org.springframework.boot:spring-boot-starter-actuator'

访问监控端点

启动应用后，可以通过访问 /actuator 路径下的各种端点来获取应用信息。

常见端点

• /actuator/health：检查应用的健康状态。
• /actuator/info：获取应用的元数据信息。
• /actuator/metrics：获取应用的指标数据。
• /actuator/env：获取应用的环境信息。
• /actuator/threaddump：获取线程堆栈信息。

示例代码

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.actuate.metrics.annotation.Counted;
import org.springframework.boot.actuate.metrics.annotation.Timed;
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 MetricsController {

    @Counted
    @GetMapping("/counted")
    public String counted() {
        return "Counted endpoint";
    }

    @Timed
    @GetMapping("/timed")
    public String timed() {
        return "Timed endpoint";
    }
}

常见问题与解决方案

问题 1: 应用启动失败

原因：配置文件错误或依赖冲突。
解决方案：检查 application.properties 或 application.yml 文件中的配置是否正确。通过 mvn dependency:tree 或 ./gradlew dependencies 查看依赖树，排除冲突的依赖。

问题 2: REST 接口返回 404 错误

原因：控制器路径配置错误或缺少扫描路径。
解决方案：检查控制器类是否正确标注了 @RestController 和 @RequestMapping 注解。确保控制器路径与请求路径一致。

问题 3: 数据库连接失败

原因：数据库连接配置不正确或数据库服务未启动。
解决方案：检查 application.properties 或 application.yml 文件中的数据库连接配置是否正确。确认数据库服务已经启动并可以访问。

问题 4: Actuator 端点不可用

原因：Actuator 依赖未正确引入或应用未正确启动。
解决方案：确保在 pom.xml 或 build.gradle 文件中引入了 Actuator 依赖。检查应用是否正确启动并访问正确的端点地址。

需求分析

我们需要开发一个简单的博客应用，包含以下功能：

• 用户注册和登录功能。
• 发布博客文章。
• 查看博客文章列表。
• 查看单个博客文章。

功能模块设计

用户模块

• 用户注册和登录接口。
• 用户信息查询接口。

博客模块

• 创建博客文章接口。
• 获取博客文章列表接口。
• 获取单个博客文章接口。

代码实现与测试

创建实体类

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 username;
    private String password;

    // Getters and Setters
}

@Entity
public class Blog {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;

    // Getters and Setters
}

创建 Repository 接口

import org.springframework.data.repository.CrudRepository;

public interface UserRepository extends CrudRepository<User, Long> {
}

public interface BlogRepository extends CrudRepository<Blog, Long> {
}

创建控制器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @PostMapping("/users/register")
    public User registerUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PostMapping("/users/login")
    public User loginUser(@RequestBody User user) {
        return userRepository.findByUsernameAndPassword(user.getUsername(), user.getPassword());
    }

    @GetMapping("/users")
    public List<User> getUsers() {
        return userRepository.findAll();
    }
}

@RestController
public class BlogController {

    @Autowired
    private BlogRepository blogRepository;

    @PostMapping("/blogs")
    public Blog createBlog(@RequestBody Blog blog) {
        return blogRepository.save(blog);
    }

    @GetMapping("/blogs")
    public List<Blog> getBlogs() {
        return blogRepository.findAll();
    }

    @GetMapping("/blogs/{id}")
    public Blog getBlogById(@PathVariable Long id) {
        return blogRepository.findById(id).orElse(null);
    }
}

创建数据初始化脚本

CREATE TABLE user (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL,
    password VARCHAR(255) NOT NULL
);

CREATE TABLE blog (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL
);

测试

可以使用 Postman 或其他工具发送 HTTP 请求测试接口。

POST /users/register
{
    "username": "testuser",
    "password": "testpassword"
}

POST /users/login
{
    "username": "testuser",
    "password": "testpassword"
}

POST /blogs
{
    "title": "First Post",
    "content": "This is the first blog post."
}

GET /blogs
GET /blogs/1

通过以上步骤，我们已经成功构建了一个简单的博客应用，实现了用户注册、登录、发布博客文章和查看博客文章列表等功能。