Java教程

Springboot微服务资料入门教程

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

本文详细介绍了Spring Boot微服务的基础搭建，包括项目创建、依赖配置以及RESTful服务的实现，提供了丰富的Springboot微服务资料，帮助开发者快速构建和管理微服务应用。

Spring Boot简介
Spring Boot是什么

Spring Boot 是一个简化Spring应用开发的框架，它通过约定优于配置的原则，使开发者能够快速搭建独立运行的Spring应用。Spring Boot的目标是简化新Spring应用的初始搭建以及开发过程，使得开发者可以不用写大量的配置代码，只需要提供必要的配置即可快速完成应用的搭建。

Spring Boot的优势
  1. 自动配置：Spring Boot可以自动配置应用程序的依赖项，如数据库、缓存、任务调度等。例如，对于数据库配置，Spring Boot会根据application.properties或application.yml中的配置自动配置数据源。
  2. 起步依赖：通过起步依赖，开发者可以快速添加依赖，Spring Boot会自动配置这些依赖，简化了依赖的管理。例如，添加spring-boot-starter-web依赖即可以起动一个Web应用。
  3. 嵌入式服务器：Spring Boot可以内嵌一个Tomcat或Jetty服务器，开发者无需配置繁琐的web.xml文件，直接运行应用即可启动服务器。
  4. 健康检查：内置Spring Boot Actuator提供健康检查、监控等功能，帮助开发者快速了解应用的状态。
  5. 外部配置：通过外部配置文件（如application.properties或application.yml）可以灵活地配置应用的各种参数。
  6. 快速集成：支持快速集成各种技术栈，如JPA、MyBatis、缓存、任务调度等。
  7. 没有代码生成：与传统的Spring应用开发不同，Spring Boot不需要开发者编写大量的配置代码。
  8. 支持热加载：支持热加载，开发者在调试代码时可以自动编译并更新应用。
  9. 全面的自动化配置：通过自动化的配置，Spring Boot可以帮助开发者快速搭建应用，减少应用开发的时间。
Spring Boot与Spring的区别
  • Spring：是一个全面的开发框架，提供了大量的功能模块，如Spring MVC、Spring AOP、Spring Security等。开发者需要手动配置这些模块。
  • Spring Boot：基于Spring框架，简化了Spring应用的初始搭建和开发过程，减少了开发者的配置工作量。Spring Boot提供了大量的自动配置功能，开发者只需通过简单的配置即可搭建一个功能完善的Spring应用。例如，一个简单的Web应用可以通过添加spring-boot-starter-web依赖并配置application.properties或application.yml文件来实现。
Spring Boot微服务的基础搭建
创建第一个Spring Boot微服务项目

创建一个简单的Spring Boot项目，可以使用IDE自带的向导来创建，如IntelliJ IDEA或Eclipse。以下是使用IDEA创建项目的步骤：

  1. 打开IntelliJ IDEA或Eclipse。
  2. 选择“文件” -> “新建” -> “项目”。
  3. 选择“Spring Initializr”，填写项目基本信息，如项目名称、语言（Java）、构建工具（Maven或Gradle）、Spring Boot版本等。
  4. 填写完成后，点击“下一步”，选择所需的依赖项，例如spring-boot-starter-web用于创建简单的RESTful服务。
  5. 选择完依赖后，点击“完成”按钮，IDE会自动生成项目结构。

以下是创建项目时选择的基础依赖：

  • spring-boot-starter-web：用于创建简单的RESTful服务。
  • spring-boot-starter-actuator：用于健康检查和监控。

创建完成后，项目结构如下：

src
└── main
    ├── java
    │   └── com
    │       └── example
    │           └── demo
    │               ├── DemoApplication.java
    │               └── controller
    │                   └── HelloController.java
    └── resources
        ├── application.properties
        └── application.yml

相应的pom.xml或build.gradle文件示例如下：

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>
// build.gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}
使用Spring Initializr快速搭建项目

