Spring Boot框架教程：从零开始的实战入门-原创手记-慕课网

本文提供了全面的Spring Boot框架教程，涵盖环境搭建、项目结构解析、RESTful服务创建、数据库操作、配置管理及日志异常处理等核心内容，通过示例代码和配置文件详细展示了Spring Boot的强大功能，帮助开发者快速上手并应用于实际项目。

引入Spring Boot框架

什么是Spring Boot

Spring Boot是Spring框架的一个模块，主要目标是简化Spring应用的初始搭建及开发过程。它通过约定优于配置的方式，帮助开发者快速搭建独立的、生产级别的Spring应用。Spring Boot能够自动配置Spring应用组件，使开发者可以专注于业务逻辑的实现，而非配置细节。

Spring Boot的优势

自动配置：Spring Boot能够根据应用所使用的依赖库，自动配置Spring环境。
独立运行：Spring Boot应用可以打包成独立的可执行JAR文件，包含所有依赖库，直接运行。
无需配置文件：虽然Spring Boot推荐使用约定优于配置，但开发者仍可以通过配置文件覆盖默认配置。
内置Web服务器：Spring Boot通常与嵌入式Web服务器（例如Tomcat或Jetty）一起使用，简化部署流程。
健康检查与监控：Spring Boot自带健康检查和应用监控功能，便于开发人员了解应用状态。
快速开发：Spring Boot简化了Spring的配置和开发过程，使得开发者能够快速搭建起一个完整的应用。

如何快速搭建Spring Boot环境

下载并安装Java开发工具包(JDK)：确保安装了Java 8或更高版本。
安装IDE：推荐使用IntelliJ IDEA或Eclipse。
安装Maven或Gradle：Maven和Gradle是常用的构建工具，用于项目依赖管理和编译打包。
创建Spring Boot项目：使用Spring Initializer（https://start.spring.io/）快速创建项目。选择Spring Boot版本、语言（Java）、依赖库（如Spring Web、JPA等），并下载项目压缩包。

<!-- 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>
    <packaging>jar</packaging>

    <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>
    </dependencies>

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

导入IDE：将下载的项目解压并导入到IDE中。
运行项目：使用IDE或命令行启动应用。例如，使用Maven命令运行：

mvn spring-boot:run

Spring Boot项目结构解析

项目目录结构说明

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

src
├── main
│   ├── java
│   │   └── com.example.demo
│   │       └── DemoApplication.java
│   ├── resources
│   │   ├── application.properties
│   │   └── logback-spring.xml
├── test
│   └── java
│       └── com.example.demo
│           └── DemoApplicationTests.java
└── pom.xml

src/main/java：Java源代码目录，包含应用的主要逻辑。
src/main/resources：资源文件目录，包括配置文件、模板文件等。
src/test/java：单元测试代码目录。
pom.xml：项目描述文件，定义依赖库、构建命令等。

Maven与Gradle构建工具的使用

Maven：使用Maven构建Spring Boot应用是最常见的方法。Maven通过pom.xml文件管理项目依赖和构建过程。

示例的pom.xml文件已介绍过，它定义了项目的基本信息、依赖库、构建插件等。

Gradle：Gradle是另一个流行的构建工具，通过build.gradle文件定义项目的依赖和构建任务。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'

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

主启动类的编写

主启动类是Spring Boot应用的入口点，通常命名为Application.java。

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注解是一个组合注解，包含了@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解。它告诉Spring Boot这是一个独立的Spring Boot应用，并启用自动配置和组件扫描。

创建一个简单的RESTful服务

Spring Boot中的控制器

控制器是Spring MVC中用于处理HTTP请求的组件。在Spring Boot中，可以使用@Controller或@RestController注解定义控制器。

package com.example.demo;

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

@RestController
public class HelloWorldController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

@RestController：这是一个组合注解，等同于@Controller和@ResponseBody。它用于表示这是一个RESTful控制器，所有返回值都被视为HTTP响应体的一部分。
@GetMapping：用于映射HTTP GET请求到处理器方法。

RESTful API的设计与实现

RESTful API的设计原则包括：

资源：每个资源都有自己的唯一标识。
统一接口：使用HTTP动词（GET、POST、PUT、DELETE）来操作资源。
无状态：每次请求都包含所有客户端信息，服务器无需保存任何信息。
缓存：客户端可以缓存资源，减少服务器负载。

示例代码实现了一个用户资源的RESTful API：

package com.example.demo;

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
public class UserController {

    private static final List<User> users = new ArrayList<>();

    static {
        users.add(new User(1, "Alice"));
        users.add(new User(2, "Bob"));
    }

    @GetMapping("/users")
    public List<User> getAllUsers() {
        return users;
    }

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable int id) {
        return users.stream().filter(user -> user.getId() == id).findFirst().orElse(null);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        user.setId(users.size() + 1);
        users.add(user);
        return user;
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User user) {
        User existingUser = getUser(id);
        if (existingUser != null) {
            existingUser.setName(user.getName());
            return existingUser;
        }
        return null;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable int id) {
        User user = getUser(id);
        if (user != null) {
            users.remove(user);
        }
    }
}

