SpringCloud入门

Spring Cloud 知识点整理

Spring Cloud 基础概念

Spring Cloud 可以理解为微服务架构的使用实现模式，微服务利用 spring boot 的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、消息总线、负载均衡、断路器、数据监控等，都可以用 spring boot 的开发风格做到一键启动和部署。

微服务架构的一些概念

服务注册：服务提供者将所提供服务的信息（服务器IP和端⼝、服务访问协议等） 注册/登记到注册中⼼

服务发现：服务消费者能够从注册中⼼获取到较为实时的服务列表，然后根究⼀定 的策略选择⼀个服务访问

负载均衡：负载均衡即将请求压⼒分配到多个服务器（应⽤服务器、数据库服务器等），以 此来提⾼服务的性能、可靠性。

熔断：熔断即断路保护。微服务架构中，如果下游服务因访问压⼒过⼤⽽响应变慢或失 败，上游服务为了保护系统整体可⽤性，可以暂时切断对下游服务的调⽤。这种牺 牲局部，保全整体的措施就叫做熔断

链路追踪：所谓链路追踪，就是对⼀次请求涉及的很多个服务链路进⾏⽇志记 录、性能监控

API ⽹关：微服务架构下，不同的微服务往往会有不同的访问地址，客户端可能需要调⽤多个服务的接⼝才能完成⼀个业务需求，API请求调用统⼀接⼊API⽹关层，由⽹关转发请求。API⽹关更专注在安全、路由、流量等问题的处理上。1） 统⼀接⼊（路由）2） 安全防护3） ⿊⽩名单4） 协议适配5） 流量管控6） 容错能⼒

体系结构

	第一代Springcloud（Netflix,SCN）	第二代SpringCloud（主要是SpringCloudAlibaba，SCA）
注册中心/服务发现	Netflix Eureka	阿里巴巴 Nacos
客户端负载均衡	Netflix Ribbon	阿里巴巴 Dubbo LB，Spring Cloud Loadbalancer
熔断器	Netflix Hystrix	阿里巴巴 Sentinel
网关	Netflix Zuul：性能一般即将退出Spring Cloud生态圈	官方 Spring CLoud Gateway
配置中心	官方 Spring CLoud Config	阿里巴巴 Nacos、协程 Apollo
服务调用	Netflix Feign	阿里巴巴 Dubbo RPC
消息驱动	官方 Spring CLoud Sream
链路追踪	官方 Spring CLoud Sleuth/Zipkin

Spring CLoud 与 Spring Boot的关系

Spring Cloud 是基于 Spring Boot 的，让我们能够快速的实现微服务组件开发，从而不必过多考虑每⼀个组件的相关Jar包的兼容新等问题。

微服务架构的优势：

• 服务聚焦/解耦 ， 每个微服务都可以被⼀个⼩团队单独实施，团队合作⼀定程度解耦，便于实施敏捷开发
• 微服务很独⽴，那么不同的微服务可以使⽤不同的语⾔开发，松耦合
• 微服务架构下，我们可以更好的实现DevOps开发运维⼀体化；
• 方便升级和扩展

微服务架构的缺点：

• 分布式复杂难以管理
• 分布式链路跟踪难等

总结

• 单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统
• 分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目。例如：京东、淘宝
• 微服务：一种更好的分布式架构方案
  • 优点：松耦合，聚焦单一业务功能，无关开发语言，团队规模降低 , 扩展性好, 天然支持分库
  • 缺点：随着服务数量增加，管理复杂，部署复杂，服务器需要增多，服务通信和调用压力增大
• SpringCloud 是微服务架构的一站式解决方案，集成了各种优秀的微服务功能组件

服务拆分和简单远程调用

服务拆分原则

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

远程调用：RestTemplate为例

服务的通讯方式主要有二种 :

1．同步通信：通过Feign发送http请求调用 或者 通过Dubbo发送RPC请求调用

2．异步通信：使用消息队列进行服务调用，如RabbitMQ、KafKa等

假设建立两个微服务

• cloud-demo：父工程，管理依赖
  • order-service：订单微服务，负责订单相关业务
  • user-service：用户微服务，负责用户相关业务
• 需求
  • 订单微服务和用户微服务必须有各自的数据库，相互独立
  • 订单服务和用户服务都对外暴露Restful的接口
  • 订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据库

导入demo