Spring Initializr是一个在线的项目生成工具，可以帮助开发者快速创建Spring Boot项目。以下是使用Spring Initializr创建项目的步骤：

  1. 访问Spring Initializr网站：https://start.spring.io/
  2. 填写项目基本信息，如组ID、模块名、语言（Java）、构建工具（Maven或Gradle）、Java版本、Spring Boot版本。
  3. 填写完成后，选择所需依赖项，如Web、Actuator等。
  4. 点击“生成”按钮，下载项目压缩包。
  5. 解压项目压缩包，并导入到IDE中。

创建完成后，项目的pom.xml或build.gradle文件会自动生成，例如：

<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>
// build.gradle
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
}
配置文件详解（application.properties与application.yml）

Spring Boot项目中常用的配置文件有两种：application.properties和application.yml。这两种配置文件都可以用来定义应用的各种参数。

application.properties

application.properties是一个基于键值对的配置文件，通过键值对的形式来设置应用的各种参数。例如：

# 配置应用端口
server.port=8080

# 配置数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 配置日志级别
logging.level.root=INFO

application.yml

application.yml是一个基于YAML格式的配置文件，相比于application.properties更易于阅读和编写。例如：

server:
  port: 8080

spring:
  datasource:
  url: jdbc:mysql://localhost:3306/mydb
  username: root
  password: root
  driver-class-name: com.mysql.cj.jdbc.Driver

logging:
 level:
  root: INFO

在实际开发中，可以根据项目的需要选择使用application.properties或application.yml。需要注意的是，当同时存在application.properties和application.yml时，Spring Boot会优先读取application.yml文件。

微服务通信方式简介
RESTful服务介绍

REST（Representational State Transfer）是一种轻量级的架构风格，它利用HTTP协议的特性，通过URL来操作资源，使服务变得可扩展和易于维护。RESTful服务通常通过GET、POST、PUT、DELETE等HTTP方法来实现对资源的访问、创建、更新和删除操作。

使用Spring Boot实现RESTful服务

使用Spring Boot可以很容易地实现RESTful服务。以下是一个简单的RESTful服务示例：

  1. 定义一个简单的实体类User：
public class User {
    private Long id;
    private String name;
    private String email;

    // 省略getter和setter方法
}
  1. 创建一个Controller类，用于处理HTTP请求：
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

    @GetMapping("/users")
    public List<User> getAllUsers() {
        // 实际项目中，这里会从数据库中获取用户列表
        return List.of(
            new User(1L, "张三", "zhangsan@example.com"),
            new User(2L, "李四", "lisi@example.com")
        );
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        // 实际项目中，这里会根据id从数据库中获取用户信息
        return new User(id, "张三", "zhangsan@example.com");
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        // 实际项目中，这里会将用户信息保存到数据库中
        return user;
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        // 实际项目中，这里会根据id更新用户信息
        return user;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        // 实际项目中，这里会根据id删除用户信息
    }
}
  1. 在主应用类中启动Spring Boot应用：
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);
    }
}

上述代码中定义了一个简单的RESTful服务，可以通过HTTP请求来操作用户资源。例如，可以使用GET /users来获取所有用户，使用POST /users来创建一个新用户。

RPC服务简介

RPC（Remote Procedure Call）是一种远程过程调用技术，它允许一个程序调用另一个程序（位于不同的地址空间）中的过程或例程。与RESTful服务相比，RPC通常提供更高级别的抽象，使得服务调用更类似于本地函数调用。

使用Spring Boot实现RPC服务

使用Spring Boot可以很容易地实现RPC服务。以下是一个简单的RPC服务示例，使用Spring Cloud Stream来实现：

  1. 引入需要的依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
  1. 创建一个消息处理类：
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Processor;
import org.springframework.messaging.handler.annotation.Payload;

@EnableBinding(Processor.class)
public class RabbitMQMessageHandler {

    @StreamListener(Processor.INPUT)
    public void handle(@Payload String message) {
        System.out.println("Received message: " + message);
    }
}
  1. 创建一个消息发送类：
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.Output;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;

@EnableBinding(Processor.class)
public class RabbitMQMessageSender {

    @Output(Processor.OUTPUT)
    private MessageChannel output;

