微服务01 - 技术栈

1.认识微服务

随着互联网行业的发展，对服务的要求也越来越高，服务架构也从单体架构逐渐演变为现在流行的分布式架构。这些架构之间有怎样的差别：

1.1单体架构：将业务的所有功能集中在一个项目中开发，打成一个包部署。比如一个电商项目各个模块的耦合：

单体架构的优缺点：优点：架构简单部署成本低缺点：耦合度高（维护困难、升级困难）

1.2.分布式架构：根据业务功能对系统做拆分，每个业务功能模块作为独立项目开发，称为一个服务。

复制代码

分布式架构的优缺点：
优点：降低服务耦合有利于服务升级和拓展
缺点：服务调用关系错综复杂

1.3微服务

复制代码

分布式架构虽然降低了服务耦合，但是服务拆分时也有很多问题需要思考：
服务拆分的粒度如何界定？
服务之间如何调用？
服务的调用关系如何管理？
人们需要制定一套行之有效的标准来约束分布式架构。

微服务的架构特征：
单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责
自治：团队独立、技术独立、数据独立，独立部署和交付
面向服务：服务提供统一标准的接口，与语言和技术无关
隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题

复制代码

微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。

因此，可以认为微服务是一种经过良好架构设计的分布式架构方案，但方案该怎么落地？选用什么样的技术栈？全球的互联网公司都在积极尝试自己的微服务落地方案。其中在Java领域最引人注目的就是SpringCloud提供的方案了。

1.4springCloud

SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。 SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。其中常见的组件包括：

我们之后会学到服务注册发现的Nacos和Eureka，远程服务调用的OpenFeign，统一配置管理的Nacos，统一网关路由的Fateway。

2.服务拆分和远程调用

复制代码

微服务拆分时的几个原则：
不同微服务，不要重复开发相同业务
微服务数据独立，不要访问其它微服务的数据库
微服务可以将自己的业务暴露为接口，供其它微服务调用

2.1远程调用案例

复制代码

以课前资料中的微服务cloud-demo为例：

cloud-demo：父工程，管理依赖
order-service：订单微服务，负责订单相关业务
user-service：用户微服务，负责用户相关业务
cloud-order表中持有cloud-user表中的id字段

复制代码

在order-service服务中，有一个根据id查询订单的接口，在user-service中有一个根据id查询用户的接口：但是现在查询订单的时候要把订单人也查出来，单体架构就是通过查询到的id再去查询user对象然后组装返回，但是这里是分布式项目，订单服务不能直接查询用户服务的数据库。

复制代码

因此，我们需要在order-service中 向user-service发起一个http的请求，调http://localhost:8081
/user/{userId}这个接口。大概的步骤是这样的：
注册一个RestTemplate的实例到Spring容器（这个就是用来发送请求的方法）
修改order-service服务中的OrderService类中的queryOrderById方法，根据Order对象中的userId查询User
将查询的User填充到Order对象，一起返回。

首先配置bean对象：为了方便我直接配置在启动类里面

java 复制代码

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

然后用这个对象发送请求即可

这就完成了基本的调用微服务

2.2提供者与消费者

在服务调用关系中，会有两个不同的角色：服务提供者：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）；服务消费者：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？ -对于A调用B的业务而言：A是服务消费者，B是服务提供者；对于B调用C的业务而言：B是服务消费者，C是服务提供者因此，服务B既可以是服务提供者，也可以是服务消费者。

3.Eureka注册中心

复制代码

假如服务提供者user-service部署了多个实例，如图：

那么值得考虑的是：

复制代码

 - order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？（既然无法得知确切的地址，那么之前的调用方法就不能使用）
 - 有多个user-service实例地址，order-service调用时该如何选择？
 - order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

所以就有了注册中心，而Euaeka就是一个常用的注册中心。

3.1Eureka的结构和作用

首先Eureka分为服务端和客户端，顾名思义服务端就是提供Euaeka服务的，客户端就是使用的

我将按照这幅图讲解消费者远程调用的流程，这样就可以解决上面三个问题：首先提供者和消费者都会注册服务信息到注册中心上（因为即使是消费者将来有可能作为提供者）这些信息就包含了这个服务各个部署的地址，然后一个消费者想要消费一个提供者就首先先得从注册中心处拉取这个服务的信息，这时候会把全部的地址（实例列表）都给消费者，然后从实例列表中利用负载均衡算法选中一个实例地址然后向该实例地址发起远程调用。这就是大体流程。

