MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Spring Cloud 微服务架构的实践经验

2022-12-274.2k 阅读

一、Spring Cloud 微服务架构概述

Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 Spring Boot 的开发风格做到一键启动和部署。

在微服务架构中，一个大型应用被拆分成多个小型、自治的服务，每个服务专注于完成单一功能，并通过轻量级通信协议进行交互。Spring Cloud 为构建这样的微服务架构提供了丰富的工具和组件，使得开发人员可以更专注于业务逻辑的实现，而无需过多关注底层的分布式系统细节。

二、服务注册与发现

2.1 Eureka 简介

Eureka 是 Spring Cloud Netflix 中的一个子项目，它是一个基于 REST 的服务，用于定位服务，以实现云端中间层服务发现和故障转移。Eureka 包含两个组件：Eureka Server 和 Eureka Client。

Eureka Server 提供服务注册服务，各个微服务节点通过配置启动后，会在 Eureka Server 中进行注册，这样 Eureka Server 中的服务注册表中将会存储所有可用服务节点的信息，服务节点的信息可以在界面中直观看到。

Eureka Client 是一个 Java 客户端，用于简化与 Eureka Server 的交互。微服务应用作为 Eureka Client，在启动时会向 Eureka Server 注册自己的信息，并定期发送心跳来保持连接，以表明自己仍然可用。

2.2 Eureka 配置示例

首先，在父项目的 pom.xml 文件中引入 Eureka Server 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

然后，在 application.yml 文件中配置 Eureka Server：

server:
  port: 8761
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

接着，创建 Eureka Server 的启动类，添加 @EnableEurekaServer 注解：

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

对于微服务客户端，在 pom.xml 中引入 Eureka Client 依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

在 application.yml 中配置客户端：

server:
  port: 8081
spring:
  application:
    name: service - example
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

在客户端启动类中添加 @EnableEurekaClient 注解：

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

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

三、配置中心

3.1 Spring Cloud Config 简介

Spring Cloud Config 为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。

它分为两个部分：Config Server 和 Config Client。Config Server 是一个独立的微服务应用，用来连接配置仓库并为客户端提供获取配置信息、加密/解密信息等访问接口；Config Client 是微服务架构中的各个微服务应用，通过指定的配置中心来管理应用资源以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。

3.2 Spring Cloud Config 配置示例

首先，在 Config Server 的 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

在 application.yml 中配置 Config Server，假设配置文件存储在 Git 仓库中：

server:
  port: 8888
spring:
  application:
    name: config - server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/your - repository/config - repo
          search - paths: config - files
          username: your - username
          password: your - password

创建 Config Server 的启动类，添加 @EnableConfigServer 注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

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

对于 Config Client，在 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

在 bootstrap.yml 文件中配置客户端连接到 Config Server：

spring:
  application:
    name: service - example
  cloud:
    config:
      uri: http://localhost:8888
      fail - fast: true
      label: master

在 application.yml 文件中可以使用从 Config Server 获取的配置，例如：

server:
  port: ${server.port:8081}

四、服务调用与负载均衡

4.1 Feign 简介

Feign 是一个声明式的 Web 服务客户端，它使得编写 Web 服务客户端变得更加简单。使用 Feign，只需要创建一个接口并在接口上添加注解即可。Feign 支持多种编码器和解码器，Spring Cloud 对 Feign 进行了增强，使其支持 Spring MVC 的注解，并整合了 Ribbon 和 Eureka 来支持负载均衡。

4.2 Feign 配置示例

在需要进行服务调用的微服务项目的 pom.xml 中添加 Feign 依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

在启动类上添加 @EnableFeignClients 注解，开启 Feign 功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

创建一个 Feign 接口，用于调用其他微服务：

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "service - provider")
public interface ServiceProviderFeignClient {
    @GetMapping("/provider/api")
    String callProvider();
}

在控制器中使用 Feign 接口进行服务调用：

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

@RestController
public class ServiceConsumerController {
    @Autowired
    private ServiceProviderFeignClient serviceProviderFeignClient;

    @GetMapping("/consumer/api")
    public String callProvider() {
        return serviceProviderFeignClient.callProvider();
    }
}

4.3 Ribbon 负载均衡

Ribbon 是一个客户端负载均衡器，它可以在客户端配置多个服务实例的地址，并根据一定的负载均衡算法在这些实例之间进行请求分发。Spring Cloud 集成了 Ribbon，使得 Feign 等组件可以方便地使用负载均衡功能。

Ribbon 支持多种负载均衡算法，如轮询（Round Robin）、随机（Random）、根据响应时间加权（WeightedResponseTime）等。默认情况下，Ribbon 使用轮询算法。

