浅入 Spring Cloud 架构设计-阿里云开发者社区

1、微服务简介

1.1 什么是微服务

所谓微服务，就是把一个比较大的单个应用程序或服务拆分为若干个独立的、粒度很小的服务或组件。

1.2 为什么使用微服务

微服务的拆解业务，这一策略，可扩展单个组件，而不需要整个的应用程序堆栈做修改，从而满足服务等级协议。微服务带来的好处是，它们更快且更容易更新。当开发者对一个传统的单体应用程序进行变更时，他们必须做详细、完整的 QA 测试，以确保变更不会影响其他特性或功能。但有了微服务，开发者可以更新应用程序的单个组件，而不会影响其他的部分。测试微服务应用程序仍然是必需的，但使得其更容易被识别和隔离，从而加快开发速度并支持 DevOps 和持续应用程序开发。

1.3 微服务的架构组成

这几年的快速发展，微服务已经变得越来越流行。其中，Spring Cloud 一直在更新，并被大部分公司所使用。代表性的有 Alibaba，2018 年 11 月左右，Spring Cloud 联合创始人 Spencer Gibb 在 Spring 官网的博客页面宣布：阿里巴巴开源 Spring Cloud Alibaba，并发布了首个预览版本。随后，Spring Cloud 官方 Twitter 也发布了此消息。Spring Cloud 的版本也很多:

Spring Cloud	Spring Cloud Alibaba	Spring Boot
Spring Cloud Hoxton	2.2.0.RELEASE	2.2.X.RELEASE
Spring Cloud Greenwich	2.1.1.RELEASE	2.1.X.RELEASE
Spring Cloud Finchley	2.0.1.RELEASE	2.0.X.RELEASE
Spring Cloud Edgware	1.5.1.RELEASE	1.5.X.RELEASE

以 Spring Boot1.x 为例，主要包括 Eureka、Zuul、Config、Ribbon、Hystrix 等。而在 Spring Boot2.x 中，网关采用了自己的 Gateway。当然在 Alibaba 版本中，其组件更是丰富：使用 Alibaba 的 Nacos 作为注册中心和配置中心。使用自带组件 Sentinel 作为限流、熔断神器。

2、微服务之网关

2.1 常见的几种网关

目前，在 Spring Boot1.x 中，用到的比较多的网关就是 Zuul。Zuul 是 Netflix 公司开源的一个网关服务，而 Spring Boot2.x 中，采用了自家推出的 Spring Cloud Gateway。

2.2 API 网关的作用

API 网关的主要作用是反向路由、安全认证、负载均衡、限流熔断、日志监控。在 Zuul 中，我们可以通过注入 Bean 的方式来配置路由，也可以在直接通过配置文件来配置:

zuul.routes.api-d.sensitiveHeaders="*"
zuul.routes.api-d.path=/business/api/**
zuul.routes.api-d.serviceId=business-web

我们可以通过网关来做一些安全的认证：如统一鉴权。在 Zuul 中：

Zuul 的工作原理

过滤器机制

zuul 的核心是一系列的 filters, 其作用可以类比 Servlet 框架的 Filter，或者 AOP。zuul 把 Request route 到用户处理逻辑的过程中，这些 filter 参与一些过滤处理，比如 Authentication，Load Shedding 等。几种标准的过滤器类型：

(1) PRE：这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。

(2) ROUTING：这种过滤器用于构建发送给微服务的请求，并使用 Apache HttpClient 或 Netfilx Ribbon 请求微服务。

(3) POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的 HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。

(4) ERROR：在其他阶段发生错误时执行该过滤器。

过滤器的生命周期

filterOrder：通过 int 值来定义过滤器的执行顺序，越小优先级越高。

shouldFilter：返回一个 boolean 类型来判断该过滤器是否要执行，所以通过此函数可实现过滤器的开关。在上例中，我们直接返回 true，所以该过滤器总是生效。

run：过滤器的具体逻辑。需要注意，这里我们通过 ctx.setSendZuulResponse(false) 令 zuul 过滤该请求，不对其进行路由，然后通过 ctx.setResponseStatusCode(401) 设置了其返回的错误码。

代码示例：

@Component
public class AccessFilter extends ZuulFilter {
    private static Logger logger = LoggerFactory.getLogger(AccessFilter.class);

    @Autowired
    RedisCacheConfiguration redisCacheConfiguration;

    @Autowired
    EnvironmentConfig env;

    private static final String[] PASS_PATH_ARRAY = { "/login", "openProject" };

    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        return 0;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        HttpServletResponse response = ctx.getResponse();
        response.setCharacterEncoding("UTF-8");
        response.setHeader("content-type", "text/html;charset=UTF-8");

        logger.info("{} request to {}", request.getMethod(), request.getRequestURL());
        for (String path : PASS_PATH_ARRAY) {
            if (StringUtils.contains(request.getRequestURL().toString(), path)) {
                logger.debug("request path: {} is pass", path);
                return null;
            }
        }

        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            logger.warn("access token is empty");
            ctx.setSendZuulResponse(false);
            ctx.setResponseStatusCode(404);
            ctx.setResponseBody(JSONObject.toJSONString(
                    Response.error(200, -3, "header param error", null)));
            return ctx;
        }

        Jedis jedis = null;
        try {
            JedisPool jedisPool = redisCacheConfiguration.getJedisPool();
            jedis = jedisPool.getResource();
            logger.debug("zuul gateway service get redisResource success");
            String key = env.getPrefix() + token;
            String value = jedis.get(key);
            if (StringUtils.isBlank(value)) {
                ctx.setSendZuulResponse(false);
                ctx.setResponseStatusCode(401);
                ctx.setResponseBody(JSONObject.toJSONString(Response.error(200, -1, "login timeout",null)));
                return ctx;
            } else {
                logger.debug("access token ok");
                return null;
            }
        } catch (Exception e) {
            logger.error("get redisResource failed");
            logger.error(e.getMessage(), e);
            ctx.setSendZuulResponse(false);
            ctx.setResponseStatusCode(500);
            ctx.setResponseBody(JSONObject.toJSONString(
                    Response.error(200, -8, "redis connect failed", null)));
            return ctx;
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }
}

3、微服务之服务注册与发现

3.1 常见的几种注册中心

目前常见的几种注册中心有：Eureka、Consul、Nacos，但其实 Kubernetes 也可以实现服务的注册与发现功能，且听下面讲解。

Eureka 的高可用

在注册中心部署时，有可能出现节点问题，我们先看看 Eureka 集群如何实现高可用，首先配置基础的 Eureka 配置：

spring.application.name=eureka-server
server.port=1111

spring.profiles.active=dev

eureka.instance.hostname=localhost

eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

logging.path=/data/${spring.application.name}/logs

eureka.server.enable-self-preservation=false
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

eureka.server.eviction-interval-timer-in-ms=5000
eureka.server.responseCacheUpdateInvervalMs=60000

eureka.instance.lease-expiration-duration-in-seconds=10

eureka.instance.lease-renewal-interval-in-seconds=3

eureka.server.responseCacheAutoExpirationInSeconds=180

server.undertow.accesslog.enabled=false
server.undertow.accesslog.pattern=combined

配置好后，新建一个 application-peer1.properties 文件：

spring.application.name=eureka-server
server.port=1111
eureka.instance.hostname=peer1
eureka.client.serviceUrl.defaultZone=http://peer2:1112/eureka/

application-peer2.properties 文件：

spring.application.name=eureka-server
server.port=1112
eureka.instance.hostname=peer2
eureka.client.serviceUrl.defaultZone=http://peer1:1111/eureka/

这样通过域名 peer1、peer2 的形式来实现高可用，那么如何配置域名呢？有几种方式：

通过 hosts 来配置域名，vi /etc/hosts:

10.12.3.2 peer1
10.12.3.5 peer2

通过 kubernetes 部署服务时来配置域名：

hostAliases:
- ip: "10.12.3.2"
  hostnames:
  - "peer1"
- ip: "10.12.3.5"
  hostnames:
  - "peer2"

Nacos 实现服务注册、发现

Nacos 是 Alibaba 推出来的，目前最新版本是 v1.2.1。其功能可以实现服务的注册、发现，也可以作为配置管理来提供配置服务。可以手动去官网下载安装，Nacos 地址：https://github.com/alibaba/nacos/releases。

执行，Linux/Unix/Mac：

sh startup.sh -m standalone

Windows：

cmd startup.cmd -m standalone

当我们引入 Nacos 相关配置时，即可使用它：

<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
 </dependency>

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

注意：下面这个配置文件需要是 bootstrap，否则可能失败，至于为什么，大家可以自己试试。

spring:
  application:
    name: oauth-cas
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        refreshable-dataids: actuator.properties,log.properties

配置完成后，完成 main：

package com.damon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableAutoConfiguration
@ComponentScan(basePackages = {"com.damon"})
@EnableDiscoveryClient
public class CasApp {
  public static void main(String[] args) {
    SpringApplication.run(CasApp.class, args);
  }
}

完成以上，我们运行启动类，我们打开 Nacos 登录后，打开服务列表，即可看到：

在这里插入图片描述

Kubernetes 服务注册与发现

接下来，请允许我为大家引入 Kubernetes 的服务注册与发现功能，spring-cloud-kubernetes 的 DiscoveryClient 服务将 Kubernetes 中的 "Service" 资源与 Spring Cloud 中的服务对应起来了，有了这个 DiscoveryClient，我们在 Kubernetes 环境下就不需要 Eureka 等来做注册发现了，而是直接使用 Kubernetes 的服务机制。

在 pom.xml 中，有对 spring-cloud-kubernetes 框架的依赖配置：

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-kubernetes-core</artifactId>
</dependency>

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-kubernetes-discovery</artifactId>
</dependency>

为何 spring-cloud-kubernetes 可以完成服务注册发现呢？首先，创建一个 Spring Boot 项目的启动类，且引入服务发现注解 @EnableDiscoveryClient，同时需要开启服务发现：

spring:
  application:
    name: edge-admin
  cloud:
    kubernetes:
      discovery:
        all-namespaces: true

开启后，我们打开spring-cloud-kubernetes-discovery的源码，地址是：https://github.com/spring-cloud/spring-cloud-kubernetes/tree/master/spring-cloud-kubernetes-discovery，看到内容：

在这里插入图片描述

为什么要看这个文件呢？因为 spring 容器启动时，会寻找 classpath 下所有 spring.factories 文件(包括 jar 文件中的)，spring.factories 中配置的所有类都会实例化，我们在开发 springboot 时常用到的***-starter.jar 就用到了这个技术，效果是一旦依赖了某个 starter.jar 很多功能就在 spring 初始化时候自动执行。

spring.factories 文件中有两个类：KubernetesDiscoveryClientAutoConfiguration 和 KubernetesDiscoveryClientConfigClientBootstrapConfiguration 都会被实例化。先看 KubernetesDiscoveryClientConfigClientBootstrapConfiguration，KubernetesAutoConfiguration 和 KubernetesDiscoveryClientAutoConfiguration 这两个类会被实例化：

 * Copyright 2013-2019 the original author or authors.

package org.springframework.cloud.kubernetes.discovery;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cloud.kubernetes.KubernetesAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ConditionalOnProperty("spring.cloud.config.discovery.enabled")
@Import({ KubernetesAutoConfiguration.class,
        KubernetesDiscoveryClientAutoConfiguration.class })
public class KubernetesDiscoveryClientConfigClientBootstrapConfiguration {

}

再看 KubernetesAutoConfiguration 的源码，会实例化一个重要的类 DefaultKubernetesClient，如下：

@Bean
@ConditionalOnMissingBean
public KubernetesClient kubernetesClient(Config config) {
    return new DefaultKubernetesClient(config);
}

最后我们再看 KubernetesDiscoveryClientAutoConfiguration 源码，注意 kubernetesDiscoveryClient 方法，这里面是接口实现的重点，还要重点关注的地方是 KubernetesClient 参数的值，是上面提到的 DefaultKubernetesClient 对象：

@Bean
@ConditionalOnMissingBean
@ConditionalOnProperty(name = "spring.cloud.kubernetes.discovery.enabled", matchIfMissing = true)
public KubernetesDiscoveryClient kubernetesDiscoveryClient(KubernetesClient client,
            KubernetesDiscoveryProperties properties,
            KubernetesClientServicesFunction kubernetesClientServicesFunction,
            DefaultIsServicePortSecureResolver isServicePortSecureResolver) {
  return new KubernetesDiscoveryClient(client, properties, kubernetesClientServicesFunction, isServicePortSecureResolver);
}

接下来，我们看 spring-cloud-kubernetes 中的 KubernetesDiscoveryClient.java，看方法：

public List<String> getServices(Predicate<Service> filter) {
        return this.kubernetesClientServicesFunction.apply(this.client).list().getItems()
                .stream().filter(filter).map(s -> s.getMetadata().getName())
                .collect(Collectors.toList());
}

在 apply(this.client).list()，可以看到数据源其实就是 this.client，并且 KubernetesClientServicesFunction 实例化时：

@Bean
public KubernetesClientServicesFunction servicesFunction(
            KubernetesDiscoveryProperties properties) {
  if (properties.getServiceLabels().isEmpty()) {
    return KubernetesClient::services;
  }

  return (client) -> client.services().withLabels(properties.getServiceLabels());
}

调用其 services 方法的返回结果，KubernetesDiscoveryClient.getServices 方法中的 this.client 是什么呢？在前面的分析时已经提到了，就是 DefaultKubernetesClient 类的实例，所以，此时要去去看 DefaultKubernetesClient.services 方法，发现 client 是 ServiceOperationsImpl：

@Override
  public MixedOperation<Service, ServiceList, DoneableService, ServiceResource<Service, DoneableService>> services() {
    return new ServiceOperationsImpl(httpClient, getConfiguration(), getNamespace());
  }

接着我们在实例 ServiceOperationsImpl 中看其 list 函数：

public L list() throws KubernetesClientException {
    try {
      HttpUrl.Builder requestUrlBuilder = HttpUrl.get(getNamespacedUrl()).newBuilder();

      String labelQueryParam = getLabelQueryParam();
      if (Utils.isNotNullOrEmpty(labelQueryParam)) {
        requestUrlBuilder.addQueryParameter("labelSelector", labelQueryParam);
      }

      String fieldQueryString = getFieldQueryParam();
      if (Utils.isNotNullOrEmpty(fieldQueryString)) {
        requestUrlBuilder.addQueryParameter("fieldSelector", fieldQueryString);
      }

      Request.Builder requestBuilder = new Request.Builder().get().url(requestUrlBuilder.build());
      L answer = handleResponse(requestBuilder, listType);
      updateApiVersion(answer);
      return answer;
    } catch (InterruptedException | ExecutionException | IOException e) {
      throw KubernetesClientException.launderThrowable(forOperationType("list"), e);
    }
  }

接着展开上面代码的 handleResponse 函数，可见里面是一次 http 请求，至于请求的地址，可以展开 getNamespacedUrl() 方法，里面调用的 getRootUrl 方法如下：

public URL getRootUrl() {
    try {
      if (apiGroup != null) {
        return new URL(URLUtils.join(config.getMasterUrl().toString(), "apis", apiGroup, apiVersion));
      }
      return new URL(URLUtils.join(config.getMasterUrl().toString(), "api", apiVersion));
    } catch (MalformedURLException e) {
      throw KubernetesClientException.launderThrowable(e);
    }
  }

我们看到逻辑中，貌似了解到其结果是这样的格式：

xxx/api/version 或 xxx/apis/xxx/version

看到这样的结果，感觉比较像访问 kubernetes 的 API Server 时用的 URL 标准格式，有关 API Server 服务的详情请参考官方文档，地址是: https://kubernetes.io/docs/reference/using-api/api-concepts/。

弄清楚以上，我们发现了其实最终是向 kubernetes 的 API Server 发起 http 请求，获取 Service 资源的数据列表。因此，我们在最后还得在 k8s 底层新建 Service 资源来让其获取：

apiVersion: v1
kind: Service
metadata:
  name: admin-web-service
  namespace: default
spec:
  ports:
  - name: admin-web01
    port: 2001
    targetPort: admin-web01
  selector:
    app: admin-web

当然，在部署时，不管是以 Deployment 形式，还是以 DaemonSet 来部署，其最后还是 pod，如果要实现单个服务的多节点部署，可以用：

kubectl scale --replicas=2 deployment admin-web-deployment

总结：

spring-cloud-kubernetes 这个组件的服务发现目的就是获取 Kubernetes 中一个或者多个 Namespace 下的所有服务列表，且在过滤列表时候设置过滤的端口号，这样获取到服务列表后就能让依赖它们的 Spring Boot 或其它框架的应用完成服务发现工作，让服务能够通过 http://serviceName 这种方式进行访问。

4、微服务之配置管理

4.1 常见的配置中心

目前常见的几种配置中心有：Spring Cloud Config、Apollo、Nacos，但其实 Kubernetes 组件 configMap 就可以实现服务的配置管理。并且，在 Spring Boot2.x 中，就已经引入使用了。

Nacos 配置中心

在上面注册中心中，我们讲到 Nacos，作为注册中心，其实也可以作为配置来管理服务的环境变量。

同样，引入其以依赖：

<dependency>
     <groupId>org.springframework.cloud</groupId>
     <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
 </dependency>

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

同样，注意：下面这个配置文件需要是 bootstrap，否则可能失败。

spring:
  application:
    name: oauth-cas
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        refreshable-dataids: actuator.properties,log.properties

启动类在上面的注册中心已经讲过了，现在看其配置类:

package com.damon.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;


@Component
@RefreshScope
public class EnvConfig {

    @Value("${jdbc.driverClassName:}")
    private String jdbc_driverClassName;

    @Value("${jdbc.url:}")
    private String jdbc_url;

    @Value("${jdbc.username:}")
    private String jdbc_username;

    @Value("${jdbc.password:}")
    private String jdbc_password;
...

}

我们通过注解 @Component、@RefreshScope，来实现其配置可被获取。注意 @Value("${jdbc.username:}")最后需要冒号的，否则启动后会报错的。

接下来可以配置属性值来，点击配置管理，查看配置：

在这里插入图片描述

如果首次打开没有配置，可以新建配置：

在这里插入图片描述

编辑配置：

在这里插入图片描述

新建完之后，可以编辑，也可以删除，这里就不操作了。

ConfigMap 作为配置管理

spring-cloud-kubernetes 在上面提供了服务发现的功能，其实它还很强大，也提供了服务的配置管理：

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-actuator-autoconfigure</artifactId>
  </dependency>

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

在初始化时，引入注解来自动注入：

package com.damon;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import com.damon.config.EnvConfig;

@Configuration
@EnableAutoConfiguration
@ComponentScan(basePackages = {"com.damon"})
@EnableConfigurationProperties(EnvConfig.class)
@EnableDiscoveryClient
public class AdminApp {

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

}

其中，EnvConfig 类来配置环境变量配置：

package com.damon.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConfigurationProperties(prefix = "damon")
public class EnvConfig {

    private String message = "This is a dummy message";

    

    public String getMessage() {
        return this.message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

}

这样，在部署时，我们新建 ConfigMap 类型的资源，同时，会配置其属性值：

kind: ConfigMap
apiVersion: v1
metadata:
  name: admin-web
data:
  application.yaml: |-
    damon:
      message: Say Hello to the World
    ---
    spring:
      profiles: dev
    damon:
      message: Say Hello to the Developers
    ---
    spring:
      profiles: test
    damon:
      message: Say Hello to the Test
    ---
    spring:
      profiles: prod
    damon:
      message: Say Hello to the Prod

并且结合配置，来实现动态更新：

spring:
  application:
    name: admin-web
  cloud:
    kubernetes:
      discovery:
        all-namespaces: true
      reload:
        enabled: true
        mode: polling
        period: 500
      config:
        sources:
        - name: ${spring.application.name}
          namespace: default

这里是实现自动 500ms 拉取配置，也可以通过事件触发的形式来动态获取最新配置：

spring:
  application:
    name: admin-web
  cloud:
    kubernetes:
      config:
        sources:
         - name: ${spring.application.name}
           namespace: default
      discovery:
        all-namespaces: true
      reload:
        enabled: true
        mode: event
        period: 500

5、微服务模块划分

5.1 如何划分微服务

微服务架构设计中，服务拆分的问题很突出，第一种，按照纵向的业务拆分，第二种，横向的功能拆分。

以电商业务为例，首先按照业务领域的纵向拆分，分为用户微服务、商品微服务、交易微服务、订单微服务等等。

思考一下：在纵向拆分仅仅按照业务领域进行拆分是否满足所有的业务场景？结果肯定是否定的。例如用户服务分为用户注册（写）和登录（读）等。写请求的重要性总是大于读请求的，在高并发下，读写比例 10:1，甚至更高的情况下，从而导致了大量的读请求往往会直接影响写请求。为了避免大量的读对写的请求干扰，需要对服务进行读写分离，即用户注册为一个微服务，登录为另一个微服务。此时按照 API 的细粒度继续进行纵向的业务拆分。

在横向上，按照所请求的功能进行拆分，即对一个请求的生命周期继续进行拆分。请求从用户端发出，首先接受到请求的是网关服务（这里不考虑 nginx 代理网关分发过程），网关服务对请求进行鉴权、参数合法性检查、路由转发等。接下来业务逻辑服务对请求进行业务逻辑的编排处理。对业务数据进行存储和查询就需要数据访问服务，数据访问服务提供了基本的 CRUD 原子操作，并负责海量数据的分库分表，以及屏蔽底层存储的差异性等功能。最后是数据持久化和缓存服务，比如可以采用 MQ、Kafka、Redis Cluster 等。

微服务架构通过业务的纵向拆分以及功能的横向拆分，服务演化成更小的颗粒度，各服务之间相互解耦，每个服务都可以快速迭代和持续交付（CI/CD），从而在公司层面能够达到降本增效的终极目标。但是服务粒度越细，服务之间的交互就会越来越多，更多的交互会使得服务之间的治理更复杂。服务之间的治理包括服务间的发现、通信、路由、负载均衡、重试机制、限流降级、熔断、链路跟踪等。

5.2 微服务划分的粒度

微服务划分粒度，其最核心的六个字可能就是：“高内聚、低耦合”。高内聚：就是说每个服务处于同一个网络或网域下，而且相对于外部，整个的是一个封闭的、安全的盒子，宛如一朵玫瑰花。盒子对外的接口是不变的，盒子内部各模块之间的接口也是不变的，但是各模块内部的内容可以更改。模块只对外暴露最小限度的接口，避免强依赖关系。增删一个模块，应该只会影响有依赖关系的相关模块，无关的不应该受影响。

那么低耦合，这就涉及到我们业务系统的设计了。所谓低耦合：就是要每个业务模块之间的关系降低，减少冗余、重复、交叉的复杂度，模块功能划分也尽可能单一。这样，才能达到低耦合的目的。

浅入 Spring Cloud 架构设计

1、微服务简介

1.1 什么是微服务

1.2 为什么使用微服务

1.3 微服务的架构组成

2、微服务之网关

2.1 常见的几种网关

2.2 API 网关的作用

3、微服务之服务注册与发现

3.1 常见的几种注册中心

Eureka 的高可用

Nacos 实现服务注册、发现

注意：下面这个配置文件需要是 bootstrap，否则可能失败，至于为什么，大家可以自己试试。

Kubernetes 服务注册与发现

总结：

4、微服务之配置管理

4.1 常见的配置中心

Nacos 配置中心

ConfigMap 作为配置管理

5、微服务模块划分

5.1 如何划分微服务

5.2 微服务划分的粒度

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

浅入 Spring Cloud 架构设计

1、 微服务简介

1.1 什么是微服务

1.2 为什么使用微服务

1.3 微服务的架构组成

2、 微服务之网关

2.1 常见的几种网关

2.2 API 网关的作用

3、 微服务之服务注册与发现

3.1 常见的几种注册中心

Eureka 的高可用

Nacos 实现服务注册、发现

注意：下面这个配置文件需要是 bootstrap，否则可能失败，至于为什么，大家可以自己试试。

Kubernetes 服务注册与发现

总结：

4、 微服务之配置管理

4.1 常见的配置中心

Nacos 配置中心

ConfigMap 作为配置管理

5、 微服务模块划分

5.1 如何划分微服务

5.2 微服务划分的粒度

热门文章

最新文章

相关课程

相关电子书

相关实验场景

1、微服务简介

2、微服务之网关

3、微服务之服务注册与发现

4、微服务之配置管理

5、微服务模块划分