class User {
    private int id;
    private String name;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

使用Spring Boot测试RESTful服务

Spring Boot提供了@SpringBootTest注解，用于测试Spring Boot应用。

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.WebMvcTest;
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.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void shouldReturnDefaultMessage() throws Exception {
        mockMvc.perform(get("/users"))
                .andExpect(status().isOk())
                .andExpect(content().string("[]"));
    }
}

@WebMvcTest：用于测试Spring MVC控制器，自动配置Spring MVC测试环境。
MockMvc：用于模拟HTTP请求和断言响应。

数据访问与集成

使用Spring Data JPA进行数据库操作

Spring Data JPA是Spring Data项目的一部分，用于简化数据库访问操作。它提供了丰富的CRUD操作接口。

package com.example.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import java.util.List;

@SpringBootApplication
@EnableJpaRepositories
public class DemoApplication {

    @PersistenceContext
    private EntityManager entityManager;

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

    @Override
    public void run(String... args) throws Exception {
        List<User> users = entityManager.createQuery("SELECT u FROM User u", User.class).getResultList();
        users.forEach(u -> System.out.println(u.getName()));
    }
}

@EnableJpaRepositories：启用JPA仓库支持。
EntityManager：用于执行JPA查询。

配置数据库连接与实体类

在application.properties文件中配置数据库连接信息：

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update

定义实体类，注解@Entity表示映射到数据库表：

package com.example.demo;

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;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

如何使用Spring Boot与MyBatis集成

Spring Boot可以与MyBatis集成，使用@Mapper注解定义Mapper接口，通过配置文件指定Mapper接口的位置。

package com.example.demo;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user WHERE id = #{id}")
    User findById(int id);
}

在application.properties文件中配置MyBatis：

mybatis.mapper-locations=classpath:mapper/*.xml

Spring Boot中的配置管理

配置文件详解（application.properties/application.yml）

Spring Boot支持application.properties和application.yml两种配置文件格式。

示例application.properties：

spring.datasource.url=jdbc:mysql://localhost:3306/dbname
spring.datasource.username=root
spring.datasource.password=root
spring.jpa.hibernate.ddl-auto=update
server.port=8080

示例application.yml：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/dbname
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: update
server:
  port: 8080

Spring Boot外部化配置

外部化配置允许将配置信息从代码中分离出来，便于维护和部署。

示例application.properties：

spring.datasource.url=${DB_URL}
spring.datasource.username=${DB_USERNAME}
spring.datasource.password=${DB_PASSWORD}

使用环境变量设置这些值：

export DB_URL=jdbc:mysql://localhost:3306/dbname
export DB_USERNAME=root
export DB_PASSWORD=root

配置文件的环境区分

Spring Boot支持根据环境加载不同的配置文件。例如，可以为开发、测试、生产环境分别定义配置文件：

application-dev.properties
application-test.properties
application-prod.properties

在application.properties中指定活动的配置文件：

spring.profiles.active=dev

日志与异常处理

Spring Boot中的日志管理

Spring Boot默认使用Logback作为日志框架，也可通过配置文件更改日志框架。

示例logback-spring.xml：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.example.demo" level="DEBUG"/>

    <root level="INFO">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

配置日志级别与输出格式

在logback-spring.xml中配置：

<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.example.demo" level="DEBUG"/>

    <root level="INFO">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

异常处理机制与自定义异常处理器

Spring Boot提供了一种方便的方式来处理异常。可以通过创建一个全局异常处理器来统一处理不同类型的异常。

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

@ControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleResourceNotFoundException(ResourceNotFoundException ex) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.NOT_FOUND.value(), ex.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.NOT_FOUND);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception ex) {
        ErrorResponse errorResponse = new ErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.value(), ex.getMessage());
        return new ResponseEntity<>(errorResponse, HttpStatus.INTERNAL_SERVER_ERROR);
    }

    static class ErrorResponse {
        private int code;
        private String message;

        public ErrorResponse(int code, String message) {
            this.code = code;
            this.message = message;
        }

        public int getCode() {
            return code;
        }

        public void setCode(int code) {
            this.code = code;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }
    }
}

@ControllerAdvice：用于全局异常处理。
@ExceptionHandler：用于处理特定类型的异常，返回自定义的错误响应。

总结

本文详细介绍了Spring Boot框架的基本概念和使用方法，从环境搭建到项目结构解析，再到RESTful服务创建、数据访问、配置管理、日志与异常处理等各个方面。通过示例代码和配置文件的展示，读者可以更直观地了解如何使用Spring Boot进行实际项目开发。希望读者能够通过本文深入理解Spring Boot框架，更好地应用于实际项目中。