Spring Boot微服务学习：从入门到实践

Spring Boot 微服务学习：从入门到实践 概述

本文深入介绍了Spring Boot微服务学习的相关内容，涵盖了Spring Boot微服务的基础概念、快速搭建Spring Boot项目的方法、微服务开发基础以及微服务的通信机制。此外，文章还详细讲解了服务治理与容错机制，并提供了部署与监控微服务的实用指南。

1. Spring Boot 微服务简介

1.1 微服务的概念

微服务是一种将单一应用程序开发为多个小型服务的方法，每个服务在独立的进程中运行，并通过定义良好的API进行通信。这些服务围绕业务功能构建，可以独立部署、扩展和维护。例如，一个电子商务网站可以被拆分为订单服务、支付服务、库存服务等多个微服务。微服务架构的核心思想是将一个大型复杂的应用程序分解为多个小型、独立的服务，每个服务负责一个独立的业务功能。

1.2 Spring Boot 的特点

Spring Boot 是一个基于Spring框架的简化开发框架。它通过自动配置、约定优于配置、内嵌Web服务器等方式极大简化了Spring应用的开发。以下是Spring Boot的一些主要特点：

• 自动配置：Spring Boot能够根据应用类型自动配置应用环境，减少了大量配置代码的编写。例如，它可以自动配置数据库连接、数据源、Web服务器等。
• 约定优于配置：Spring Boot遵循一套约定，开发者只需遵守这些约定，就能快速地创建应用，而不需要配置很多XML或Properties文件。
• 内嵌Web容器：Spring Boot默认提供了内嵌的Web服务器（如Tomcat、Jetty、Undertow），可以将应用直接打包成一个可执行的Jar文件，简化了部署过程。
• 生产就绪的特性：Spring Boot提供了许多特性，如健康检查、监控、审计等，使应用在生产环境中更加健壮。
• 无代码生成和XML配置：Spring Boot强调无代码生成和无XML配置，使开发过程更加简洁和高效。

1.3 Spring Boot 与 微服务的关系

虽然Spring Boot本身并不是一个微服务框架，但它为开发微服务提供了许多便捷的工具和特性。例如，可以使用Spring Boot的自动配置和约定优于配置机制快速搭建和部署服务。此外，Spring Boot与Spring Cloud结合使用时，可以方便地实现服务发现、服务治理、负载均衡、熔断等微服务架构的核心功能。下面是一个简单的Spring Boot微服务项目示例：

package com.example.demo;

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
class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "{ \"message\": \"Hello, World!\" }";
    }
}

通过上述示例，可以看到使用Spring Boot开发微服务可以更加简单和高效。

2. 快速搭建Spring Boot项目

2.1 使用IDEA创建Spring Boot项目

开发Spring Boot应用通常使用IntelliJ IDEA或Eclipse等IDE。以下是使用IntelliJ IDEA创建Spring Boot项目的步骤：

1. 打开IntelliJ IDEA，创建一个新项目。
2. 选择“Spring Initializr”或其他Spring Boot项目创建工具。
3. 填写项目名称和依赖。
4. 点击“Finish”按钮完成创建。

2.2 配置项目依赖

在创建Spring Boot项目之后，需要配置项目的依赖。例如，可以使用Spring Web和Spring Data JPA等依赖。在IDEA中，可以通过pom.xml文件（对于Maven项目）或build.gradle文件（对于Gradle项目）来配置项目依赖。

2.2.1 Maven项目依赖配置

在pom.xml文件中，添加以下依赖：

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Boot Starter JPA -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

2.2.2 Gradle项目依赖配置

在build.gradle文件中，添加以下依赖：

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'mysql:mysql-connector-java'
}

2.3 运行第一个Spring Boot应用

配置好项目依赖后，可以编写第一个Spring Boot应用。以下是一个简单的Spring Boot应用示例，它返回一个简单的JSON响应：

package com.example.demo;

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
class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "{ \"message\": \"Hello, World!\" }";
    }
}

在IDEA中运行DemoApplication类，启动应用后访问http://localhost:8080/hello，可以看到返回的JSON响应。

3. Spring Boot 微服务开发基础

3.1 创建RESTful服务

RESTful服务是一种基于HTTP协议的轻量级服务，可以提供简单的、无状态的、幂等的操作。Spring Boot提供了@RestController注解，可以方便地创建RESTful服务。

3.1.1 示例代码

以下是一个简单的RESTful服务示例，该服务返回一个用户列表：

package com.example.demo;

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;

import java.util.Arrays;
import java.util.List;

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

@RestController
class UserController {
    @GetMapping("/users")
    public List<String> getUsers() {
        return Arrays.asList("John", "Jane", "Doe");
    }
}

3.2 使用Spring Data JPA操作数据库

Spring Data JPA是Spring Data项目的一部分，它提供了一种简单的方式来操作数据库。可以使用注解定义数据模型和数据库操作。以下是一个简单的Spring Data JPA示例，它定义了一个User实体和一个UserRepository接口。

3.2.1 实体定义

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;

    // getters and setters
    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;
    }
}

3.2.2 数据库操作接口

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

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