可以通过在 application.yml 中配置来修改 Ribbon 的负载均衡策略，例如：

service - provider:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

上述配置将 service - provider 服务的负载均衡策略修改为随机策略。

五、断路器

5.1 Hystrix 简介

Hystrix 是一个用于处理分布式系统的延迟和容错的开源库，在微服务架构中，服务之间的调用可能会因为各种原因失败，如网络故障、服务过载等。Hystrix 通过添加熔断机制来防止级联故障，当某个服务调用出现问题时，Hystrix 可以快速地切断对该服务的调用，并提供一个 fallback 方法来返回一个兜底的响应，保证系统的稳定性和可用性。

5.2 Hystrix 配置示例

在需要使用 Hystrix 的微服务项目的 pom.xml 中添加依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

在启动类上添加 @EnableHystrix 注解，开启 Hystrix 功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

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

在需要进行熔断保护的方法上添加 @HystrixCommand 注解，并指定 fallback 方法：

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ServiceWithHystrixController {
    @Autowired
    private ServiceProviderFeignClient serviceProviderFeignClient;

    @GetMapping("/hystrix/api")
    @HystrixCommand(fallbackMethod = "fallbackCallProvider")
    public String callProvider() {
        return serviceProviderFeignClient.callProvider();
    }

    public String fallbackCallProvider() {
        return "Fallback response: Service is currently unavailable.";
    }
}

六、分布式链路追踪

6.1 Sleuth 与 Zipkin 简介

在微服务架构中，一个请求可能会经过多个微服务，当出现问题时，很难定位问题出在哪个服务节点。分布式链路追踪技术可以解决这个问题，Spring Cloud Sleuth 提供了分布式链路追踪的功能，它通过在每个请求中添加唯一的标识（Trace ID 和 Span ID）来记录请求在各个微服务之间的调用路径。

Zipkin 是一个分布式追踪系统，它可以收集和展示这些追踪数据。Spring Cloud Sleuth 可以与 Zipkin 集成，将追踪数据发送到 Zipkin 服务器，通过 Zipkin 的界面可以直观地查看请求的调用链路、每个服务节点的处理时间等信息。

6.2 Sleuth 与 Zipkin 配置示例

首先，在各个微服务项目的 pom.xml 中添加 Sleuth 和 Zipkin 相关依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

在 application.yml 中配置 Zipkin 服务器的地址：

spring:
  sleuth:
    sampler:
      probability: 1.0
  zipkin:
    base - url: http://localhost:9411

启动 Zipkin 服务器，可以通过 Docker 快速启动：

docker run -d -p 9411:9411 openzipkin/zipkin

启动各个微服务后，访问微服务的接口，Zipkin 服务器会收集到追踪数据，通过访问 http://localhost:9411 可以在 Zipkin 的界面中查看请求的调用链路。

七、微服务的部署与管理

7.1 Docker 容器化

Docker 是一种轻量级的容器化技术，可以将微服务及其依赖打包成一个独立的容器，使得微服务在不同的环境中能够保持一致的运行状态。

以一个 Spring Boot 微服务为例，首先在项目根目录下创建一个 Dockerfile：

FROM openjdk:8 - jdk - alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app.jar"]

然后在项目的 pom.xml 中添加 Docker 插件：

<build>
    <plugins>
        <plugin>
            <groupId>com.spotify</groupId>
            <artifactId>docker - maven - plugin</artifactId>
            <version>1.2.0</version>
            <configuration>
                <imageName>your - image - name:${project.version}</imageName>
                <dockerDirectory>${project.basedir}</dockerDirectory>
                <resources>
                    <resource>
                        <targetPath>/</targetPath>
                        <directory>${project.build.directory}</directory>
                        <include>${project.build.finalName}.jar</include>
                    </resource>
                </resources>
            </configuration>
        </plugin>
    </plugins>
</build>

通过 mvn clean package docker:build 命令可以构建 Docker 镜像。

7.2 Kubernetes 集群管理

Kubernetes 是一个开源的容器编排引擎，可以自动化容器的部署、扩展和管理。在 Kubernetes 集群中，可以创建 Deployment 来管理微服务的多个副本，通过 Service 来暴露微服务，实现负载均衡和服务发现。

例如，创建一个 deployment.yml 文件：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: service - example - deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: service - example
  template:
    metadata:
      labels:
        app: service - example
    spec:
      containers:
      - name: service - example
        image: your - image - name:1.0.0
        ports:
        - containerPort: 8081

创建一个 service.yml 文件：