• 导入资料提供好的demo，里面包含了order-service和user-service，将其配置文件中的数据库修改为自己的配置，随后将这两个服务启动，开始我们的调用案例

sql

CREATE DATABASE cloud_order;
USE cloud_order;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for tb_order
-- ----------------------------
DROP TABLE IF EXISTS `tb_order`;
CREATE TABLE `tb_order`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '订单id',
  `user_id` bigint(20) NOT NULL COMMENT '用户id',
  `name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '商品名称',
  `price` bigint(20) NOT NULL COMMENT '商品价格',
  `num` int(10) NULL DEFAULT 0 COMMENT '商品数量',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`name`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 109 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of tb_order
-- ----------------------------
INSERT INTO `tb_order` VALUES (101, 1, 'Apple 苹果 iPhone 12 ', 699900, 1);
INSERT INTO `tb_order` VALUES (102, 2, '雅迪 yadea 新国标电动车', 209900, 1);
INSERT INTO `tb_order` VALUES (103, 3, '骆驼（CAMEL）休闲运动鞋女', 43900, 1);
INSERT INTO `tb_order` VALUES (104, 4, '小米10 双模5G 骁龙865', 359900, 1);
INSERT INTO `tb_order` VALUES (105, 5, 'OPPO Reno3 Pro 双模5G 视频双防抖', 299900, 1);
INSERT INTO `tb_order` VALUES (106, 6, '美的（Midea) 新能效 冷静星II ', 544900, 1);
INSERT INTO `tb_order` VALUES (107, 2, '西昊/SIHOO 人体工学电脑椅子', 79900, 1);
INSERT INTO `tb_order` VALUES (108, 3, '梵班（FAMDBANN）休闲男鞋', 31900, 1);

SET FOREIGN_KEY_CHECKS = 1;

CREATE DATABASE cloud_user;
USE cloud_user;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '收件人',
  `address` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`username`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 109 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES (1, '柳岩', '湖南省衡阳市');
INSERT INTO `tb_user` VALUES (2, '文二狗', '陕西省西安市');
INSERT INTO `tb_user` VALUES (3, '华沉鱼', '湖北省十堰市');
INSERT INTO `tb_user` VALUES (4, '张必沉', '天津市');
INSERT INTO `tb_user` VALUES (5, '郑爽爽', '辽宁省沈阳市大东区');
INSERT INTO `tb_user` VALUES (6, '范兵兵', '山东省青岛市');

SET FOREIGN_KEY_CHECKS = 1;

实现远程调用案例

• 在order-service中的web包下，有一个OrderController，是根据id查询订单的接口

@RestController
@RequestMapping("order")
public class OrderController {

   @Autowired
   private OrderService orderService;

    @GetMapping("{orderId}")
    public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
        // 根据id查询订单并返回
        return orderService.queryOrderById(orderId);
    }
}

我们打开浏览器，访问http://localhost:8080/order/101 ，是可以查询到数据的，但此时的user是null

• 即订单服务无法调用用户微服务来查询用户详情信息

{
	"id": 101,
	"price": 699900,
	"name": "Apple 苹果 iPhone 12 ",
	"num": 1,
	"userId": 1,
	"user": null
}

• 在user-service中的web包下，也有一个UserController，其中包含一个根据id查询用户的接口

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User queryById(@PathVariable("id") Long id) {
        return userService.queryById(id);
    }
}

我们打开浏览器，访问http://localhost:8081/user/1 ，查询到的数据如下

{
	"id": 1,
	"username": "柳岩",
	"address": "湖南省衡阳市"
}

怎么改造才能使订单服务调用用户微服务来查询用户详情信息呢？

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

步骤一：注册RestTemplate

首先我们在order-service服务中的OrderApplication启动类中，注册RestTemplate实例

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

步骤二：实现远程调用

修改order-service服务中的queryById方法(使用restTemplate)

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);
        // 2. 远程查询User
        // 2.1 url地址，这里的url是写死的，后面会改进
        String url = "http://localhost:8081/user/" + order.getUserId();
        // 2.2 发起调用
        User user = restTemplate.getForObject(url, User.class);
        // 3. 存入order
        order.setUser(user);
        // 4.返回
        return order;
    }
}

再次访问http://localhost:8080/order/101， 这次就能看到User数据了

{
	"id": 101,
	"price": 699900,
	"name": "Apple 苹果 iPhone 12 ",
	"num": 1,
	"userId": 1,
	"user": {
		"id": 1,
		"username": "柳岩",
		"address": "湖南省衡阳市"
	}
}

提供者与消费者

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

Eureka

Eureka是一个服务发现框架

Eureka：服务注册中心(可以是一个集群)，对外暴露自己的地址。

• 提供者：启动后向Eureka注册自己信息(地址，提供什么服务)。

• 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新。

• 心跳(续约)：提供者定期通过http（心跳）方式向Eureka刷新自己的状态。

• 自我保护机制：某时刻某一个微服务不可用了，eureka不会立刻清理，依旧会对该微服务的信息进行保存。

• 客户端缓存：Eureka还提供了客户端缓存机制，即使所有的Eureka Server都挂掉，客户端依然可以利用缓存中的信息消费其他服务的API，所以Eureka是AP的

那么现在来回答之前的各个问题

order-service如何得知user-service实例地址？

获取地址信息流程如下

• user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端），这个叫服务注册
• eureka-server保存服务名称到服务实例地址列表的映射关系
• order-service根据服务名称，拉取实例地址列表，这个叫服务发现或服务拉取

order-service如何从多个user-service实例中选择具体的实例？

• order-service从实例列表中利用负载均衡算法选中一个实例地址
• 向该实例地址发起远程调用

order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？

• user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己的状态，成为心跳
• 当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
• order-service拉取服务时，就能将该故障实例排除了

实操

• 因此，我们接下来动手实践的步骤包括
  1. 搭建注册中心
     • 搭建EurekaServer
  2. 服务注册
     • 将user-service、order-service都注册到eureka
  3. 服务发现
     • 在order-service中完成服务拉取，然后通过负载均衡挑选一个服务，实现远程调用

搭建注册中心

引入eureka依赖

引入SpringCloud为eureka提供的starter依赖：

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

编写启动类

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

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

编写配置文件

• 编写一个application.yml文件，内容如下

• 为什么也需要配置eureka的服务名称呢？

  • eureka也会将自己注册为一个服务

  server:
    port: 10086 # 服务端口
  spring:
    application:
      name: eureka-server # eureka的服务名称
  eureka:
    client:
      service-url: # eureka的地址信息
        defaultZone: http://127.0.0.1:10086/eureka

启动服务

启动微服务，然后在浏览器访问 http://localhost:10086/， 看到如下结果就是成功了

服务注册

• 下面，我们将user-service注册到eureka-server中去

引入依赖

• 在user-service的pom.xml文件中，引入下面的eureka-client依赖

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

配置文件

• 在user-service中，修改application.yml文件，添加服务名称、eureka地址

server:
  port: 8081
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/cloud_user?useSSL=false
    username: root
    password: 1234
    driver-class-name: com.mysql.jdbc.Driver
+  application:
+    name: user-service
+eureka:
+  client:
+    service-url:
+      defaultZone: http://127.0.0.1:10086/eureka
mybatis:
  type-aliases-package: cn.itcast.user.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

启动多个user-service实例

• 为了演示一个服务有多个实例的场景，我们添加一个SpringBoot的启动配置，再启动一个user-service，其操作步骤就是复制一份user-service的配置，name配置为UserApplication2，同时也要配合VM选项，修改端口号-Dserver.port=8082，点击确定之后，在IDEA的服务选项卡中，就会出现两个user-service启动配置，一个端口是8081，一个端口是8082
• 之后我们按照相同的方法配置order-service，并将两个user-service和一个order-service都启动，然后查看eureka-server管理页面，发现服务确实都启动了，而且user-service有两个

服务发现

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

引入依赖

• 服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一致
• 在order-service的pom.xml文件中，引入eureka-client依赖

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

配置文件

• 服务发现也需要知道eureka地址，因此第二步与服务注册一致，都是配置eureka信息
• 在order-service中，修改application.yml文件，添加服务名称、eureka地址

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

服务拉取和负载均衡

• 最后，我们要去eureka-server中拉取user-service服务的实例列表，并实现负载均衡
• 不过这些操作并不需要我们来做，是需要添加一些注解即可
• 在order-service的OrderApplication中，给RestTemplate这个Bean添加一个@LoadBalanced注解

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {

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

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

修改order-service服务中的OrderService类中的queryOrderById方法，修改访问路径，用服务名来代替ip、端口

public Order queryOrderById(Long orderId) {
    // 1.查询订单
    Order order = orderMapper.findById(orderId);
    // 2. 远程查询User
    // 2.1 url地址，用user-service替换了localhost:8081
    String url = "http://user-service/user/" + order.getUserId();
    // 2.2 发起调用
    User user = restTemplate.getForObject(url, User.class);
    // 3. 存入order
    order.setUser(user);
    // 4.返回
    return order;
}

• Spring会自动帮我们从eureka-server端，根据user-service这个服务名称，获取实例列表，然后完成负载均衡

• 试试http://localhost:8080/order/101 正常访问（获取服务成功）

  • ```json
    {

    "id":101,
    "price":699900,
    "name":"Apple 苹果 iPhone 12 ",
    "num":1,
    "userId":1,
    "user":{
        "id":1,
        "username":"柳岩",
        "address":"湖南省衡阳市"
    }
    

    }

    
    
    ### 实操小结
    
    1. 搭建EurekaServer
      - 引入eureka-server依赖
      - 添加@EnableEurekaServer注解
      - 在application.yml中配置eureka地址
    2. 服务注册
      - 引入eureka-client依赖
      - 在application.yml中配置eureka地址
    3. 服务发现
      - 引入eureka-client依赖
      - 在application.yml中配置eureka地址
      - 在RestTemplate添加`@LoadBalanced`注解
      - 用服务提供者的服务名称远程调用
    
    
    
    # Ribbon负载均衡
    
    上一小节中我们提到 我们在服务调用方 的 启动类 RestTemplate上添加`@LoadBalanced`注解，它其实是**Spring Cloud Ribbon**提供的一个负载均衡注解。它可以让RestTemplate在调用服务时具备负载均衡的能力。通过该注解，Spring Cloud能够自动将应用中的服务调用请求分发到不同的服务实例中。
    
    ![](https://differencer.oss-cn-beijing.aliyuncs.com/img/20230704231032.png)
    
    默认采用轮询的方式访问实例
    
    - 那么我们明明发出的请求是http://userservice/user/1， 怎么变成了http://localhost:8080/user/1 的呢
    
    我们来看看源码
    
    ## 源码跟踪
    
    - 为什么我们只输入了service名称就可以访问了呢？之前还得获取ip和端口
    - 答案显然是有函数帮我们根据service名称，获取到了服务实例的ip和端口。
     - 它就是LoadBalancerInterceptor，这个类会第RestTemplate的请求进行拦截，然后从Eureka根据服务id获取服务列表，随后利用负载均衡算法，得到真实的服务地址信息，替换服务id
    - 那下面我们来进行源码跟踪
    
    ### LoadBalancerInterceptor
    
    ```java
    public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
       private LoadBalancerClient loadBalancer;
       private LoadBalancerRequestFactory requestFactory;
    
       public LoadBalancerInterceptor(LoadBalancerClient loadBalancer, LoadBalancerRequestFactory requestFactory) {
           this.loadBalancer = loadBalancer;
           this.requestFactory = requestFactory;
       }
    
       public LoadBalancerInterceptor(LoadBalancerClient loadBalancer) {
           this(loadBalancer, new LoadBalancerRequestFactory(loadBalancer));
       }
    
       public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
           URI originalUri = request.getURI();
           String serviceName = originalUri.getHost();
           Assert.state(serviceName != null, "Request URI does not contain a valid hostname: " + originalUri);
           return (ClientHttpResponse)this.loadBalancer.execute(serviceName, this.requestFactory.createRequest(request, body, execution));
       }
    }

我们要”负载均衡“的网址会进入 intercept 中被处理，打个断点看看

• 可以看到这里的intercept方法，拦截了用户的HTTPRequest请求，然后做了几件事
  1. request.getURI()：获取请求uri，本利中就是http://user-service/user/1
  2. originalUri.getHost()：获取uri路径的主机名，其实就是服务id，user-service
  3. this.loadBalancer.execute：处理服务id和用户请求
• 这里的this.loadBalancer是LoadBalancerClient类型，我们继续跟入execute 函数

public <T> T execute(String serviceId, LoadBalancerRequest<T> request, Object hint) throws IOException {
    ILoadBalancer loadBalancer = this.getLoadBalancer(serviceId);
    Server server = this.getServer(loadBalancer, hint);
    if (server == null) {
        throw new IllegalStateException("No instances available for " + serviceId);
    } else {
        RibbonServer ribbonServer = new RibbonServer(serviceId, server, this.isSecure(server, serviceId), this.serverIntrospector(serviceId).getMetadata(server));
        return this.execute(serviceId, (ServiceInstance)ribbonServer, (LoadBalancerRequest)request);
    }
}

• 代码是这样的

  1. getLoadBalancer(serviceId)：根据服务id（Servername：user-service）获取ILoadBalancer，而ILoadBalancer会拿着服务id去eureka中获取服务列表并保存起来
  2. getServer(loadBalancer, hint)：利用内置的负载均衡算法，从服务列表中选择一个，本例中，可以看到获取到的是8081端口的一个实例

  放行后，再次访问并跟踪，这次获取到的是8082端口，果然实现了负载均衡

负载均衡策略IRule

• 在刚才的代码中，可以看到获取服务是通过一个getServer的方法来做负载均衡，我们继续跟入，会发现这样一段代码

public Server chooseServer(Object key) {
    if (this.counter == null) {
        this.counter = this.createCounter();
    }

    this.counter.increment();
    if (this.rule == null) {
        return null;
    } else {
        try {
            return this.rule.choose(key);
        } catch (Exception var3) {
            logger.warn("LoadBalancer [{}]:  Error choosing server for key {}", new Object[]{this.name, key, var3});
            return null;
        }
    }
}

在try/catch代码块中，进行服务选择的是this.rule.choose(key)，那我们看看这个rule是谁

• 这里的rule默认值是一个RoundRobinRule，也就是轮询
• 那么到这里，整个负载均衡的流程我们就清楚了

总结

• SpringCloudRibbon的底层采用了一个拦截器，拦截了RestTemplate发出的请求，对地址做了修改，用一幅图来总结一下

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

负载均衡策略

负载均衡策略

刚才我们看到，负载均衡的规则都定义在IRule接口中，而IRule有很多不同的实现类

大致分为 轮询、重试、随机、可用性过滤等

• 不同规则的含义如下

内置负载均衡规则类	规则描述
RoundRobinRule	简单轮询服务列表来选择服务器。它是Ribbon默认的负载均衡规则。
AvailabilityFilteringRule	对以下两种服务器进行忽略： （1）在默认情况下，这台服务器如果3次连接失败，这台服务器就会被设置为“短路”状态。短路状态将持续30秒，如果再次连接失败，短路的持续时间就会几何级地增加。 （2）并发数过高的服务器。如果一个服务器的并发连接数过高，配置了AvailabilityFilteringRule规则的客户端也会将其忽略。并发连接数的上限，可以由客户端的..ActiveConnectionsLimit属性进行配置。
WeightedResponseTimeRule	为每一个服务器赋予一个权重值。服务器响应时间越长，这个服务器的权重就越小。这个规则会随机选择服务器，这个权重值会影响服务器的选择。
ZoneAvoidanceRule	以区域可用的服务器为基础进行服务器的选择。使用Zone对服务器进行分类，这个Zone可以理解为一个机房、一个机架等。而后再对Zone内的多个服务做轮询。
BestAvailableRule	忽略那些短路的服务器，并选择并发数较低的服务器。
RandomRule	随机选择一个可用的服务器。
RetryRule	重试机制的选择逻辑

自定义负载均衡策略

通过定义IRule实现，可以修改负载均衡规则，有两种方式

1. 代码方式：在order-service中的OrderApplication类中，定义一个IRule，此种方式定义的负载均衡规则，对所有微服务均有效

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

1. 配置文件方式：在order-service中的application.yml文件中，添加新的配置也可以修改规则

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

注意：一般使用默认的负载均衡规则，不做修改

饥饿加载

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

ribbon:
  eager-load:
    enabled: true # 开启饥饿加载
	clients: 
  	 - user-service
  	 - xxx-service 

小结

1. Ribbon负载均衡规则
   • 规则接口是IRule
   • 默认实现是ZoneAvoidanceRule，根据zone选择服务列表，然后轮询
2. 负载均衡自定义方式
   • 代码方式：配置灵活，但修改时需要重新打包发布
   • 配置方式：直观，方便，无需重新打包发布，但是无法做全局配置（只能指定某一个微服务）
3. 饥饿加载
   • 开启饥饿加载
   • 指定饥饿加载的微服务名称，可以配置多个

Nacos注册中心

• 国内公司一般都推崇阿里巴巴的技术，比如注册中心，SpringCloud Alibaba也推出了一个名为Nacos的注册中心

认识和安装Nacos

• Nacos是阿里巴巴的产品，现在是SpringCloud中的一个组件，相比于Eureka，功能更加丰富，在国内受欢迎程度较高
• 在Nacos的GitHub页面，提供有下载链接，可以下载编译好的Nacos服务端或者源代码：
  • GitHub主页：https://github.com/alibaba/nacos
  • GitHub的Release下载页：https://github.com/alibaba/nacos/releases
• 下载好了之后，将文件解压到非中文路径下的任意目录，目录说明：
  • bin：启动脚本
  • conf：配置文件
• Nacos的默认端口是8848，如果你电脑上的其它进程占用了8848端口，请先尝试关闭该进程。
  • 如果无法关闭占用8848端口的进程，也可以进入nacos的conf目录，修改配置文件application.properties中的server.port
• Nacos的启动非常简单，进入bin目录，打开cmd窗口执行以下命令即可

startup.cmd -m standalone

• 之后在浏览器访问http://localhost:8848/nacos 即可，默认的登录账号和密码都是nacos

服务注册到Nacos

• Nacos是SpringCloudAlibaba的组件，而SpringCloud Alibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos与使用Eureka对于微服务来说，并没有太大区别
• 主要差异在于
  1. 依赖不同
  2. 服务地址不同

引入依赖

在cloud-demo父工程的pom.xml文件中引入SpringCloudAlibaba的依赖

<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>

然后在user-service和order-service中的pom文件引入nacos-discovery依赖

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

注意：同时也要将eureka的依赖注释/删除掉

配置Nacos地址

在user-service和order-service的application.yml中添加Nacos地址（删掉eureka相关）

spring:
  cloud:
    nacos:
      server-addr: localhost:8848

重启服务

• 重启微服务后，登录nacos的管理页面，可以看到微服务信息

服务分级存储模型

一个服务可以有多个实例，假如这些实例分布于全国各地的不同机房，

• Nacod就将在同一机房的实例，划分为一个集群
• 也就是说，user-service是服务，一个服务可以包含多个集群，例如在杭州，上海，每个集群下可以有多个实例，形成分级模型
• 微服务相互访问时，应该尽可能访问同集群实例，因为本地访问速度更快，房本集群内不可用时，才去访问其他集群
  • 例如：杭州机房内的order-service应该有限访问同机房的user-service，若无法访问，则去访问上海机房的user-service

给user-service配置集群（cluster-name）

修改user-service的application.yml文件，添加集群配置

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

• 重启两个user-service实例
• 之后我们再复制一个user-service的启动配置，端口号设为8083，之后修改application.yml文件，将集群名称设为上海，之后启动该服务

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: SH # 集群名称，上海

• 那么我们现在就启动了两个集群名称为HZ的user-service，一个集群名称为SH的user-service，在Nacos控制台看到如下结果

• Nacos服务分级存储模型
  1. 一级是服务，例如user-service
  2. 二级是集群，例如杭州或上海
  3. 三级是实例，例如杭州机房的某台部署了user-service的服务器
• 如何设置实例的集群属性
  • 修改application.yml文件，添加spring.cloud.nacos.discovery.cluster-name属性即可

同集群优先的负载均衡

• 默认的ZoneAvoidanceRule并不能根据同集群优先来实现负载均衡

• 因此Nacos中提供了一个NacosRule的实现，可以优先从同集群中挑选实例

1. 给order-service配置集群信息，修改其application.yml文件，将集群名称配置为HZ

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

1. 修改负载均衡规则（顶头写）

user-service: # 给某个微服务配置负载均衡规则，这里是user-service服务
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

• 那我们现在访问http://localhost:8080/order/101 ，同时观察三个user-service的日志输出，集群名称为HZ的两个user-service可以看到日志输出，而集群名称为SH的user-service则看不到日志输出

• NacosRule负载均衡策略

  1. 优先选择统计群服务实例列表
  2. 本地集群找不到提供者，才去其他集群寻找，并且会报警告
  3. 确定了可用实例列表后，再采用随机负载均衡挑选实例

权重配置

• 实际部署中肯定会出现这样的场景

  • 服务器设备性能由差距，部分实例所在的机器性能较好，而另一些较差，我么你希望性能好的机器承担更多的用户请求
  • 但默认情况下NacosRule是统计群内随机挑选，不会考虑机器性能的问题

• 因此Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高

• 在Nacos控制台，找到user-service的实例列表，点击编辑，即可以修改权重

  注意：若权重修改为0，则该实例永远不会被访问
  我们可以将某个服务的权重修改为0，然后进行更新，然后也不会影响到用户的正常访问别的服务集群，之后我们可以给更新后的该服务，设置一个很小的权重，这样就会有一小部分用户来访问该服务，测试该服务是否稳定（类似于灰度测试）

环境隔离

• Nacos提供了namespace来实现环境隔离功能
  • nacos中可以有多个namespace
  • namespace下可以由group、service等
  • 不同的namespace之间相互隔离，例如不同的namespace的服务互相不可见

创建namespace

• 默认情况下，所有的service、data、group都是在同一个namespace，名为public
• 我们点击命名空间 -> 新建命名空间 -> 填写表单，可以创建一个新的namespace

给微服务配置namespace

• 给微服务配置namespace只能通过修改配置来实现
• 例如，修改order-service的application.yml文件

spring:
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: HZ
        namespace: 0d4fa829-98b7-4858-abef-b3fe8093bd92 # 命名空间，填上图中的命名空间ID

重启order-service后，访问Nacos控制台，可以看到下面的结果，此时访问order-service，因为namespace不同，会导致找不到user-service，若访问http://localhost:8080/order/101 则会报错

Nacos和Eureka的区别

• Nacos的服务实例可以分为两种类型

  1. 临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型
  2. 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例

• 配置一个服务实例为永久实例

spring:
  cloud:
    nacos:
      discovery:
        ephemeral: false # 设置为非临时实例

Nacos和Eureka整体结构类似，服务注册、服务拉取、心跳等待，但是也存在一些差异

• Nacos与Eureka的共同点
  1. 都支持服务注册和服务拉取
  2. 都支持服务提供者心跳方式做健康监测
• Nacos与Eureka的区别
  1. Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式（但是对服务器压力比较大，不推荐）
  2. 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
  3. Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
  4. Nacos集群默认采用AP方式，当集群存在非临时实例时，采用CP模式；Eureka采用AP方式

Nacos配置管理

• Nacos除了可以做注册中心，同样还可以做配置管理来使用

统一配置管理

• 当微服务部署的实例越来越多，达到数十、数百时，逐个修改微服务配置就会让人抓狂，而且容易出错，所以我们需要一种统一配置管理方案，可以集中管理所有实例的配置
• Nacos一方面可以将配置集中管理，另一方面可以在配置变更时，及时通知微服务，实现配置的热更新

在Nacos中添加配置文件

• 如何在Nacos中管理配置呢
  • 配置列表 -> 点击右侧加号
• 在弹出的表单中，填写配置信息

pattern:
  dateformat: yyyy-MM-dd HH:mm:ss

注意：只有需要热更新的配置才有放到Nacos管理的必要，基本不会变更的一些配置，还是保存到微服务本地比较好（例如数据库连接配置等）

从微服务拉取配置

• 微服务要拉取Nacos中管理的配置，并且与本地的application.yml配置合并，才能完成项目启动
• 但如果上位读取application.yml，又如何得知Nacos地址呢？
• Spring引入了一种新的配置文件：bootstrap.yml文件，会在application.yml之前被读取，流程如下
  1. 项目启动
  2. 加载bootstrap.yml文件，获取Nacos地址，配置文件id
  3. 根据配置文件id，读取Nacos中的配置文件
  4. 读取本地配置文件application.yml，与Nacos拉取到的配置合并
  5. 创建Spring容器
  6. 加载bean

引入nacos-config依赖

• 首先在user-service服务中，引入nacos-config的客户端依赖

<!--nacos配置管理依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

添加bootstrap.yml

• 然后在user-service中添加一个bootstrap.yml文件，内容如下

spring:
  application:
    name: user-service # 服务名称
+  profiles:
+    active: dev #开发环境，这里是dev 
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
+      config:
+        file-extension: yaml # 文件后缀名

• 这里会根据spring.cloud.nacos.server-addr获取Nacos地址，再根据${spring.application.name}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}作为文件id，来读取配置。
• 在本例中，就是读取user-service-dev.yaml
• 测试是否真的读取到了，我们在user-service的UserController中添加业务逻辑，读取nacos中的配置信息pattern.dateformat配置

@Value("${pattern.dateformat}")
private String dateformat;

@GetMapping("/test")
public String test() {
    return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
}