SpringBoot资料入门教程-原创手记-慕课网

概述

本文全面介绍了Spring Boot框架的核心概念和应用实践，包括自动配置、嵌入式Servlet容器、数据库集成、安全框架等，提供了丰富的示例代码和配置说明，帮助开发者快速掌握Spring Boot的使用方法。SpringBoot资料涵盖了从入门到进阶的各个层面，适合不同水平的开发者学习和参考。

SpringBoot简介

什么是SpringBoot

Spring Boot是由Pivotal团队提供的框架，其设计理念是简化Spring应用的开发、部署和运行。Spring Boot基于Spring框架，旨在简化新Spring应用的初始搭建以及开发过程。具体来说，Spring Boot旨在减少初始配置和项目构建的复杂性，使得开发者可以专注于业务逻辑的开发。

Spring Boot支持通过“约定优于配置”的理念，自动配置应用程序所需的基本功能，同时提供了一个易于使用的命令行界面来快速生成应用程序的骨架。它支持创建独立的、基于生产级别的应用程序，可与各种外部资源集成，并支持嵌入式Servlet容器的使用。

SpringBoot的优势和应用场景

优势

无需配置XML：Spring Boot尽量减少对XML的依赖，大多数配置都可以通过注解进行配置。
自动配置：Spring Boot提供了很多默认配置，当满足一定条件时会自动配置相应功能。
起步依赖：Spring Boot通过起步依赖来简化依赖管理，只需要在pom.xml中添加相应依赖即可。
内嵌式服务器：Spring Boot可以内嵌Tomcat、Jetty或Undertow，省去了部署步骤。
命令行界面：提供一个命令行界面，可以快速创建Spring Boot应用、运行应用等。
健康检查：提供一系列的健康检查端点，可以帮助监控应用的健康状况。
嵌入式数据库支持：支持嵌入式数据库，方便开发阶段使用。
外部化配置：支持外部化配置，方便在不同环境中使用不同配置。

应用场景

微服务架构：Spring Boot非常适合构建微服务，可以快速创建独立的微服务应用。
API网关：Spring Boot可以用于创建API网关，管理后端服务的访问。
简单Web应用：快速开发和部署简单的Web应用。
RESTful服务：创建RESTful服务，提供数据访问接口。
数据库集成：支持与多种数据库集成，如JPA、MyBatis等。

SpringBoot的版本介绍

Spring Boot版本的发布遵循语义化版本（SemVer）。Spring Boot版本分为三个部分：主版本号、次版本号和修订版本号。主版本号在API发生不兼容更改时更新，次版本号在添加新的功能或特性时更新，修订版本号在修复bug时更新。

当前，Spring Boot的最新稳定版本是2.7.x。例如，2.7.0是一个主版本，它可能包含新的API和功能，而2.7.1则表示此主版本下的一个小修订版本，主要是为了修复bug或改进性能。

版本更新周期如下：

主版本号：每半年发布一次。
次版本号：每季度发布一次。
修订版本号：根据需要不定期发布。

示例代码

创建一个简单的Spring Boot应用，可以使用Spring Initializr来快速生成项目骨架。例如，通过Spring Initializr，可以生成一个带有spring-boot-starter-web依赖的项目。

<!-- 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.2</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>
``

# SpringBoot快速入门

## 创建SpringBoot项目

创建一个简单的Spring Boot项目，可以使用Spring Initializr，这是一个在线的项目生成器，能够快速生成项目结构和基本配置文件。

### 使用Spring Initializr生成项目

1. 访问Spring Initializr网站：https://start.spring.io/
2. 选择项目类型：Maven项目。
3. 输入项目基本信息，如`Group`和`Artifact`。
4. 选择依赖：`Spring Web`，这将为项目添加基本Web功能。

生成的项目结构如下：

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


### 示例代码

在上面生成的项目中，`DemoApplication.java`是项目启动的入口类，`application.properties`是项目配置文件。