    public void sendMessage(String message) {
        output.send(MessageBuilder.withPayload(message).build());
    }
}
  1. 在主应用类中启动Spring Boot应用：
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);
    }
}

上述代码中定义了一个简单的RPC服务，可以通过消息队列来发送和接收消息。例如，可以使用RabbitMQMessageSender类来发送消息，使用RabbitMQMessageHandler类来处理接收到的消息。

微服务中的数据存储
数据库的选择与配置

在Spring Boot应用中，可以使用多种数据库，如关系型数据库（MySQL、PostgreSQL、Oracle等）和NoSQL数据库（MongoDB、Redis等）。以下是一些常见的数据库配置示例：

MySQL数据库配置

在application.properties或application.yml文件中配置MySQL数据库：

# application.properties
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# application.yml
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver

PostgreSQL数据库配置

在application.properties或application.yml文件中配置PostgreSQL数据库：

# application.properties
spring.datasource.url=jdbc:postgresql://localhost:5432/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=org.postgresql.Driver
# application.yml
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: root
    password: root
    driver-class-name: org.postgresql.Driver
使用Spring Boot集成JPA与MyBatis

使用Spring Boot集成JPA

JPA（Java Persistence API）是一种用于对象关系映射（ORM）的规范。Spring Boot可以通过Spring Data JPA来简化JPA的使用。以下是一个简单的JPA示例：

  1. 引入需要的依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
  1. 创建一个实体类User：
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方法
}
  1. 创建一个Repository接口：
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}
  1. 创建一个Service类：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

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

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

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

    public User updateUser(Long id, User user) {
        // 实际项目中，这里会根据id更新用户信息
        return userRepository.save(user);
    }

    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}
  1. 创建一个Controller类：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

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

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

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

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getUserById(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

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

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

使用Spring Boot集成MyBatis

MyBatis是一种持久层框架，可以用来操作数据库。Spring Boot可以通过Spring Boot Starter MyBatis来简化MyBatis的使用。以下是一个简单的MyBatis示例：

  1. 引入需要的依赖：
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.2.0</version>
</dependency>
  1. 创建一个实体类User：
public class User {
    private Long id;
    private String name;
    private String email;

    // 省略getter和setter方法
}
  1. 创建一个Mapper接口：
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM user")
    List<User> getAllUsers();
}
  1. 创建一个Service类：
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    private final SqlSessionFactory sqlSessionFactory;

    @Autowired
    public UserService(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    public List<User> getAllUsers() {
        try (SqlSession session = sqlSessionFactory.openSession()) {
            UserMapper mapper = session.getMapper(UserMapper.class);
            return mapper.getAllUsers();
        }
    }
}
  1. 创建一个Controller类：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

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

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}
使用Spring Boot实现数据缓存

在Spring Boot中，可以使用多种缓存实现，如Ehcache、Hazelcast、Redis等。以下是一个简单的Redis缓存示例：

  1. 引入需要的依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. 配置Redis连接：

在application.properties或application.yml文件中配置Redis连接：

# application.properties
spring.redis.host=localhost
spring.redis.port=6379
# application.yml
spring:
  redis:
    host: localhost
    port: 6379
  1. 创建一个Service类，并使用@Cacheable注解：
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {

    // 使用@Cacheable注解缓存用户列表
    @Cacheable("users")
    public List<User> getAllUsers() {
        // 实际项目中，这里会从数据库中获取用户列表
        return List.of(
            new User(1L, "张三", "zhangsan@example.com"),
            new User(2L, "李四", "lisi@example.com")
        );
    }
}
  1. 创建一个Controller类：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

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

    private final UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }
}
微服务监控与日志
应用监控简介

应用监控是微服务架构中非常重要的一部分，它可以帮助开发者了解应用的运行状态，及时发现并解决问题。Spring Boot Actuator提供了丰富的监控功能，如健康检查、线程池信息、HTTP请求统计等。

使用Spring Boot Actuator实现应用监控

Spring Boot Actuator是一个增强应用监控和管理功能的模块，可以通过简单的配置来启用。以下是一个简单的Actuator配置示例：

  1. 引入Actuator依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
  1. 配置Actuator端点：