那么order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳，当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除，而order-service拉取服务时，就能将故障实例排除了。

3.2实现：

3.2.1搭建eureka-server

首先注册中心服务端：eureka-server，这其实就是是一个独立的微服务。

step1：创建一个子模块（使用maven）

step2：引入eureka-server（这是一个服务端肯定得引入服务端依赖）依赖（一定要注意兼容性）

java 复制代码

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

step3：编写启动类

给eureka-server服务编写一个启动类，一定要添加一个@EnableEurekaServer注解，开启eureka的注册中心功能：

java 复制代码

package cn.itcast.eureka;

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

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

step4：编写配置文件

java 复制代码

server:
  port: 10086
spring:
  application:
    name: eureka-server
eureka:
  client:
    use-discovery-client-http-client: false # 新增：解决JDK21+兼容性错误
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka/

复制代码

启动微服务，然后在浏览器访问：http://127.0.0.1:10086即可。

3.2.2服务注册

比如，将user-service注册到eureka-server中去。

step1：引入eureka-client（这是客户端，所以引入客户端依赖）依赖：

java 复制代码

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

step2：配置yaml文件

java 复制代码

spring:
  application:
    name: userservice//表面我这个服务的名字
eureka://既然要注册到一个服务端，肯定要指定服务端名字
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

因为现在只有一台设备，无法模拟分布式，但是我们可以改一下端口来代表不同的服务

首先复制一份配置：

然后修改一下名字和端口：

然后就可以在service里面启动这两个服务，即可。

这就完成了注册，在Eureka里面是这样的：

然后订单服务就可以拉取user服务了，这就是服务发现：

3.2.3服务发现

将order-service的逻辑修改：向eureka-server拉取user-service的信息，实现服务发现。

step1:引入依赖

服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一致。

java 复制代码

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

step2：配置yaml文件（和服务注册是一样的）

java 复制代码

spring:
  application:
    name: orderservice
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:10086/eureka

又把消费者注册进来了

step3：服务拉取和负载均衡（这些动作不用我们去做，只需要添加一些注解即可）

首先给之前的配置的那个Rest....对象加上@LoadBalanced注解，这样可以实现负载均衡。

java 复制代码

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

然后就是修改访问提供者的逻辑：OrderService类中的queryOrderById方法。修改访问的url路径，就是用服务名代替以前的ip、端口：

这样spring会自动从eureka-server端，根据userservice这个服务名称，获取实例列表，而后完成负载均衡。很简单吧。

其实到现在为止就几个操作很简单，都是两部分其实：

首先先写一个注册中心：两部分一部分就是引入Eureka服务端依赖，第二部分就是配置yaml文件

其次就是服务注册：也是两部分一部分就是引入Eureka客户端依赖，第二部分也是配置yaml文件

然后就是服务发现：也是两部分然后再加一个发请求罢了，两部分和服务注册是一样的，发请求的话就是先配置RestTemplate，上面加上@LoadBalanced注解，然后就可以在需要用到的地方注入，然后使用就行了，使用服务名直接访问

3.3Ribbon负载均衡

添加了@LoadBalanced注解，即可实现负载均衡功能，原理是什么：

SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。大体来说流程是这样的：Ribbon会帮助我们拉取提供者，然后再采取负载均衡轮询的策略，从服务列表选择一个。

细节就是：有人帮我们根据service名称，获取到了服务实例的ip和端口。它就是LoadBalancerInterceptor，这个类会在对RestTemplate的请求进行拦截，然后从Eureka根据服务id获取服务列表，随后利用负载均衡算法得到真实的服务地址信息，替换服务id。源码是：

step1：LoadBalancerIntercepor

复制代码

可以看到这里的intercept方法，拦截了用户的HttpRequest请求，然后做了几件事：
- request.getURI()：获取请求uri，本例中就是 http://user-service/user/8
- originalUri.getHost()：获取uri路径的主机名，其实就是服务id，user-service，然后传递给了execute方法。
- this.loadBalancer.execute()：处理服务id，和用户请求。
继续跟入execute方法：