```java
// DemoApplication.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);
    }
}

# application.properties
server.port=8080

项目结构解析

Spring Boot项目结构相对简单，主要分为src/main/java和src/main/resources目录。

Java源代码目录

src/main/java目录存放项目的所有Java源代码，包括主启动类、服务类和控制器等。

资源目录

src/main/resources目录存放项目的资源文件，包括配置文件（如application.properties或application.yml）、静态资源文件等。

示例代码

在src/main/resources目录下，可以创建静态资源文件，如HTML、JavaScript和CSS文件。

<!-- src/main/resources/static/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello World</title>
</head>
<body>
    <h1>Welcome to Spring Boot!</h1>
</body>
</html>

第一个SpringBoot应用程序

创建一个简单的Spring Boot应用，实现一个基本的Web控制器，返回“Hello World”。

创建控制器

在src/main/java目录下创建一个新的控制器类HelloController.java。

// 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("/")
    public String hello() {
        return "Hello World!";
    }
}

运行应用

在IDE中运行DemoApplication.java，或者通过命令行进入项目根目录，执行以下命令启动应用：

mvn spring-boot:run

访问http://localhost:8080/，可以看到返回Hello World!。

示例代码

启动类DemoApplication.java启动应用：

// src/main/java/com/example/demo/DemoApplication.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);
    }
}

SpringBoot配置详解

配置文件介绍

Spring Boot支持两种配置文件：application.properties和application.yml。这两种文件可以用来配置应用的各种属性，例如数据库连接、端口号、应用的环境等。

application.properties

application.properties文件是基于键值对形式的配置文件。例如，定义一个端口号：

server.port=8080

application.yml

application.yml文件是基于YAML格式的配置文件。例如，定义一个端口号：

server:
  port: 8080

两种配置文件在功能上是等价的，可以根据个人喜好选择使用。

示例代码

在application.properties中定义一个数据库连接：

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root

在application.yml中定义相同的数据库连接：

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: root

环境变量与属性注入

Spring Boot支持通过环境变量注入配置属性。例如，可以在环境变量中定义端口号，这样就不需要在配置文件中修改端口号了。

使用环境变量

可以在环境变量中定义一个名为SERVER_PORT的环境变量：

export SERVER_PORT=8081

在Spring Boot应用中，可以通过@Value注解注入环境变量中的值：

// src/main/java/com/example/demo/HelloController.java
package com.example.demo;

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

@RestController
public class HelloController {
    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/")
    public String hello() {
        return "Hello World! Server port is " + serverPort;
    }
}

示例代码

定义一个环境变量：

export SERVER_PORT=8081

在Spring Boot应用中注入环境变量：

// src/main/java/com/example/demo/HelloController.java
package com.example.demo;

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

@RestController
public class HelloController {
    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/")
    public String hello() {
        return "Hello World! Server port is " + serverPort;
    }
}

外部化配置

Spring Boot支持外部化配置，例如，可以在不同的环境中使用不同的配置文件。可以通过spring.profiles.active属性来激活不同的配置文件。

配置文件命名

Spring Boot支持通过配置文件的命名来区分不同环境的配置。例如，可以在src/main/resources目录下创建application-dev.properties和application-prod.properties文件，分别用于开发环境和生产环境。

启用不同的配置文件

可以使用spring.profiles.active属性来选择要激活的配置文件。例如，在application.properties中设置：

spring.profiles.active=dev

或者在运行时通过命令行参数指定：

java -jar app.jar --spring.profiles.active=prod

示例代码

创建application-dev.properties和application-prod.properties文件：

# src/main/resources/application-dev.properties
server.port=8080

# src/main/resources/application-prod.properties
server.port=8081

在application.properties中设置激活的配置文件：

# src/main/resources/application.properties
spring.profiles.active=dev

在运行时通过命令行参数指定激活的配置文件：

java -jar app.jar --spring.profiles.active=prod

SpringBoot核心功能

自动配置原理

Spring Boot的核心功能之一是自动配置（Auto-configuration）。Spring Boot通过自动配置来简化应用的配置工作，自动根据类路径中的依赖关系来配置应用。

自动配置依赖于Spring的@Conditional注解，这些注解可以根据特定的条件来决定是否应用某些配置。例如，Spring Boot会检测类路径中是否有spring-boot-starter-web依赖，如果检测到，则会自动配置一个嵌入的Tomcat服务器。

Spring Boot的自动配置主要通过spring.factories文件来实现。每个自动配置类都必须在META-INF/spring.factories文件中注册。

示例代码

在spring.factories文件中，可以注册一个自动配置类：

# META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.example.demo.MyAutoConfiguration

在MyAutoConfiguration.java中定义自动配置逻辑：

package com.example.demo;

import org.springframework.context.annotation.Configuration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

@Configuration
@EnableAutoConfiguration
public class MyAutoConfiguration {
    // 自动配置逻辑
}

启动器的作用

Spring Boot的启动器（Starter）是方便依赖管理的工具，它为常见的开发场景提供了一组预定义的依赖集合。例如，spring-boot-starter-web包含了开发一个Web应用所需要的所有依赖。

每个启动器都包含一组默认的依赖，当项目中添加了对应的启动器依赖时，Spring Boot会自动引入这些依赖，并进行相应的配置。

示例代码

在pom.xml中添加spring-boot-starter-web启动器依赖：

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

SpringBoot的嵌入式Servlet容器

Spring Boot内置了对Tomcat、Jetty和Undertow的支持，可以将这些Servlet容器直接内嵌到应用中，这样不需要单独安装Servlet容器，简化了应用的部署过程。

示例代码

在pom.xml中添加spring-boot-starter-web启动器依赖，会自动引入嵌入式Tomcat服务器：

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

启动应用时，Spring Boot会自动启动嵌入式Tomcat服务器：

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);
    }
}

SpringBoot常用组件

数据库集成

Spring Boot支持多种数据库集成，包括JPA、MyBatis等。

JPA集成

JPA是一种ORM框架，使得开发者可以以面向对象的方式操作数据库。Spring Boot通过spring-boot-starter-data-jpa起步依赖提供了对JPA的支持。

示例代码

在pom.xml中添加JPA依赖：

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

创建一个JPA实体类：

package com.example.demo.entity;

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 and Setter methods
}

创建一个JPA Repository接口：

package com.example.demo.repository;

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

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

使用Repository接口进行数据库操作：

package com.example.demo.service;

import com.example.demo.entity.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 saveUser(User user) {
        return userRepository.save(user);
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

MyBatis集成

MyBatis是一个持久层框架，用于将Java对象映射到数据库表。Spring Boot通过spring-boot-starter-mybatis起步依赖提供了对MyBatis的支持。

示例代码

在pom.xml中添加MyBatis依赖：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>

创建一个MyBatis实体类：

package com.example.demo.entity;

public class User {
    private Long id;
    private String name;
    private String email;

    // Getter and Setter methods
}

创建一个Mapper接口：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper {
    User getUserById(Long id);
}

创建一个Mapper XML配置文件：

<!-- src/main/resources/mapper/UserMapper.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.demo.entity.User">
        SELECT id, name, email FROM user WHERE id = #{id}
    </select>
</mapper>

使用Mapper接口进行数据库操作：

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }
}

日志框架

Spring Boot支持多种日志框架，包括SLF4J和Logback。

SLF4J

SLF4J是一个简单、易用的日志框架接口，它不直接提供日志实现，而是作为其他日志框架的接口层。Spring Boot默认使用SLF4J作为日志接口。

示例代码

在pom.xml中添加SLF4J依赖：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
</dependency>

在pom.xml中添加Logback依赖，作为SLF4J的实现：

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
</dependency>

在application.properties中配置Logback：

# src/main/resources/application.properties
logging.file.name=logs/app.log
logging.level.root=INFO

在代码中使用SLF4J进行日志记录：

package com.example.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);

    public static void main(String[] args) {
        logger.info("Application is starting...");
        SpringApplication.run(DemoApplication.class, args);
    }
}

Logback

Logback是Log4j的继任者，它同样支持SLF4J接口。Spring Boot默认使用Logback作为日志实现。

示例代码

在pom.xml中添加Logback依赖：

<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
</dependency>

在application.properties中配置Logback：

# src/main/resources/application.properties
logging.file.name=logs/app.log
logging.level.root=INFO

在代码中使用SLF4J进行日志记录：

package com.example.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
    private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);

    public static void main(String[] args) {
        logger.info("Application is starting...");
        SpringApplication.run(DemoApplication.class, args);
    }
}

安全框架

Spring Boot支持多种安全框架，包括Spring Security。

Spring Security

Spring Security是一个强大的安全框架，可以提供认证和授权功能。Spring Boot通过spring-boot-starter-security起步依赖提供了对Spring Security的支持。

示例代码

在pom.xml中添加Spring Security依赖：

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

在pom.xml中添加Thymeleaf依赖，用于渲染安全相关的视图：

<dependency>
    <groupId>org.springframework.boot</groupId>
   . . .

创建一个简单的login.html文件：

<!-- src/main/resources/templates/login.html -->
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Login</title>
</head>
<body>
    <h1>Login</h1>
    <form action="#" th:action="@{/login}" th:method="post">
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" />
        <br />
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" />
        <br />
        <input type="submit" value="Login" />
    </form>
</body>
</html>

配置Spring Security：

package com.example.demo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/").permitAll()
            .anyRequest().authenticated()
            .and()
            .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

启动应用时，Spring Security会自动配置一个登录页面，并对所有请求进行安全检查。

SpringBoot项目实战

创建RESTful API

创建一个简单的RESTful API，提供用户数据的增删改查功能。

创建实体类

创建一个用户实体类User.java：

package com.example.demo.entity;

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 and Setter methods
}

创建Repository接口

创建一个用户Repository接口UserRepository.java：

package com.example.demo.repository;

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

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

创建Service层

创建一个用户服务类UserService.java：

package com.example.demo.service;

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

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public User updateUser(User user) {
        return userRepository.save(user);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

创建Controller层

创建一个用户控制器类UserController.java：

package com.example.demo.controller;

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

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public ResponseEntity<List<User>> getAllUsers() {
        return ResponseEntity.ok(userService.getAllUsers());
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = userService.getUserById(id);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

    @PostMapping
    public ResponseEntity<User> saveUser(@RequestBody User user) {
        return ResponseEntity.ok(userService.saveUser(user));
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return ResponseEntity.ok(userService.updateUser(user));
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

示例代码

启动类：

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);
    }
}

运行应用

在IDE中运行DemoApplication.java，或者通过命令行进入项目根目录，执行以下命令启动应用：

mvn spring-boot:run

访问http://localhost:8080/users，可以看到返回用户列表。

单元测试与集成测试

Spring Boot支持单元测试和集成测试，可以使用JUnit、Mockito等测试框架来编写测试代码。

单元测试

单元测试主要测试单个方法或功能。例如，测试UserService中的saveUser方法。

示例代码

创建一个单元测试类UserServiceTest.java：

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

class UserServiceTest {
    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserService userService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testSaveUser() {
        User user = new User();
        user.setName("John");
        user.setEmail("john@example.com");

        when(userRepository.save(user)).thenReturn(user);

        User savedUser = userService.saveUser(user);

        assertNotNull(savedUser);
        assertEquals("John", savedUser.getName());
        assertEquals("john@example.com", savedUser.getEmail());

        verify(userRepository, times(1)).save(user);
    }
}

集成测试

集成测试主要测试整个应用或多个组件之间的交互。例如，测试UserController中的getAllUsers方法。

示例代码

创建一个集成测试类UserControllerTest.java：

package com.example.demo.controller;

import com.example.demo.entity.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.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

import java.util.Arrays;

@WebMvcTest
class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserRepository userRepository;

    @BeforeEach
    void setUp() {
        // 设置用户数据
        User user1 = new User();
        user1.setId(1L);
        user1.setName("John");
        user1.setEmail("john@example.com");

        User user2 = new User();
        user2.setId(2L);
        user2.setName("Jane");
        user2.setEmail("jane@example.com");

        when(userRepository.findAll()).thenReturn(Arrays.asList(user1, user2));
    }

    @Test
    void testGetAllUsers() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/users")
                .accept(MediaType.APPLICATION_JSON))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("$.[0].name").value("John"))
                .andExpect(MockMvcResultMatchers.jsonPath("$.[1].name").value("Jane"));
    }
}

构建与部署

构建应用

Spring Boot应用可以使用Maven或Gradle进行构建。使用Maven构建时，可以使用mvn package命令打包应用。

示例代码

在项目根目录执行以下命令进行打包：

mvn package

部署应用

Spring Boot应用可以部署到任何支持Java的应用服务器上，如Tomcat、Jetty或Undertow。可以将生成的.jar文件部署到这些服务器上，或者直接运行.jar文件启动应用。

示例代码

运行生成的.jar文件：

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

或者将.jar文件部署到Tomcat服务器上：

// 将jar文件复制到Tomcat的webapps目录下
cp target/demo-0.0.1-SNAPSHOT.jar /path/to/tomcat/webapps/

启动Tomcat服务器：

// 启动Tomcat服务器
/path/to/tomcat/bin/startup.sh

访问http://localhost:8080/demo-0.0.1-SNAPSHOT，可以看到应用启动成功。