在application.properties或application.yml文件中配置Actuator端点：

# application.properties
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
# application.yml
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always

上述配置中，management.endpoints.web.exposure.include=*表示启用所有端点的HTTP接口访问，management.endpoint.health.show-details=always表示显示健康检查的详细信息。

  1. 创建一个简单的Controller类来调用Actuator端点：
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Map;

@RestController
@RequestMapping("/actuator")
public class ActuatorController {

    @GetMapping("/health")
    public Map<String, Object> getHealth() {
        // 调用Actuator的health端点
        return new HealthEndpoint().invoke();
    }
}
  1. 在主应用类中启动Spring Boot应用：
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);
    }
}

上述代码中，通过HTTP请求来访问Actuator提供的健康检查端点，可以获取应用的健康状态。

日志管理与配置

日志管理是微服务架构中非常重要的一部分，它可以帮助开发者了解应用的运行状态，及时发现并解决问题。Spring Boot使用SLF4J作为日志门面，通过logback或log4j实现具体的日志记录。

日志配置

在logback-spring.xml或log4j-spring.xml文件中配置日志记录：

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

    <root level="INFO">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>
<!-- log4j-spring.xml -->
<Configuration>
    <Appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <Encoder>
            <Pattern>%d{yyyy-MM-dd HH:mm:ss} - %m%n</Pattern>
        </Encoder>
    </Appender>

    <Root level="INFO">
        <AppenderRef ref="STDOUT" />
    </Root>
</Configuration>

上述配置中，定义了一个STDOUT输出到控制台的Appender，并设置了日志格式和级别。

微服务部署与测试
微服务部署方式简介

在微服务架构中，可以使用多种部署方式，如Docker、Kubernetes、虚拟机等。以下是一些常见的部署方式：

  • Docker：使用Docker可以将应用打包成容器，便于部署和迁移。
  • Kubernetes：使用Kubernetes可以对多个容器进行编排和管理。
  • 虚拟机：使用虚拟机可以为每个服务分配独立的资源。
使用Docker打包Spring Boot微服务

使用Docker可以将Spring Boot应用打包成容器，便于部署和迁移。以下是一个简单的Docker打包示例：

  1. 引入需要的依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
  1. 创建一个简单的Spring Boot应用：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
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 HelloController {

    @GetMapping("/")
    public String hello() {
        return "Hello World!";
    }
}
  1. 创建一个Dockerfile，用于构建Docker镜像：
# 使用官方的Java运行时作为父镜像
FROM openjdk:11-jre-slim

# 设置环境变量
ENV APP_NAME=hello-world
ENV APP_VERSION=1.0

# 拷贝可执行jar包到镜像中
COPY target/${APP_NAME}-${APP_VERSION}.jar app.jar

# 暴露端口
EXPOSE 8080

# 运行jar包
ENTRYPOINT ["java", "-jar", "/app.jar"]
  1. 构建Docker镜像：
docker build -t hello-world:1.0 .
  1. 运行Docker容器：
docker run -p 8080:8080 -t hello-world:1.0
单元测试与集成测试

在Spring Boot应用中，可以使用多种测试框架来编写单元测试和集成测试，如JUnit、Mockito、Spring Boot Test等。以下是一个简单的单元测试示例：

单元测试

  1. 引入需要的依赖：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
  1. 创建一个简单的单元测试类：
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
public class UserControllerTest {

    @Autowired
    private UserController userController;

    @Test
    public void testGetAllUsers() {
        List<User> users = userController.getAllUsers();
        assertEquals(2, users.size());
    }
}

集成测试

  1. 创建一个集成测试类：
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.ResponseEntity;

import java.util.List;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class UserControllerIntegrationTest {

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    public void testGetAllUsers() throws Exception {
        ResponseEntity<List<User>> response = restTemplate.getForEntity("/users", List.class);
        assertEquals(2, response.getBody().size());
    }
}

上述代码中，UserControllerTest是一个简单的单元测试类，用于测试UserController中的方法是否按预期工作。UserControllerIntegrationTest是一个集成测试类，用于测试整个应用的功能是否按预期工作。

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