apiVersion: v1
kind: Service
metadata:
  name: service - example - service
spec:
  selector:
    app: service - example
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8081
  type: ClusterIP

通过 kubectl apply -f deployment.yml 和 kubectl apply -f service.yml 命令可以在 Kubernetes 集群中部署和暴露微服务。

八、实践中的常见问题与解决方案

8.1 服务间数据一致性问题

在微服务架构中，不同的微服务可能会操作共享数据，这就容易引发数据一致性问题。例如，一个订单微服务和库存微服务，当创建订单时，订单微服务需要减少库存微服务中的库存数量。如果在这个过程中出现网络故障等问题，可能会导致订单创建成功但库存未减少，或者库存减少了但订单创建失败。

解决方案可以采用分布式事务，Spring Cloud 提供了一些解决方案，如使用 Seata 来实现分布式事务。Seata 是一个开源的分布式事务解决方案，它提供了 AT、TCC、SAGA 和 XA 等事务模式。

以 AT 模式为例，首先在各个微服务项目的 pom.xml 中添加 Seata 依赖：

<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata - spring - boot - starter</artifactId>
    <version>1.4.2</version>
</dependency>

在 application.yml 中配置 Seata：

seata:
  application - id: service - example
  tx - service - group: my_test_tx_group
  enable - auto - data - source - proxy: true
  registry:
    type: nacos
    nacos:
      application: seata - server
      server - addr: localhost:8848
      group: SEATA_GROUP
      namespace: ""
      username: ""
      password: ""
  config:
    type: nacos
    nacos:
      server - addr: localhost:8848
      group: SEATA_GROUP
      namespace: ""
      username: ""
      password: ""

在需要进行分布式事务的方法上添加 @GlobalTransactional 注解：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    @GlobalTransactional
    public void createOrder() {
        // 调用库存微服务减少库存
        // 创建订单逻辑
    }
}

8.2 服务版本控制问题

随着微服务的不断迭代和升级，服务版本控制变得非常重要。不同版本的微服务可能具有不同的接口和功能，如果不进行有效的版本控制，可能会导致服务之间的兼容性问题。

一种常见的解决方案是在服务接口中添加版本号，例如在 URL 中体现版本号，如 /v1/api 和 /v2/api。同时，在服务注册中心中也可以记录服务的版本信息，消费者在调用服务时可以根据自己的需求选择合适版本的服务。

另外，使用语义化版本号（SemVer）也是一个很好的实践，例如 1.0.0，其中主版本号（1）表示有不兼容的 API 更改，次版本号（0）表示有向下兼容的功能性新增，修订号（0）表示有向下兼容的问题修正。

8.3 性能优化问题

微服务架构中，由于服务之间的调用增加，可能会带来性能问题。例如，网络延迟、服务内部的性能瓶颈等。

对于网络延迟问题，可以通过优化网络拓扑、使用高性能的网络协议等方式来解决。在服务内部，可以使用性能分析工具（如 Java 中的 VisualVM、YourKit 等）来找出性能瓶颈，进行针对性的优化，如优化数据库查询、减少不必要的计算等。

此外，合理设置缓存也是提高性能的有效手段。例如，对于一些不经常变化的数据，可以在微服务内部设置本地缓存，或者使用分布式缓存（如 Redis）来减少对后端数据源的访问次数。

九、总结 Spring Cloud 微服务架构的优势与挑战

Spring Cloud 微服务架构为开发分布式系统提供了强大的工具和框架，具有以下优势：

  1. 易于开发和部署：利用 Spring Boot 的特性，使得微服务的开发和部署变得简单快捷，开发人员可以更专注于业务逻辑。
  2. 服务治理能力强：通过服务注册与发现、配置中心、负载均衡、断路器等组件，实现了对微服务的有效治理，提高了系统的可用性和稳定性。
  3. 可扩展性高：微服务的架构使得系统可以方便地进行水平扩展，根据业务需求增加或减少服务实例。

然而，Spring Cloud 微服务架构也面临一些挑战：

  1. 分布式系统复杂性：引入了分布式系统的复杂性，如数据一致性、网络问题等，需要开发人员具备更深入的分布式系统知识来解决这些问题。
  2. 运维成本增加：多个微服务的部署和管理需要更专业的运维团队和工具，增加了运维成本。
  3. 服务间依赖管理：微服务之间的依赖关系变得复杂，需要有效的版本控制和依赖管理策略来确保服务之间的兼容性。

在实践中，需要充分了解 Spring Cloud 微服务架构的特性，合理运用各种组件，同时积极应对挑战，才能构建出高效、稳定的分布式系统。