开发者社区> 码疯窝在香嗝喱辣> 正文

微服务 Springcloud 架构设计

简介: 微服务现如今已成为炙手可热的新技术,似乎不谈点微服务技术,都显得不是那么主流了。微服务当中,Spring 家族尤为凸显的便是 Spring Boot,乃至 Spring Cloud。本篇主要介绍微服务 Springcloud 组件的多重设计。
+关注继续查看

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 CloudSpring Cloud AlibabaSpring Boot
Spring Cloud Hoxton2.2.0.RELEASE2.2.X.RELEASE
Spring Cloud Greenwich2.1.1.RELEASE2.1.X.RELEASE
Spring Cloud Finchley2.0.1.RELEASE2.0.X.RELEASE
Spring Cloud Edgware1.5.1.RELEASE1.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的简易SSO设计
通常稍微规模大一些的企业,内部已经有很多的应用系统,多个系统整合首先要解决的便是“统一登录(SSO)”问题,之前写过一篇 利用Membership实现SSO(单点登录)?,java环境下已经有一些开源的成熟sso项目(比如CAS),但如果觉得CAS太麻烦,想自己再造轮子重复发明一个,可以参考下面的思...
1082 0
springcloud 服务提供方 compute-service
? ? ?------------------------------------------------------------------------------------------------------------? springcloud (零) springboo...
713 0
SpringCloud微服务实战(六)-统一配置中心
1 统一配置中心概述 为什么需要统一配置中心 2 Config Server 直接运行报错,因为会从 git拉取配置文件 在 Git 建立新仓库存放配置文件 ...
1070 0
开发者学堂课程干货总结——Spring Cloud微服务架构设计与开发实战(六)
Spring Cloud微服务架构设计与开发实战课时1.6—微服务架构常用RPC协议 。Java Spring Cloud是全球范围内最成熟、最完善、最流行的微服务架构方案体系。被众多的互联网大公司采用,包括阿里巴巴、腾讯、支付宝、网易、IBM、谷歌、京东、百度、滴滴等。电子书+视频为同学带来最佳学习效果,文字、课程链接、图谱地址统统为大家放送了哦!
130 0
开发者学堂课程干货总结——Spring Cloud微服务架构设计与开发实战(二)
Spring Cloud微服务架构设计与开发实战课时1.2—什么是微服务架构Microservice 。Java Spring Cloud是全球范围内最成熟、最完善、最流行的微服务架构方案体系。被众多的互联网大公司采用,包括阿里巴巴、腾讯、支付宝、网易、IBM、谷歌、京东、百度、滴滴等。电子书+视频为同学带来最佳学习效果,文字、课程链接、图谱地址统统为大家放送了哦!
136 0
Spring注解缓存设计原理及实战
注解驱动的Spring Cache能够极大的减少我们编写常见缓存的代码量,通过少量的注释标签和配置文件,即可达到使代码具备缓存的能力,且具备很好的灵活性和扩展性。但是我们也应该看到,Spring Cache由于基于Spring AOP技术,尤其是动态的proxy技术,导致其不能很好的支持方法的内部调用或者非public方法的缓存设置,当然这些都是可以解决的问题。
36 0
SpringCloud+Vue微服务教程与实战(1)--全新的开始
本文目录 1. 背景 2. 微服务架构的优缺点 3. 实现技术 4. 开发环境 5. 小结
35 0
SpringCloud之服务注册与发现Eureka+客户端Feign
SpringCloud之服务注册与发现Eureka+客户端Feign前言? SpringCloud 是微服务中的翘楚,最佳的落地方案。 ??Eureka 作为注册中心,是 SpringCloud 体系中最重要最核心的组件之一。
2731 0
+关注
码疯窝在香嗝喱辣
一起起飞吧!
63
文章
35
问答
文章排行榜
最热
最新
相关电子书
更多
OceanBase 入门到实战教程
立即下载
阿里云图数据库GDB,加速开启“图智”未来.ppt
立即下载
实时数仓Hologres技术实战一本通2.0版(下)
立即下载
http://www.vxiaotou.com