Java教程

SpringBoot资料入门教程

本文主要是介绍SpringBoot资料入门教程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
概述

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

SpringBoot简介
什么是SpringBoot

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

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

SpringBoot的优势和应用场景

优势

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

应用场景

  1. 微服务架构：Spring Boot非常适合构建微服务，可以快速创建独立的微服务应用。
  2. API网关：Spring Boot可以用于创建API网关，管理后端服务的访问。
  3. 简单Web应用：快速开发和部署简单的Web应用。
  4. RESTful服务：创建RESTful服务，提供数据访问接口。
  5. 数据库集成：支持与多种数据库集成，如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，可以看到应用启动成功。

这篇关于SpringBoot资料入门教程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
栏目导航