其实就是从请求中拿到uri，然后再拿到服务名（提供者的名字）然后传给execute方法

step2：LoadBalancerClient

复制代码

- getLoadBalancer(serviceId)：根据服务id获取ILoadBalancer，而ILoadBalancer会拿着服务id去eureka中获取服务列表并保存起来，传递给getServer
- getServer(loadBalancer)：利用内置的负载均衡算法，从服务列表中选择一个。这个方法其实就是实现了负载均衡的最终方法

其实就是通过上一步传过来的服务名得到服务列表，然后执行getService方法选择一个，这个getService方法内部就实现了负载均衡。

继续跟入这个方法

step3：负载均衡策略IRule

继续跟进chooseService方法

看一下rule是什么：

这里的rule是IRule类型，默认值是一个RoundRobinRule，看类的介绍：

复制代码

这个就是轮询的意思，至此我们跟踪源码明白了轮询的原理，总之细节就是

复制代码

基本流程如下：
- 拦截我们的RestTemplate请求http://userservice/user/1
- RibbonLoadBalancerClient会从请求url中获取服务名称，也就是user-service
- DynamicServerListLoadBalancer根据user-service到eureka拉取服务列表
- eureka返回列表，localhost:8081、localhost:8082
- IRule利用内置负载均衡规则，从列表中选择一个，例如localhost:8081
- RibbonLoadBalancerClient修改请求地址，用localhost:8081替代userservice，得到http://localhost:8081/user/1，发起真实请求

3.4负载均衡策略

负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类：默认的实现就是第一种轮询方案。

那么可以自定义负载均衡策略（一般用默认的即可，无需修改），有两种方式：

3.4.1. 配置bean：

定义一个新的IRule，比如随机选择一个吧：

java 复制代码

@Bean
public IRule randomRule(){
    return new RandomRule();
}

这样在进行选择实例的时候就会使用RandRule规则，但是是所有使用的提供者

3.4.2. 配置文件方式：在消费者的application.yml文件中，添加提供者的配置：这样可以对指定消费者进行配置。

java 复制代码

userservice: # 给某个微服务配置负载均衡规则，这里是userservice服务
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则

3.5饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：

java 复制代码

ribbon:
  eager-load:
    enabled: true
    clients: userservice #如果还要添加其他服务，用逗号隔开

注意如果还要添加其他服务，用逗号隔开，因为我们不可能每个调用的提供者都要进行饥饿加载。

其实Eureka就几个操作很简单，都是两部分其实：

首先先写一个注册中心：两部分一部分就是引入Eureka服务端依赖，第二部分就是配置yaml文件

其次就是服务注册：也是两部分一部分就是引入Eureka客户端依赖，第二部分也是配置yaml文件

然后就是服务发现：也是两部分然后再加一个发请求罢了，两部分和服务注册是一样的，发请求的话就是先配置RestTemplate，上面加上@LoadBalanced注解，然后就可以在需要用到的地方注入，然后使用就行了，使用服务名直接访问

然后服务发现的项目里可以配置负载均衡策略和需要饥饿加载的消费者。

4.Nacos注册中心

国内公司一般都推崇阿里巴巴的技术，比如注册中心，SpringCloudAlibaba也推出了一个名为Nacos的注册中心。相比Eureka功能更加丰富（除了服务注册发现还可以进行配置管理），在国内受欢迎程度较高。

4.1安装Nacos，我安装到了window上，因为我上面就有jdk环境，默认的账号和密码都是nacos

注意不能直接点击这个运行，因为你直接点击就是集群模式了

所以要用cmd窗口：startup.cmd -m standalone，后面那个单词表示单机执行。在浏览器输入地址：http://127.0.0.1:8848/nacos即可。![](https://i-blog.csdnimg.cn/direct/e393bbb5cb9c4547a4d7987eb2488891.png)

4.2服务注册到Nacos

Nacos是SpringCloudAlibaba的组件，而SpringCloudAlibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos和使用Eureka对于微服务来说，并没有太大区别。主要差异在于：依赖不同和服务地址不同，流程都是一样的（看见没很简单吧）

step1：引入SpringCloudAlibaba依赖（多出来的一步）：

在父工程的pom文件中的<dependencyManagement>中引入SpringCloudAlibaba的依赖：