3.2.3 使用数据库操作接口

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
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;

import java.util.List;

@SpringBootApplication
public class DemoApplication {
    @Autowired
    private UserRepository userRepository;

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

    public void run(String... args) throws Exception {
        User user = new User();
        user.setName("John");
        userRepository.save(user);
    }
}

@RestController
class UserController {
    @Autowired
    private UserRepository userRepository;

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

3.3 配置日志和异常处理

在Spring Boot应用中，可以使用logback-spring.xml配置日志，使用@ControllerAdvice和@ExceptionHandler注解配置全局异常处理。

3.3.1 日志配置

在src/main/resources目录下创建logback-spring.xml文件，添加以下内容：

<configuration>
    <property name="LOG_HOME" value="logs"/>

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

    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>${LOG_HOME}/app.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>

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

3.3.2 异常处理

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.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public ErrorDetails handleUserNotFoundException(UserNotFoundException ex) {
        return new ErrorDetails(LocalDateTime.now(), ex.getMessage(), "User not found");
    }

    @ExceptionHandler(Exception.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ErrorDetails handleException(Exception ex) {
        return new ErrorDetails(LocalDateTime.now(), ex.getMessage(), "Internal server error");
    }
}

class UserNotFoundException extends RuntimeException {
    public UserNotFoundException(String message) {
        super(message);
    }
}

class ErrorDetails {
    private LocalDateTime timestamp;
    private String message;
    private String details;

    public ErrorDetails(LocalDateTime timestamp, String message, String details) {
        this.timestamp = timestamp;
        this.message = message;
        this.details = details;
    }

    // getters and setters
}

4. 微服务的通信机制

4.1 RESTful API 通信

微服务之间可以通过HTTP协议进行通信，这种通信方式通常使用RESTful API。在Spring Boot应用中，可以通过创建RESTful服务来进行服务间的通信。

4.1.1 示例代码

服务提供者：

package com.example.serviceprovider;

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 ServiceProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceProviderApplication.class, args);
    }
}

@RestController
class ServiceProviderController {
    @GetMapping("/service")
    public String getService() {
        return "Service from service provider";
    }
}

服务消费者：

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.client.RestTemplate;

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

@RestController
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/service")
    public String getService() {
        return restTemplate.getForObject("http://localhost:8081/service", String.class);
    }
}

4.2 使用Spring Cloud进行服务间通信

Spring Cloud是一组开源框架，用于简化分布式系统开发。Spring Cloud提供了服务发现、服务治理等功能，使得微服务间的通信更加简便。

4.2.1 服务注册与发现

在Spring Cloud中，可以使用Spring Cloud Netflix Eureka来实现服务注册与发现。Eureka是一个服务注册和发现的组件，它的主要功能是提供服务注册和发现的能力。在服务提供者启动时，它会将服务注册到Eureka，服务消费者通过查询Eureka获取服务提供者的地址并进行通信。

服务提供者：

package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
public class ServiceProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceProviderApplication.class, args);
    }
}

@RestController
class ServiceProviderController {
    @GetMapping("/service")
    public String getService() {
        return "Service from service provider";
    }
}

服务消费者：

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@EnableHystrixDashboard
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}

@RestController
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/service")
    public String getService() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/service", String.class);
    }

    @GetMapping("/service2")
    public String getService2() {
        return this.restTemplate.getForObject("http://SERVICE-PROVIDER2/service2", String.class);
    }
}

4.3 服务发现与注册（Spring Cloud Eureka）

在Spring Cloud中，可以使用Eureka来实现服务发现和注册。Eureka是一个服务发现组件，提供了服务注册、服务发现、服务健康检查等功能。以下是一个简单的Eureka服务注册与发现示例。

4.3.1 Eureka Server

创建一个Eureka Server，用于注册和发现服务：

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaServerApplication.class, args);
    }
}

4.3.2 Eureka Client

创建一个Eureka Client，注册到Eureka Server：

package com.example.serviceprovider;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
public class ServiceProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceProviderApplication.class, args);
    }
}

@RestController
class ServiceProviderController {
    @GetMapping("/service")
    public String getService() {
        return "Service from service provider";
    }
}

5. 服务治理与容错机制

5.1 服务熔断（Hystrix）

Hystrix是Netflix开源的一个延迟和容错库，用于提高分布式系统和服务之间的交互性。Hystrix通过隔离服务的访问点，阻止服务之间的相互影响，同时提供快速失败（fallback）机制来提高系统的可用性。

5.1.1 示例代码

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@EnableHystrixDashboard
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}

@RestController
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/service")
    public String getService() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/service", String.class);
    }

    @GetMapping("/service2")
    public String getService2() {
        return this.restTemplate.getForObject("http://SERVICE-PROVIDER2/service2", String.class);
    }
}

5.2 服务降级与重试

服务降级是指当某个微服务出现问题时，提供一个备用的服务来替代，以保证系统整体的稳定性。服务重试是指在调用服务失败时，尝试重新调用，直到成功或者达到最大重试次数。

5.2.1 示例代码