java 复制代码

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.6.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

step2：引入Nacos对应的依赖

在user-service和order-service中的pom文件中引入nacos-discovery依赖（Eureka是都引入eureka客户端的依赖）：

java 复制代码

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

step3：配置yaml文件

在user-service和order-service的application.yml中添加nacos地址：

java 复制代码

spring:
  application:
    name: user-service  # 服务名，必须配置，用于在Nacos中注册和发现
  cloud:
    nacos:
      server-addr: localhost:8848  # Nacos服务器地址

step4：启动类添加@EnableDiscoveryClient注解

注意：

现在两个服务都注册成功了、代码也没错，我一开始就是服务调用不了，问题就是缺少了负载均衡依赖 ，Spring Cloud 2020版本之后，默认不包含负载均衡包，@LoadBalanced无法生效，所以才解析不了服务名。

这个时候需要在order-service的pom.xml里，加上这个依赖即可解决：
java 复制代码
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

4.3服务分级存储模型

一个服务可以有多个实例.例如user-service，可以有: 127.0.0.1:8081 ，127.0.0.1:8082 ， 127.0.0.1:8083 假如这些实例分布于全国各地的不同机房，例如：127.0.0.1:8081，在上海机房 127.0.0.1:8082，在上海机房 127.0.0.1:8083，在杭州机房 Nacos就将同一机房内的实例划分为一个集群。也就是说，user-service是服务，一个服务可以包含多个集群，如杭州、上海，每个集群下可以有多个实例，形成分级模型.

微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群。

比如之前没配置集群可以发现集群都是默认集群，即都在一个下面：

4.3.1修改集群

配置集群很简单，就是在yaml配置文件中配置即可

java 复制代码

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ # 集群名称

给3个提供者和一个消费者配置了集群：

4.3.3同集群优先的负载均衡

默认的负载均衡策略并不能实现根据同集群优先来实现负载均衡。因此Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例，配置的话就和上面说过的一样，这里使用yaml文件进行配置，所以在消费者的yaml文件中加入

java 复制代码

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

4.3.4权重配置

实际部署中会出现这样的场景：服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。

可以直接在集群配置中配置

4.3.5环境隔离

Nacos提供了namespace来实现环境隔离功能。nacos中可以有多个namespace，而namespace下可以有group一个group下可以有多个service等，不同namespace之间相互隔离，服务互相不可见，层级关系是：

默认情况下，所有service、data、group都在同一个namespace，名为public：

我们可以点击页面新增按钮，添加一个namespace：

然后就可以给微服务配置nameplace了：

java 复制代码

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID

4.4Nacos和Eureka区别

复制代码

Nacos的服务实例分为两种类型：
- 临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。
- 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。

配置一个服务实例为永久实例：一个比较完整的yaml文件

java 复制代码

spring:
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID
        ephemeral: false # 设置为非临时实例 

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

复制代码

Nacos和Eureka整体结构类似，服务注册、服务拉取、心跳等待，但是也存在一些差异：
- Nacos与eureka的共同点
  - 都支持服务注册和服务拉取
  - 都支持服务提供者心跳方式做健康检测
- Nacos与Eureka的区别
  - Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式，临时实例心跳不正常会被剔除，非临时实例则不会被剔除
  - Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
  - Nacos集群默认采用AP方式，当集群中存在非临时实例时，采用CP模式；Eureka采用AP方式（之后讲）

其实Nacos就几个操作很简单，都是三部分其实：

首先就是安装一个Nacos的服务端，并且启动

其次就是服务注册：两部分一部分就是引入依赖，第二部分也是配置yaml文件，第三步就是在启动类加一个@EnableDiscoveryClient

然后就是服务发现：也是三部分然后再加一个发请求罢了，两部分和服务注册是一样的，发请求的话就是先配置RestTemplate，上面加上@LoadBalanced注解，然后就可以在需要用到的地方注入，然后使用就行了，使用服务名直接访问（但是需要注意的是，）

然后服务发现的项目里可以配置负载均衡策略和需要饥饿加载的消费者，这里给一个比较全面的yaml文件：
java 复制代码
spring:
  application:
    name: orderservice
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID
        ephemeral: false # 设置为非临时实例 

userservice:
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则