package com.example.serviceconsumer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableEurekaClient
@EnableHystrix
@EnableHystrixDashboard
@EnableRetry
public class ServiceConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ServiceConsumerApplication.class, args);
    }
}

@RestController
class ServiceConsumerController {
    private final RestTemplate restTemplate;

    public ServiceConsumerController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/service")
    public String getService() {
        return restTemplate.getForObject("http://SERVICE-PROVIDER/service", String.class);
    }

    @GetMapping("/service2")
    public String getService2() {
        return this.restTemplate.getForObject("http://SERVICE-PROVIDER2/service2", String.class);
    }
}

5.3 断路器与监控（Spring Boot Actuator）

Spring Boot Actuator提供了生产就绪的功能，包括健康检查、审计、配置监视等。可以使用Actuator来监控系统的运行状态，例如系统内存使用情况、线程状态、HTTP请求统计等。

5.3.1 示例代码

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
import org.springframework.boot.actuate.autoconfigure.web.ManagementPortType;
import org.springframework.boot.actuate.endpoint.web.EndpointWebProperties;
import org.springframework.boot.actuate.endpoint.web.WebEndpointsSupplier;
import org.springframework.boot.actuate.endpoint.web.servlet.WebMvcEndpointHandlerMapping;
import org.springframework.boot.web.servlet.server.ServletWebServerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.core.annotation.Order;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

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

    @Bean
    public WebMvcConfigurer webMvcConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/**").allowedOrigins("*");
            }
        };
    }

    @Bean
    @Order(-100)
    public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier, ServletEndpointRegistrar servletEndpointRegistrar, WebEndpointProperties webEndpointProperties) {
        EndpointMapping endpointMapping = webEndpointProperties.getDefaultEndpointMapping();
        return new WebMvcEndpointHandlerMapping(webEndpointsSupplier.getEndpoints(), endpointMapping, servletEndpointRegistrar, webEndpointProperties);
    }
}

6. 部署与监控微服务

6.1 使用Docker容器化部署Spring Boot应用

Docker是一个开源的应用容器引擎，它可以让开发者将应用程序及其依赖打包到一个可移植的容器中。使用Docker容器化部署Spring Boot应用可以简化部署过程，确保应用在不同环境中的一致性。

6.1.1 Dockerfile示例

创建一个Dockerfile，用于构建Spring Boot应用的镜像：

# 使用官方的Java运行时作为基础镜像
FROM openjdk:11-jre-slim

# 设置工作目录
WORKDIR /app

# 将构建好的jar包复制到镜像中
COPY target/*.jar /app/*.jar

# 运行jar包
ENTRYPOINT ["java","-jar","/app/*.jar"]

6.1.2 使用Docker构建镜像并运行

在命令行中使用以下命令构建Docker镜像并运行应用：

# 构建Docker镜像
docker build -t my-spring-boot-app .

# 运行Docker容器
docker run -d -p 8080:8080 my-spring-boot-app

6.2 使用Spring Boot Admin监控微服务

Spring Boot Admin是一个用于监控Spring Boot应用的Web应用，它可以监控应用的健康状态、日志、JVM等信息。使用Spring Boot Admin可以更好地了解应用的运行状态。

6.2.1 Spring Boot Admin Server

创建一个Spring Boot Admin Server应用：

package com.example.admin;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class AdminApplication {
    public static void main(String[] args) {
        SpringApplication.run(AdminApplication.class, args);
    }
}

6.2.2 Spring Boot Admin Client

在微服务应用中添加Spring Boot Admin Client依赖：

<!-- pom.xml -->
<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.3.2</version>
</dependency>

6.3 日志收集与分析（ELK Stack）

ELK Stack由Elasticsearch、Logstash和Kibana三个开源工具组成。Elasticsearch是一个分布式、支持多租户的全文搜索引擎，支持RESTful API；Logstash是一个可以用来搜集、过滤和转发日志的工具；Kibana是一个基于Web的图形化分析工具，用于可视化Elasticsearch中的数据。

6.3.1 配置Elasticsearch和Logstash

创建一个Elasticsearch服务：

# 启动Elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 docker.elastic.co/elasticsearch/elasticsearch:7.10.1

创建一个Logstash服务，并将其配置为从文件中读取日志并发送到Elasticsearch：

# 启动Logstash
docker run -d --name logstash -p 5044:5044 docker.elastic.co/logstash/logstash:7.10.1

将Logstash的配置文件放在容器内，例如：

# Logstash配置文件
input {
    file {
        path => "/path/to/logs/*.log"
        start_position => "beginning"
    }
}

output {
    elasticsearch {
        hosts => ["http://elasticsearch:9200"]
        index => "app-logs-%{+YYYY.MM.dd}"
    }
}

6.3.2 使用Kibana可视化日志

创建一个Kibana服务：

# 启动Kibana
docker run -d --name kibana -p 5601:5601 docker.elastic.co/kibana/kibana:7.10.1

访问http://localhost:5601，可以使用Kibana可视化Elasticsearch中的日志数据，进行日志分析和监控。

通过以上步骤，可以实现微服务的日志收集、存储和分析，从而更好地监控和管理微服务。