SpringCloud Alibaba

一、微服务简介

1.1、架构演变

1.1.1、单体架构

• 互联网早期，一般的网站应用流量较小，只需一个应用，将所有功能代码都部署在一起就可以，这 样可以减少开发、部署和维护的成本。
• 比如说一个电商系统，里面会包含很多用户管理，商品管理，订单管理，物流管理等等很多模块， 我们会把它们做成一个web项目，然后部署到一台tomcat服务器上
• 优点
  • 项目架构简单，小型项目的话， 开发成本低
  • 项目部署在一个节点上， 维护方便
• 缺点
  • 全部功能集成在一个工程中，对于大型项目来讲不易开发和维护
  • 项目模块之间紧密耦合，单点容错率低
  • 无法针对不同模块进行针对性优化和水平扩展

1.1.2、垂直应用架构

• 随着访问量的逐渐增大，单一应用只能依靠增加节点来应对，但是这时候会发现并不是所有的模块 都会有比较大的访问量.
• 所谓垂直应用架构，就是将原来的一个应用拆成互不相干的几个应用，以提升效率。
• 比如我们可 以将上面电商的单体应用拆分成：
  • 电商系统(用户管理 商品管理 订单管理)
  • 后台系统(用户管理 订单管理 客户管理)
  • CMS系统(广告管理 营销管理)
• 垂直拆分后，一旦用户访问量变大，只需要增加电商系统的节点就可以了，而无需增加后台 和CMS的节点
• 优点：
  • 系统拆分实现了流量分担，解决了并发问题，而且可以针对不同模块进行优化和水平扩展
  • 一个系统的问题不会影响到其他系统，提高容错率
• 缺点：
  • 系统之间相互独立， 无法进行相互调用
  • 系统之间相互独立， 会有重复的开发任务

1.1.3、分布式架构

• 当垂直架构拆分越来越多时，重复的业务代码就会越来越多，为了降低耦合，分布式架构诞生了
• 分布式架构将把工程拆分成表现层和服务层两个部分，服务层中包含业务逻辑。
• 表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。
• 优点：
  • 抽取公共的功能为服务层，提高代码复用性
• 缺点：
  • 系统间耦合度变高，调用关系错综复杂，难以维护

1.1.4、SOA架构

• 面向服务的架构（SOA）是一个组件模型，它将应用程序的不同功能单元（称为服务）进行拆分，并通过这些服务之间定义良好的接口和协议联系起来。
• 接口是采用中立的方式进行定义的，它应该独立于实现服务的硬件平台、操作系统和编程语言。这使得构建在各种各样的系统中的服务可以以一种统一和通用的方式进行交互。
• 面向服务架构，它可以根据需求通过网络对松散耦合的粗粒度应用组件进行分布式部署、组合和使用。
• 服务层是SOA的基础，可以直接被应用调用，从而有效控制系统中与软件代理交互的人为依赖性。
• SOA是一种粗粒度、松耦合服务架构，服务之间通过简单、精确定义接口进行通讯，不涉及底层编程接口和通讯模型。
• SOA可以看作是B/S模型、XML，Web Service技术之后的自然延伸。
• SOA系统是一种企业通用性架构。
• 优点:
  • 使用注册中心解决了服务间调用关系的自动调节
• 缺点:
  • 服务间会有依赖关系，一旦某个环节出错会影响较大( 服务雪崩 )
  • 服务关心复杂，运维、测试部署困难

1.2、认识微服务

1.2.1、什么是微服务

• 微服务是一种架构风格，严格来说微服务并不是一项技术，而是spring技术生态整合的集合，即将单体应用划分为小型的服务单元，达到模块化开发的目的，微服务之间使用 HTTP 的 API 进行资源访问与操作。

1.2.2、微服务优点及缺点

• 优点
  • 服务的独立部署：每个服务都是一个独立的项目，可以独立部署，不依赖于其他服务，耦合性低。
  • 服务的快速启动：拆分之后服务启动的速度必然要比拆分之前快很多，因为依赖的库少了，代码量也少了。
    更加适合敏捷开发：敏捷开发以用户的需求进化为核心，采用迭代、循序渐进的方法进行。模块化发布。
    职责专一：每个模块独立开发，提高了开发人员对业务的专注性
    服务动态按需扩容：当某个服务的访问量较大时，我们只需要将这个服务扩容即可。
    代码的复用：每个服务都提供 REST API，所有的基础服务都必须抽出来，很多的底层实现都可以以接口方式提供。
• 缺点
  • 分布式部署，调用复杂性高：在微服务中，每个模块都是独立部署的，通过 HTTP 来进行通信，这当中会产生很多问题，比如网络问题、容错问题、调用关系等。
  • 独立数据库，分布式事务挑战：每个微服务都有自己的数据库，这就是所谓的去中心化的数据管理。这种模式的优点在于不同的服务，可以选择适合自身业务的数据，比如订单服务可以用 MySQL、评论服务可以用 Mongodb、商品搜索服务可以用 Elasticsearch。
    测试的难度提升：服务和服务之间通过接口来交互，当接口有改变的时候，对所有的调用方都是有影响的，同时就强调了 API 文档的管理尤为重要。
    运维难度的提升：在微服务架构下模块化部署，会让业务增加时，服务也将越来越多，服务的部署、监控将变得非常复杂。

1.3、SpringCloud

• SpringCloud是一系列框架的有序集合。它利用 SpringBoot 的开发便利性，巧妙地简化了分布式系统基础设施的开发，如服务注册、服务发现、配置中心、消息总线、负载均衡、断路器、数据监控等，这些都可以用 Spring Boot 的开发风格做到一键启动和部署。
• 通俗地讲，Spring Cloud 就是用于构建微服务开发和治理的框架集合，并不是具体的一个框架。
• 作为新一代的服务框架，Spring Cloud 提出的口号是开发“面向云的应用程序”，它为微服务架构提供了更加全面的技术支持。
• SpringCloud与dubbo的功能区别
• SpringCloud的优势
  • Spring Cloud 来源于 Spring，质量、稳定性、持续性都可以得到保证。
  • Spirng Cloud 天然支持 Spring Boot，更加便于业务落地。
  • Spring Cloud 是 Java领域最适合做微服务的框架。

1.4、SpringCloud Alibaba

1.4.1、什么是SpringCloud Alibaba

• SpringCloud Alibaba是阿里针对SpringCloud优化开源的国产技术，致力于一站式解决方案
• 依托 Spring Cloud Alibaba，只需要添加部分注解和少量配置就可将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。

1.4.2、SpringCloud Alibaba功能介绍

• 服务限流降级：默认支持 WebServlet、WebFlux, OpenFeign、RestTemplate、Spring Cloud Gateway, Zuul, Dubbo 和 RocketMQ 限流降级功能的接入，可以在运行时通过控制台实时修改限流降级规则，还支持查看限流降级 Metrics 监控。
• 服务注册与发现：适配 Spring Cloud 服务注册与发现标准，默认集成了 Ribbon 的支持。
• 分布式配置管理：支持分布式系统中的外部化配置，配置更改时自动刷新。
• 消息驱动能力：基于 Spring Cloud Stream 为微服务应用构建消息驱动能力。
• 分布式事务：使用 @GlobalTransactional 注解， 高效并且对业务零侵入地解决分布式事务问题。
• 阿里云对象存储：阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。
• 分布式任务调度：提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。同时提供分布式的任务执行模型，如网格任务。网格任务支持海量子任务均匀分配到所有 Worker（schedulerx-client）上执行。
• 阿里云短信服务：覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

1.4.3、SpringCloud Alibaba优势

• 得益于SpringCloud Alibaba强大的组件生态
  • Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
  • Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
  • RocketMQ：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时、高可靠的消息发布与订阅服务。
  • Dubbo：Apache Dubbo是一款高性能 Java RPC 框架。
  • Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。
  • Alibaba Cloud ACM：一款在分布式架构环境中对应用配置进行集中管理和推送的应用配置中心产品。
  • Alibaba Cloud OSS: 阿里云对象存储服务，是阿里云提供的海量、安全、低成本、高可靠的云存储服务。可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。
  • Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。
  • Alibaba Cloud SMS: 覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

二、版本控制与环境构建

• 开发遵循约定 > 配置 > 编码，各框架组件之间的版本必须一一对应。

2.1、框架主体版本

• 毕业版本依赖关系(推荐使用)
  | Spring Cloud Version | Spring Cloud Alibaba Version | Spring Boot Version | | —- | —- | —- | | Spring Cloud 2020.0.0 | 2021.1 | 2.4.2 | | Spring Cloud Hoxton.SR9 | 2.2.6.RELEASE | 2.3.2.RELEASE | | Spring Cloud Greenwich.SR6 | 2.1.4.RELEASE | 2.1.13.RELEASE | | Spring Cloud Hoxton.SR3 | 2.2.1.RELEASE | 2.2.5.RELEASE | | Spring Cloud Hoxton.RELEASE | 2.2.0.RELEASE | 2.2.X.RELEASE | | Spring Cloud Greenwich | 2.1.2.RELEASE | 2.1.X.RELEASE | | Spring Cloud Finchley | 2.0.4.RELEASE(停止维护，建议升级) | 2.0.X.RELEASE | | Spring Cloud Edgware | 1.5.1.RELEASE(停止维护，建议升级) | 1.5.X.RELEASE |

• 使用直接添加依赖

  #添加Spring Cloud Alibaba 2021.1
  <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-alibaba-dependencies</artifactId>
   <version>2021.1</version>
   <type>pom</type>
   <scope>import</scope>
  </dependency>

2.2、组件版本

• 组件版本关系
  | Spring Cloud Alibaba Version | Sentinel Version | Nacos Version | RocketMQ Version | Dubbo Version | Seata Version | | —- | —- | —- | —- | —- | —- | | 2.2.6.RELEASE | 1.8.1 | 1.4.2 | 4.4.0 | 2.7.8 | 1.3.0 | | 2021.1 or 2.2.5.RELEASE or 2.1.4.RELEASE or 2.0.4.RELEASE | 1.8.0 | 1.4.1 | 4.4.0 | 2.7.8 | 1.3.0 | | 2.2.3.RELEASE or 2.1.3.RELEASE or 2.0.3.RELEASE | 1.8.0 | 1.3.3 | 4.4.0 | 2.7.8 | 1.3.0 | | 2.2.1.RELEASE or 2.1.2.RELEASE or 2.0.2.RELEASE | 1.7.1 | 1.2.1 | 4.4.0 | 2.7.6 | 1.2.0 | | 2.2.0.RELEASE | 1.7.1 | 1.1.4 | 4.4.0 | 2.7.4.1 | 1.0.0 | | 2.1.1.RELEASE or 2.0.1.RELEASE or 1.5.1.RELEASE | 1.7.0 | 1.1.4 | 4.4.0 | 2.7.3 | 0.9.0 | | 2.1.0.RELEASE or 2.0.0.RELEASE or 1.5.0.RELEASE | 1.6.3 | 1.1.1 | 4.4.0 | 2.7.3 | 0.7.1 |

• 使用直接添加依赖

  #添加Nacos 1.4.2
  <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  </dependency>

2.3、第一个SPringCloud案例

2.3.1、技术选型及版本确认

1、目录结构

2、整体框架

• Springboot 2.1.3 RELEASE
• SpringCloud Greenwich.RELEASE
• SpringCloud alibaba 2.1.0
• Maven 3.6.1
• mysql 5.7

• springData jpa 2.5.2

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.hguo</groupId>
   <artifactId>SpringCloud_01</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>pom</packaging>
   <!--pom父工程总包-->
   <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot</artifactId>
           <version>2.1.3.RELEASE</version>
   </parent>
   <!--依赖版本锁定-->
   <properties>
       <java.version>1.8</java.version>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
       <spring-cloud.version>Greenwich.RELEASE</spring-cloud.version>
       <spring-cloud-alibaba.version>2.1.0.RELEASE</spring-cloud-alibaba.version>
   </properties>
   <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>org.springframework.cloud</groupId>
               <artifactId>spring-cloud-dependencies</artifactId>
               <version>${spring-cloud.version}</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
           <dependency>
               <groupId>com.alibaba.cloud</groupId>
               <artifactId>spring-cloud-alibaba-dependencies</artifactId>
               <version>${spring-cloud-alibaba.version}</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
       </dependencies>
   </dependencyManagement>
  </project>

2.3.2、模块设计

• springcloud_01 父工程
• shop-common 公共模块【实体类】
• shop-user 用户微服务 【端口: 807x】
• shop-product 商品微服务【端口: 808x】
• shop-order 订单微服务 【端口: 809x】

2.3.3、创建基础模块

1、创建子模块shop-common并配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hguo</groupId>
    <artifactId>shop-common</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.56</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、创建实体类

• 用户类 ```java package com.hguo.entity;

import lombok.Data; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;

/**

• @author hguo
• @date2021/8/5 17:30
• @title 现世安稳，岁月静好，佛祖保佑，永无bug!
• 用户 */ @Entity(name = “shop_user”) @Data public class User {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer uid;//主键
   private String username;//用户名
   private String password;//密码
   private String telephone;//手机号

  } ```

• 商品类 ```java package com.hguo.entity;

import lombok.Data; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;

/**

• @author hguo
• @date2021/8/5 17:32
• @title 现世安稳，岁月静好，佛祖保佑，永无bug!
• 商品 */ @Entity(name = “shop_product”) @Data public class Product {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer pid;//主键
   private String pname;//商品名称
   private Double pprice;//商品价格
   private Integer stock;//库存

  } ```

• 订单类 ```java package com.hguo.entity;

import lombok.Data; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;

/**

• @author hguo
• @date2021/8/5 17:33
• @title 现世安稳，岁月静好，佛祖保佑，永无bug!
• 订单 */ @Entity(name = “shop_order”) @Data public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long oid;//订单id private Integer uid;//用户id private String username;//用户名 private Integer pid;//商品id private String pname;//商品名称 private Double pprice;//商品单价 private Integer number;//购买数量 } ```

2.3.4、创建微服务

1、创建用户模块

• 目录结构
• dao层 ```java package com.hguo.dao;

import com.hguo.entity.User; import org.springframework.data.jpa.repository.JpaRepository; /**

• @author hguo
• @date2021/8/5 23:55
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ public interface UserDao extends JpaRepository { } ```

• controller层 ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.User; import com.hguo.service.UserService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; /**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class UserController { @Autowired private UserService userService; @GetMapping(“/user/{uid}”) public User user(@PathVariable(“uid”) Integer uid){ User user = userService.findByuid(uid); log.info(“查询用户：”+ JSON.toJSONString(user)); return user; } }

-  **service层** 
```java
package com.hguo.service;
import com.hguo.entity.User;
/**
 * @author hguo
 * @date2021/8/6 0:02
 * @title 现世安稳，岁月静好，佛祖保佑，永无bug!
 */
public interface UserService {
    User findByuid(Integer uid);
}

• serviceImpl ```java package com.hguo.service.impl;

import com.hguo.dao.UserDao; import com.hguo.entity.User; import com.hguo.service.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;

/**

• @author hguo
• @date2021/8/5 23:58

• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ @Service public class UserServiceImpl implements UserService { @Autowired private UserDao userDao;

  public User findByUid(Integer uid){

   return userDao.findById(uid).get();

  }

  @Override public User findByuid(Integer uid) {

   return userDao.findById(uid).get();

  } } ```

• shop_user/pom.xml ```xml <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance“

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  4.0.0

  org.hguo SpringCloud_01 1.0-SNAPSHOT

  com.hguo shop_user

  0.0.1-SNAPSHOT

   <java.version>1.8</java.version>

   <dependency>
     <groupId>org.hguo</groupId>
       <artifactId>shop_common</artifactId>
       <version>1.0-SNAPSHOT</version>
       <scope>compile</scope>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-devtools</artifactId>
       <scope>runtime</scope>
       <optional>true</optional>
   </dependency>

  org.springframework.boot spring-boot-maven-plugin

-  **yaml配置文件** 
```yaml
server:
  port: 8071
spring:
  application:
    name: service-user
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?
      serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
  jpa:
    properties:
      hibernates:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

2、创建商品模块

• 目录结构
• dao层 ```java package com.hguo.dao;

import com.hguo.entity.Product; import org.springframework.data.jpa.repository.JpaRepository;

/**

• @author hguo
• @date2021/8/5 23:55
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ public interface ProductDao extends JpaRepository { } ```

• controller层 ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.Product; import com.hguo.service.ProductService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController;

/**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class ProductController { @Autowired private ProductService productService; @GetMapping(“/product/{pid}”) public Product product(@PathVariable(“pid”) Integer pid){ Product product = productService.findBypid(pid); log.info(“查询商品：”+ JSON.toJSONString(product)); return product; } }

-  **service层** 
```java
package com.hguo.service;
import com.hguo.entity.Product;
/**
 * @author hguo
 * @date2021/8/6 0:02
 * @title 现世安稳，岁月静好，佛祖保佑，永无bug!
 */
public interface ProductService {
    Product findBypid(Integer pid);
}

• serviceImpl ```java package com.hguo.service.impl;

import com.hguo.dao.ProductDao; import com.hguo.entity.Product; import com.hguo.service.ProductService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;

/**

• @author hguo
• @date2021/8/5 23:58

• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ @Service public class ProductServiceImpl implements ProductService { @Autowired private ProductDao productDao;

  @Override public Product findBypid(Integer pid) {

   return productDao.findById(pid).get();

  } } ```

• shop_product/pom.xml ```xml <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance“

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  4.0.0

  org.hguo SpringCloud_01 1.0-SNAPSHOT shop_product

   <java.version>1.8</java.version>

   <dependency>
     <groupId>org.hguo</groupId>
       <artifactId>shop_common</artifactId>
       <version>1.0-SNAPSHOT</version>
       <scope>compile</scope>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-devtools</artifactId>
       <scope>runtime</scope>
       <optional>true</optional>
   </dependency>

</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

-  **yaml配置文件** 
```yaml
server:
  port: 8081
spring:
  application:
    name: service-product
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
  jpa:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
          dialect: org.hibernate.dialect.MySQL5InnoDBDialect

3、创建订单模块

• 目录结构
• dao层 ```java package com.hguo.dao;

import com.hguo.entity.Order; import org.springframework.data.jpa.repository.JpaRepository;

/**

• @author hguo
• @date2021/8/5 23:55
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ public interface OrderDao extends JpaRepository { } ```

• controller层
  • order调用product模块，实现微服务之间的相互调用 ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.Order; import com.hguo.entity.Product; import com.hguo.service.OrderService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;

/**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class OrderController { @Autowired private OrderService orderService;

@Autowired
private RestTemplate restTemplate;
//买1件商品
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid") Integer pid){
    log.info(">>客户已下单，调用微服务查询订单信息");
    //通过restTemplate调用微服务
    Product product = restTemplate.getForObject(
            "http://localhost:8081/product/"+pid,Product.class
    );
    log.info(">>商品详情：{}",pid,JSON.toJSONString(product));
    Order order = new Order();
    order.setUid(1);
    order.setUsername("用户测试");
    order.setPid(product.getPid());
    order.setUsername(product.getPname());
    order.setPprice(product.getPprice());
    order.setNumber(1);
    orderService.createOrder(order);
    log.info("订单创建成功：{}",JSON.toJSONString(order));
    return order;
}

}

-  **service层** 
```java
package com.hguo.service;
import com.hguo.entity.Order;
import org.springframework.data.jpa.repository.JpaRepository;
/**
 * @author hguo
 * @date2021/8/6 0:02
 * @title 现世安稳，岁月静好，佛祖保佑，永无bug!
 */
public interface OrderService  {
    //创建订单
    void createOrder(Order order);
}

• serviceImpl ```java package com.hguo.service.impl;

import com.hguo.dao.OrderDao; import com.hguo.entity.Order; import com.hguo.service.OrderService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service;

/**

• @author hguo
• @date2021/8/5 23:58

• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ @Service public class OrderServiceImpl implements OrderService { @Autowired private OrderDao orderDao;

  @Override public void createOrder(Order order) {

   orderDao.save(order);

  } } ```

• shop_order/pom.xml ```xml <?xml version=”1.0” encoding=”UTF-8”?> <project xmlns=”http://maven.apache.org/POM/4.0.0“ xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance“

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  4.0.0 org.hguo SpringCloud_01 1.0-SNAPSHOT

<artifactId>shop_order</artifactId>
<properties>
    <java.version>1.8</java.version>
</properties>
<dependencies>
    <dependency>
      <groupId>org.hguo</groupId>
        <artifactId>shop_common</artifactId>
        <version>1.0-SNAPSHOT</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

-  **yaml配置文件** 
```yaml
server:
  port: 8091
spring:
  application:
    name: service-order
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
  jpa:
    properties:
      hibernate:
        hbm2ddl:
          auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

2.3.5、微服务调用

1、消费者和服务者

• 服务者：服务声明被调用的模块一方，上述案例中的Product
• 消费者：服务主动调用其他模块的一方，上述案例中的Order
• 在Nacos Discovery—服务治理中会详细说明

2、逻辑层的调用关系

• 自底向上的顺序
  • entity层
    • 定义与数据库对象应的属性，提供get/set方法，tostring方法,有参无参构造函数。
  • dao层
    • 创建dao接口，接着就可以在配置文件中定义该接口的实现类；
    • 在模块中调用dao的接口进行数据业务的处理，dao层的数据源和数据库连接的参数都是在配置文件中进行配置
  • service层
    • 业务模块的逻辑应用设计，和dao层一样都是先设计接口，再创建要实现的类，然后在配置文件中进行配置其实现的关联。然后service层调用接口进行业务逻辑应用的处理。
  • controller层
    • 具体的业务模块流程的控制，controller层主要调用Service层里面的接口控制具体的业务流程，控制的配置也要在配置文件中进行。
  • Controller和Service的区别
    • Controller负责具体的业务模块流程的控制；Service层负责业务模块的逻辑应用设计
• 调用逻辑顺序
  • Controller —> Service层接口方法 —> Dao层方法 —> 数据库

三、组件详解

3.1、Nacos

3.1.1、服务治理

1、什么是服务治理

• 服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现
• 服务注册
  • 在服务治理框架中，都会构建一个注册中心，每个服务单元向注册中心登记自己提供服务的详细信息，并在注册中心形成一张服务的清单，服务注册中心需要以心跳的方式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务
• 服务发现
  • 服务调用方向服务注册中心咨询服务，并获取所有服务的实例清单，实现对具体服务实例的访问
• 注册中心
  • 服务发现：
  • 服务注册：保存服务提供者和服务调用者的信息
  • 服务订阅：服务调用者订阅服务提供者的信息，注册中心向订阅者推送提供者的信息
  • 服务配置：
    • 配置订阅：服务提供者和服务调用者订阅微服务相关的配置
    • 配置下发：主动将配置推送给服务提供者和服务调用者
  • 服务健康检测：
    • 检测服务提供者的健康情况，如果发现异常，执行服务剔除

2、常见的注册中心

• Nacos
  • Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台
  • 它是 Spring Cloud Alibaba 组件之一，负责服务注册发现和服务配置，可以这样认为nacos=eureka+config。
• Zookeeper
  • zookeeper是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式 应用中经常遇到的一些数据管理问题
  • 如：统一命名服务、状态同步服务、集群管理、分布式应用 配置项的管理等
• Eureka
  • Eureka是Springcloud Netflix中的重要组件，主要作用就是做服务注册和发现，但是现在已经闭源
• Eureka
  • Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现 和配置管理的功能。
  • Consul的功能都很实用，其中包括：
    • 服务注册/发现
    • 健康检查
    • Key/Value 存储
    • 多数据中心和分布式一致性保证等特性。
  • Consul本身只是一个二进制的可执行文件，所以 安装和部署都非常简单，只需要从官网下载后，在执行对应的启动脚本即可

3.1.2、Nacos简介

• Nacos 致力于帮助您发现、配置和管理微服务
• Nacos 提供了一组简单易用的特性集，帮助您快速 实现动态服务发现、服务配置、服务元数据及流量管理
• Nacos 支持基于 DNS 和基于 RPC 的服务发现
• 服务提供者使用 原生SDK、OpenAPI、或一个独立的Agent TODO注册 Service 后，服务消费者可以使用DNS TODO 或HTTP&API查找和发现服务
• Nacos 提供对服务的实时的健康检查，阻止向不健康的主机或服务实例发送请求
• Nacos特性分析
  • 特性大图：要从功能特性，非功能特性，全面介绍我们要解的问题域的特性诉求
  • 架构大图：通过清晰架构，让您快速进入 Nacos 世界
  • 业务大图：利用当前特性可以支持的业务场景，及其最佳实践
  • 生态大图：系统梳理 Nacos 和主流技术生态的关系
  • 优势大图：展示 Nacos 核心竞争力
  • 战略大图：要从战略到战术层面讲 Nacos 的宏观优势
• Nacos生态

3.1.3、Nacos实战整合

1、搭建Nacos环境

1.1、安装Nacos

• 下载地址：https://github.com/alibaba/nacos/releases
• 下载zip版本，走解压版安装
• 安装
  

1.2、启动Nacos

• 启动方式一：双击startup.cmd
• 启动方式二：命令行启动

  #切换目录
  cd nacos/bin
  #启动命令
  startup cmd -mstandalone

• 启动结果
  • 默认访问地址为：192.168.137.1或localhost
  • 默认监听端口为：8848

1.3、访问Nacos

• 再浏览器中访问：http://192.168.137.1:8848/nacos，账号：nacos 密码：nacos

2、将服务注册到Nacos中

2.1、将商品微服务加入Nacos中

• 在shop_product/pom.xml中添加Nacos依赖

  <!--nacos客户端-->
  <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  </dependency>

• 在启动类上添加Nacos客户端启动注解

  //添加@EnableDiscoveryClient注解
  @SpringBootApplication
  @EnableDiscoveryClient
  public class ProductApplication

• 在shop_product/application.yaml中添加访问地址

  spring:
   cloud:
       nacos:
           discovery:
               server-addr: 192.168.137.1:8848 #locahost:8848

• 启动访问，查看nacos中微服务的注册情况
• 

2.2、将订单微服务加入Nacos中

• 在shop_order/pom.xml中添加Nacos依赖

  <!--nacos客户端-->
  <dependency>
   <groupId>com.alibaba.cloud</groupId>
   <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  </dependency>

• 在启动类上添加Nacos客户端启动注解

  //添加@EnableDiscoveryClient注解
  @SpringBootApplication
  @EnableDiscoveryClient
  public class ProductApplication

• 修改OrderController ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.Order; import com.hguo.entity.Product; import com.hguo.service.OrderService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;

/**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class OrderController { @Autowired private OrderService orderService;

@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
//买1件商品
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid") Integer pid){
    log.info(">>客户已下单，调用微服务查询订单信息");
    /*通过restTemplate调用微服务
    Product product = restTemplate.getForObject(
            "http://localhost:8081/product/"+pid,Product.class
    );
    log.info(">>商品详情：{}",pid,JSON.toJSONString(product));
    */
    //从nacos中获取服务地址
    ServiceInstance serviceInstance = discoveryClient.getInstances("service-product").get(0);
    String url = serviceInstance.getHost()+":" +serviceInstance.getPort();
            log.info(">>从nacos中获取的微服务地址为："+url);
    //通过restTemplate调用微服务
    Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);
    log.info(">>商品详细,查询结果："+JSON.toJSONString(product));
    Order order = new Order();
    order.setUid(1);
    order.setUsername("用户测试");
    order.setPid(product.getPid());
    order.setUsername(product.getPname());
    order.setPprice(product.getPprice());
    order.setNumber(1);
    orderService.createOrder(order);
    log.info("订单创建成功：{}",JSON.toJSONString(order));
    return order;
}

}

-  在**shop_order/application.yaml**中添加访问地址 
```yaml
spring:
    cloud:
        nacos:
            discovery:
                server-addr: 192.168.137.1:8848 #locahost:8848

• 启动访问，查看nacos中微服务的注册情况

3.1.4、实现负载均衡

1、负载均衡

• 通俗的讲， 负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行
• 在访问请求到达一定数量时，增加服务器的数量，然后将请求分发到各个服务器上，将原先请求集中到单个服务器上的情况改为将请求分发到多个服务器上，将负载分发到不同的服务器，已到达降低服务器压力的效果，也就是负载均衡。
• 根据负载均衡发生位置的不同,一般分为服务端负载均衡和客户端负载均衡
  • 服务端负载均衡指的是发生在服务提供者一方,比如常见的nginx负载均衡
  • 客户端负载均衡指的是发生在服务请求的一方，也就是在发送请求之前已经选好了由哪个实例处理请求
• 在高性能的请求和响应中，一般要求在客户端做到负载均衡
  

2、自定义负载均衡

2.1、启动新的微服并设置端口

• 新建微服务
• 启动服务

2.2、查看Nacos注册中心

2.3、修改逻辑请求实现负载均衡

package com.hguo.controller;
import com.alibaba.fastjson.JSON;
import com.hguo.entity.Order;
import com.hguo.entity.Product;
import com.hguo.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
import java.util.Random;
/**
 * @author hguo
 * @date2021/8/6 0:09
 * @title 现世安稳，岁月静好，佛祖保佑，永无bug!
 */
@RestController
@Slf4j
public class OrderController {
    @Autowired
    private OrderService orderService;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DiscoveryClient discoveryClient;
    //买1件商品
    @GetMapping("/order/prod/{pid}")
    public Order order(@PathVariable("pid") Integer pid){
        log.info(">>客户已下单，调用微服务查询订单信息");
        //3、随机挑选服务，伪负载
        List<ServiceInstance> instances = discoveryClient.getInstances("service-product");
        //创建0-2之间的随机数
        int index = new Random().nextInt(instances.size());
        ServiceInstance serviceInstance = instances.get(index);
        String url = serviceInstance.getHost()+":"+serviceInstance.getPort();
        log.info(">>从nacos中获取的微服务地址："+url);
        //通过restTemplate调用微服务
        //通过restTemplate调用微服务
        Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);
        log.info(">>商品详细,查询结果："+JSON.toJSONString(product));
        //订单业务处理
        Order order = new Order();
        order.setUid(1);
        order.setUsername("用户测试");
        order.setPid(product.getPid());
        order.setUsername(product.getPname());
        order.setPprice(product.getPprice());
        order.setNumber(1);
        orderService.createOrder(order);
        log.info("订单创建成功：{}",JSON.toJSONString(order));
        return order;
    }
}

2.4、负载均衡效果

• 两次随机请求
• 负载均衡效果

3、基于Ribbon实现负载均衡

3.1、ribbon == ?

• Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具，它基于Netflix Ribbon实现。
• SpringCloud Ribbon是一种默认轮询的负载均衡策略，在Springboot中添加ribbon组件即可使用。
• 通过Spring Cloud的封装，可以让我们轻松地将面向服务的REST模版请求自动转换成客户端负载均衡的服务调用。
• Spring Cloud Ribbon虽然只是一个工具类框架，它不像服务注册中心、配置中心、API网关那样需要独立部署，但是它几乎存在于每一个Spring Cloud构建的微服务和基础设施中。
• 因为微服务间的调用，API网关的请求转发等内容，实际上都是通过Ribbon来实现的，包括后续我们将要介绍的Feign，它也是基于Ribbon实现的工具。
• Spring Cloud Ribbon在微服务架构中使用客户端负载均衡调用只需两步：
  • 服务提供者只需要启动多个服务实例并注册到一个注册中心或是多个相关联的服务注册中心。
  • 服务消费者直接通过调用被@LoadBalanced注解修饰过的RestTemplate来实现面向服务的接口调用。
  • 这样可以将服务提供者的高可用以及服务消费者的负载均衡调用一起实现

3.2、Ribbon实现负载均衡的流程

• 在RestTemplate 的生成方法上添加@LoadBalanced 注解

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

• 修改服务调用的方法 ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.Order; import com.hguo.entity.Product; import com.hguo.service.OrderService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.ServiceInstance; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;

import java.util.List; import java.util.Random;

/**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class OrderController { @Autowired private OrderService orderService;

@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
//买1件商品
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid") Integer pid){
    log.info(">>客户已下单，调用微服务查询订单信息");
    //4、基于ribbon实现负载均衡
    //直接使用服务站名称，从nacos中获取
    String  url = "service-product";
    Product product = restTemplate.getForObject("http://" + url + "/product/" + pid, Product.class);
    log.info(">>商品详细,查询结果："+JSON.toJSONString(product));
    //订单业务处理
    Order order = new Order();
    order.setUid(1);
    order.setUsername("用户测试");
    order.setPid(product.getPid());
    order.setUsername(product.getPname());
    order.setPprice(product.getPprice());
    order.setNumber(1);
    orderService.createOrder(order);
    log.info("订单创建成功：{}",JSON.toJSONString(order));
    return order;
}

}

<a name="39e0110e"></a>
###### 3.3、负载均衡效果
![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210807201337676.png#crop=0&crop=0&crop=1&crop=1&id=uZaDO&originHeight=370&originWidth=1528&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="ac8b44ad"></a>
###### 3.4、Ribbon支持的负载均衡策略
-  Ribbon内置了多种负载均衡策略,内部负载均衡的顶级接口为 **com.netflix.loadbalancer.策略**  
| 策略名 | 策略描述 | 实现说明 |
| --- | --- | --- |
| BestAvailableRule | 选择一个最小的并发 请求的server | 逐个考察Server，如果Server被 tripped了，则忽略，在选择其中 ActiveRequestsCount最小的server |
| AvailabilityFilteringRule | 过滤掉那些因为一直 连接失败的被标记为 circuit tripped的后 端server，并过滤掉 那些高并发的的后端 server（active connections 超过配 置的阈值 | 使用一个AvailabilityPredicate来包含 过滤server的逻辑，其实就就是检查 status里记录的各个server的运行状 态 |
| WeightedResponseTimeRule | 过滤掉那些因为一直 连接失败的被标记为 circuit tripped的后 端server，并过滤掉 那些高并发的的后端 server（active connections 超过配 置的阈值 | 一个后台线程定期的从status里面读 取评价响应时间，为每个server计算 一个weight。Weight的计算也比较简 单responsetime 减去每个server自己 平均的responsetime是server的权 重。当刚开始运行，没有形成statas 时，使用roubine策略选择server。 |
| RetryRule | 过滤掉那些因为一直 连接失败的被标记为 circuit tripped的后 端server，并过滤掉 那些高并发的的后端 server（active connections 超过配 置的阈值 | 在一个配置时间段内当选择server不 成功，则一直尝试使用subRule的方 式选择一个可用的server |
| RoundRobinRule | 轮询方式轮询选择 server | 轮询index，选择index对应位置的 server |
| RandomRule | 随机选择一个server | 在index上随机，选择index对应位置 的server |
| ZoneAvoidanceRule | 复合判断server所在 区域的性能和server 的可用性选择server | 使用ZoneAvoidancePredicate和 AvailabilityPredicate来判断是否选择 某个server，前一个判断判定一个 zone的运行性能是否可用，剔除不可 用的zone（的所有server）， AvailabilityPredicate用于过滤掉连接 数过多的Server。 |
-  通过修改配置来调整Ribbon的负载均衡策略 
```yaml
service-product: # 调用的提供者的名称
    ribbon:
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

4、基于Feign实现服务调用

4.1、Feign == ?

• Feign是Spring Cloud提供的一个声明式的伪Http客户端， 它使得调用远程服务就像调用本地服务 一样简单， 只需要创建一个接口并添加一个注解即可。
• Nacos很好的兼容了Feign， Feign默认集成了 Ribbon， 所以在Nacos下使用Fegin默认就实现了负 载均衡的效果。

4.2、Feign的使用

• 加入Feign依赖

  <!--fegin组件-->
  <dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-openfeign</artifactId>
  </dependency>

• 在主类上添加注解

  @SpringBootApplication
  //开启nacos客户端
  @EnableDiscoveryClient
  //开启Fegin
  @EnableFeignClients
  public class OrderApplication {}

• 创建service并使用Feign实现微服务调用
  • 创建FeignSerivce
  • 驱动编辑 ```java package com.hguo.service;

import com.hguo.entity.Product; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping;

/**

• @author hguo
• @date2021/8/7 23:59
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */ //用于指定nacos下的微服务 @FeignClient(value = “service-product”) public interface FeignService { //@FeignClient+@GetMapping 就是一个完整的请求路径 http://serviceproduct/product/{pid} @RequestMapping(“/product/{pid}”) Product findByPid(@PathVariable(“pid”) Integer pid); } ```

• 修改controller并启动验证 ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.Order; import com.hguo.entity.Product; import com.hguo.service.FeignService; import com.hguo.service.OrderService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;

/**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class OrderController { @Autowired private OrderService orderService;

@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;
@Autowired
private FeignService feignService;
//买1件商品
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid") Integer pid){
    log.info(">>客户已下单，调用微服务查询订单信息");
    //5、通过fegin调用商品微服务
    Product product = feignService.findByPid(pid);
    log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
    //订单业务处理
    Order order = new Order();
    order.setUid(1);
    order.setUsername("用户测试");
    order.setPid(product.getPid());
    order.setUsername(product.getPname());
    order.setPprice(product.getPprice());
    order.setNumber(1);
    orderService.createOrder(order);
    log.info("订单创建成功：{}",JSON.toJSONString(order));
    return order;
}

}

<a name="f66d9d9c"></a>
#### 3.1.5、Nacsos配置解析
<a name="9e4eae89"></a>
##### 1、连接失败问题
<a name="750b1066"></a>
###### 1.1、失败原因
- 下载时，nacos-server使用的是cluster集群模式，
- 这个模式是要求使用mysql进行连接
- 事先需要配置好数据库并连接成功
<a name="05596829"></a>
###### 1.2、解决方案
-  将连接模式更改为单例模式即可 ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808144024875.png#crop=0&crop=0&crop=1&crop=1&id=YvoPR&originHeight=207&originWidth=804&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  cluster —> standalone ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808144146157.png#crop=0&crop=0&crop=1&crop=1&id=t6xJE&originHeight=303&originWidth=881&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
<a name="d3997a03"></a>
##### 2、数据库连接
<a name="3be11212"></a>
###### 2.1、问题描述
- nacos内置了一套数据持久化处理，属于文件集成，不便于后期维护、升级和数据校验，因此需要配置独立的数据库以达到数据持久化管理
<a name="3f8e1d16"></a>
###### 2.2、解决方案
- Nacos设计之初就已经做好了业务拓展的准备
- nacos的配置文件中包含了数据库连接并同步数据的配置文件
- 修改配置文件，启动连接即可
<a name="9ff8fb02"></a>
###### 2.3、解决流程
-  找到application.properties文件 ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808141014633.png#crop=0&crop=0&crop=1&crop=1&id=EfyIk&originHeight=456&originWidth=1045&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  修改数据库连接配置<br />![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808141318573.png#crop=0&crop=0&crop=1&crop=1&id=AzVkx&originHeight=286&originWidth=1792&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  将nacos-mysql.sql脚本在本地数据库运行 ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808142743044.png#crop=0&crop=0&crop=1&crop=1&id=OVKg8&originHeight=587&originWidth=1198&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  登陆Nacos官网 ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808144525365.png#crop=0&crop=0&crop=1&crop=1&id=vVNa1&originHeight=654&originWidth=1913&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  数据存储在数据库中 ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808144541331.png#crop=0&crop=0&crop=1&crop=1&id=h9giz&originHeight=220&originWidth=883&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
-  总结 
   - 在Nacos中产生的数据都会存储到数据库中
<a name="377017df"></a>
#### 3.1.6、Nacos config
<a name="2f268480"></a>
##### 1、服务配置中心
<a name="ac885ca8"></a>
###### 1.1、微服务带来的配置问题
- 配置文件相对分散。 
   - 在一个微服务架构下，配置文件会随着微服务的增多变的越来越多，而且分散在各个微服务中，不好统一配置和管理。
- 配置文件无法区分环境。 
   - 微服务项目可能会有多个环境
   - 例如：测试环境、预发布环境、生产环 境，每一个环境所使用的配置理论上都是不同的，一旦需要修改，就需要去各个微服务下手动维护，这比较困难。
- 配置文件无法实时更新。 
   - 修改配置文件之后，必须重新启动微服务才能使配置生效，这对一 个正在运行的项目来说是非常不友好的。
<a name="714914b8"></a>
###### 1.2、配置中心的思路
-  首先把项目中各种配置全部都放到一个集中的地方进行统一管理，并提供一套标准的接口。 
-  当各个服务需要获取配置的时候，就来配置中心的接口拉取自己的配置。 
-  当配置中心中的各种参数有更新的时候，也能通知到各个服务实时的过来同步最新的信息，使之动态更新。 
![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210813154634648.png#crop=0&crop=0&crop=1&crop=1&id=xbei8&originHeight=424&originWidth=833&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
<a name="f27057da"></a>
###### 1.3、常用的配置中心
- Apollo 
   - Apollo是由携程开源的分布式配置中心。
   - 特点有很多：配置更新之后可以实时生效，支持灰 度发布功能，并且能对所有的配置进行版本管理、操作审计等功能，提供开放平台API。
- Disconf 
   - Disconf是由百度开源的分布式配置中心。
   - 它是基于Zookeeper来实现配置变更后实时通知和生效 的。
- SpringCloud Config 
   - 是Spring Cloud中带的配置中心组件。
   - 它和Spring是无缝集成，使用起来非常方便，并且它的配 置存储支持Git。
   - 没有可视化的操作界面，配置的生效也不是实时的，需要重启或去刷新。
- Nacos 
   - 这是SpingCloud alibaba技术栈中的一个组件，前面我们已经使用它做过服务注册中心。
   - 集成了服务配置的功能，可以直接使用它作为服务配置中心。
<a name="a6fce9f4"></a>
##### 2、Nacos config
<a name="163719aa"></a>
###### 2.1、Nacos config入门
-  使用nacos作为配置中心，其实就是将nacos当做一个服务端，将各个微服务看成是客户端，将各个微服务的配置文件统一存放在nacos上，然后各个微服务从nacos上拉取配置即可。 
-  开启Nacos环境 
   - 双击打开nacos中的startup.cmd文件启动nacos
-  引入依赖 
```xml
<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

• 在微服务中添加nacos config配置
  • 新建一个bootstrap.yml作为配置文件
  • 配置文件优先级：bootstrap.properties -> bootstrap.yml -> application.properties -> application.yml

    spring:
    application:
      name: service-product
    cloud:
      nacos:
          config:
              server-addr: 127.0.0.1:8848 #nacos中心地址
              file-extension: yaml # 配置文件格式
    profiles:
      active: dev # 环境标识

• 在nacos中添加配置
  • 点击配置列表，点击右边+号，新建配置。在新建配置过程中，要注意下面的细节：
  • Data ID不能随便写，要跟配置文件中的对应，对应关系如图所示
  • 配置文件格式要跟配置文件的格式对应，且目前仅仅支持YAML和Properties
  • 配置内容按照上面选定的格式书写
• 注释本地的application.yam中的内容， 启动程序进行测试

2.2、Nacos config深入

• 配置动态刷新
  • 在入门案例中，我们实现了配置的远程存放，但是此时如果修改了配置，我们的程序是无法读取到 的，因此，我们需要开启配置的动态刷新功能。
  • 在nacos中的service-product-dev.yaml配置项中添加下面配置

    config: 
    appName: product

• 方式一：硬编码格式

  @RestController
  public class NacosConfigController {
       @Autowired
       private ConfigurableApplicationContext applicationContext;
  @GetMapping("/nacos-config-test1")
   public String nacosConfingTest1() {
       return applicationContext.getEnvironment().getProperty("config.appName");
       }
  }

• 方式二：注解方式

  @RestController
  @RefreshScope//只需要在需要动态读取配置的类上添加此注解就可以
  public class NacosConfigController {
  @Value("${config.appName}")
   private String appName;
  //2 注解方式
   @GetMapping("/nacos-config-test2")
   public String nacosConfingTest2() {
           return appName;
   }
  }

2.3、配置共享

• spring.application.name 命名的配置文件，然后将其所有环境的公共配置放在里面即可。
• 不同微服务之间的配置共享
  • 不同为服务之间实现配置共享的原理类似于文件引入，就是定义一个公共配置，然后在当前配置中引 入。
  • 在nacos中定义一个DataID为all-service.yaml的配置，用于所有微服务共享

    spring:
    zipkin:
    base-url: http://192.168.137.1:9411/ #zipkin server的请求地址
    discoveryClientEnabled: false #让nacos把它当成一个URL，而不要当做服务名
    sleuth:
    sampler:
    probability: 1.0 #采样的百分比
    application:
    name: service-product
    datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///shop?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true
    username: root
    password: 123456
    jpa:
    properties:
    hibernate:
      hbm2ddl:
        auto: update
        dialect: org.hibernate.dialect.MySQL5InnoDBDialect

• 修改bootstrap.yaml

  spring:
  application:
    name: service-product
  cloud:
    nacos:
        config:
            server-addr: 127.0.0.1:8848 #nacos中心地址
            file-extension: yaml # 配置文件格式
            shared-dataids: all-service.yaml # 配置要引入的配置
            refreshable-dataids: all-service.yaml # 配置要实现动态配置刷新的配置
  profiles:
        active: dev # 环境标识

3、Nacos配置介绍

• 命名空间(Namespace)
  命名空间可用于进行不同环境的配置隔离。一般一个环境划分到一个命名空间
• 配置分组(Group)
  配置分组用于将不同的服务可以归类到同一分组。一般将一个项目的配置分到一组
• 配置集(Data ID)
  在系统中，一个配置文件通常就是一个配置集。一般微服务的配置就是一个配置集

3.2、Sentinel

3.2.1、服务雪崩效应

1、高并发问题

1.1、高并发带来的问题

• 在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但是由于网络 原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会 出现网络延迟，此时若有大量的网络涌入，会形成任务堆积，最终导致服务瘫痪。

1.2、模拟高并发场景

• 代码及配置的编写
  • 新建OrderControllerTest类 ```java package com.hguo.controller;

import com.alibaba.fastjson.JSON; import com.hguo.entity.Order; import com.hguo.entity.Product; import com.hguo.service.FeignService; import com.hguo.service.OrderService; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.client.discovery.DiscoveryClient; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate;

/**

• @author hguo
• @date2021/8/6 0:09
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@RestController @Slf4j public class OrderControllerTest { @Autowired private OrderService orderService;

@Autowired
private FeignService feignService;
//买1件商品
@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid") Integer pid){
    log.info(">>客户已下单，调用微服务查询订单信息");
    //5、通过fegin调用商品微服务
    Product product = feignService.findByPid(pid);
    log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
    //模拟网络延时出现的卡顿
    try{
        Thread.sleep(100);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //订单业务处理
    Order order = new Order();
    order.setUid(1);
    order.setUsername("用户测试");
    order.setPid(product.getPid());
    order.setUsername(product.getPname());
    order.setPprice(product.getPprice());
    order.setNumber(1);
    orderService.createOrder(order);
    log.info("订单创建成功：{}",JSON.toJSONString(order));
    return order;
}
@RequestMapping("/order/message")
public String message(){
    return "高并发环境下的测试";
}

}

   -  application.yaml文件配置tomcat高并发数 
```yaml
server:
  port: 8091
  tomcat:
    max-threads: 10

• 使用工具进行压力测试
  • 下载
    • 下载地址https://jmeter.apache.org/
  • 安装并启动
    • 进入bin目录,修改jmeter.properties文件中的语言支持为language=zh_CN，然后点击jmeter.bat 启动软件
    • 双击Jemter.bat启动
  • 添加线程组
  • 配置线程并发数
  • 添加http取样
  • 开启查看结果树
  • 配置取样并启动
• 总结
  • 当并发启动后， 由于order方法囤积了大量请求, 导致ｍessage方法的访问出现了问题，这就是服务雪崩的雏形

2、雪崩效应

2.1、雪崩效应

• 在分布式系统中,由于网络原因或自身的原因,服务一般无法保证 100% 可用。如果一个服务出现了 问题，调用这个服务就会出现线程阻塞的情况，此时若有大量的请求涌入，就会出现多条线程阻塞等 待，进而导致服务瘫痪。
• 由于服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是 服务故障的 “雪崩效应” 。
• 雪崩发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某 台机器的资源耗尽。
• 无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问 题，不会影响到其它服务的正常运行。也就是＂雪落而不雪崩＂。

2.2、容错策略

• 要防止雪崩的扩散，就要做好服务的容错，容错说白了就是保护自己不被猪队友拖垮的一些措施，在Springcoud中有对应的组件可以解决
• 常见的容错思路有隔离、超时、限流、熔断、降级这几种
• 隔离
  • 它是指将系统按照一定的原则划分为若干个服务模块，各个模块之间相对独立，无强依赖。
  • 当有故 障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不波及其它模块，不影响整体的系统服务。
  • 常见的隔离方式有：线程池隔离和信号量隔离
• 超时
  • 在上游服务调用下游服务的时候，设置一个最大响应时间，如果超过这个时间，下游未作出反应， 就断开请求，释放掉线程。
• 限流
  • 限流就是限制系统的输入和输出流量已达到保护系统的目的。为了保证系统的稳固运行,一旦达到 的需要限制的阈值,就需要限制流量并采取少量措施以完成限制流量的目的。
• 熔断
  • 熔断 在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整 体的可用性，可以暂时切断对下游服务的调用。这种牺牲局部，保全整体的措施就叫做熔断。
  • 服务熔断一般有三种状态：
    • 熔断关闭状态（Closed）
      服务没有故障时，熔断器所处的状态，对调用方的调用不做任何限制
    • 熔断开启状态（Open）
      后续对该服务接口的调用不再经过网络，直接执行本地的fallback方法
    • 半熔断状态（Half-Open）
      尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率。
      如果成功率达到预 期，则说明服务已恢复，进入熔断关闭状态。
      如果成功率仍旧很低，则重新进入熔断关闭状 态。
• 降级
  • 降级其实就是为服务提供一个托底方案，一旦服务无法正常调用，就使用托底方案。

2.3、容错组件

• Sentinel
  • Sentinel 是阿里巴巴开源的一款断路器实现，本身在阿里内部已经被大规模采用，非常稳定
• Hystrix
  • Hystrix是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止 级联失败，从而提升系统的可用性与容错性。
• Resilience4J
  • Resilicence4J一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推 荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也支持和 prometheus等多款主流产品进行整合。
• 容错组件对比
  

3.2.2、Sentinel入门

1、Sentinel == ?

• Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的综合性解决方案。它以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。
• Sentinel 的特征:
  • 丰富的应用场景：
    Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景， 例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
  • 完备的实时监控：

Sentinel 提供了实时的监控功能。通过控制台可以看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。

• 广泛的开源生态：

Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。只需要引入相应的依赖并进行简单的配置即可快速地接入Sentinel。

• 完善的SPI扩展点：
  Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。
• Sentinel 分为两个部分:
  核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。 控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。
• Sentinel 分为两个部分:
  • 核心库（Java 客户端）
    不依赖任何框架/库,能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
  • 控制台（Dashboard）

基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等 应用容器。

2、Sentinel概念与功能

2.1、基础概念

• 资源
  • 资源就是Sentinel要保护的东西，资源是 Sentinel 的关键概念。
  • 资源可以是 Java 应用程序中的任何内容，可以是一个服务，也可以是 一个方法，甚至可以是一段代码
  • 案例中的message1方法就可以认为是一个资源
• 规则
  • 规则就是用来定义如何进行保护资源的
  • 作用在资源之上， 定义以什么样的方式保护资源，主要包括流量控制规则、熔断降级规则以及系统保护规则
  • 门案例中就是为message1资源设置了一种流控规则，限制了进入message1的流量

2.2、重要功能

![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808152125345.png#crop=0&crop=0&crop=1&crop=1&id=DyuMG&originHeight=309&originWidth=714&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)

• Sentinel的主要功能就是容错

  • 流量控制
    • 流量控制在网络传输中是一个常用的概念，它用于调整网络包的数据。
    • 任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。
    • 需要根据系统的处理能力对流量进行控制。
    • Sentinel作为一个调配器，可以根据需要把随机的请求调整成合适的形状。

  • 熔断降级

    • 当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则 对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。
    • Sentinel 对这个问题采取了两种手段:
    • 通过并发线程数进行限制
      Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。当某个资源 出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的 线程完成任务后才开始继续接收请求。

    • 通过响应时间对资源进行降级

      除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。 当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的 时间窗口之后才重新恢复。

    • Sentinel 和 Hystrix的区别

      • 两者的原则是一致的, 都是当一个资源出现问题时, 让其快速失败, 不要波及到其它服务 但是在限制的手段上, 确采取了完全不一样的方法:
        • Hystrix 采用的是线程池隔离的方式, 优点是做到了资源之间的隔离, 缺点是增加了线程切换的成本。
        • Sentinel 采用的是通过并发线程的数量和响应时间来对资源做限制。
  • 系统负载保护
    • Sentinel 同时提供系统维度的自适应保护能力。
    • 当系统负载较高的时候，如果还持续让 请求进入可能会导致系统崩溃，无法响应。
    • 在集群环境下，会把本应这台机器承载的流量转发到其它的机器上去。这个时候其它的机器也处在一个边缘状态的时候，Sentinel 提供了对应的保 护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求。
    • 总之需要手动做的事情，就是在Sentinel的资源上配置各种各样的规则，来实现各种容错的功能

3、微服务集成Sentinel

• 为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可
  

  3.1、在对应的微服务文件pom.xml中添加依赖

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

  
  3.2、编写controller类

4、安装Sentinel控制台

4.1、下载jar包资源

• Sentinel 提供一个轻量级的控制台, 它提供机器发现、单机资源实时监控以及规则管理等功能。
• 下载地址： https://github.com/alibaba/Sentinel/releases

4.2、启动控制台

# 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目)
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.7.0.jar
java -Dserver.port=8718 -Dcsp.sentinel.dashboard.server=localhost:8718 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.7.0.jar

4.3、修改shop_order并加入控制台配置

spring:
    cloud:
        sentinel:
            transport:
                port: 9999 #跟控制台交流的端口,随意指定一个未使用的端口即可
                dashboard: localhost:8080 # 指定控制台服务的地址

4.4、访问控制台

• 访问网址：localhost:8080/192.168.137.1:8080
• 用户名/密码：sentinel/sentinel

4.5、补充

• Sentinel的控制台其实就是一个SpringBoot编写的程序。
• 需要将自定义的微服务程序注册到控制台上，即在微服务中指定控制台的地址，并且还要开启一个跟控制台传递数据的端口，控制台也可以通过此端口 调用微服务中的监控程序获取微服务的各种信息。

5、实现一个接口限流

5.1、在控制台中为message1添加流控规则

• 以QPS类型进行限制，每秒访问刷新次数为2

5.2、通过控制台快速频繁访问, 观察效果

3.2.3、Sentinel规则

1、流控规则

• 流量控制，其原理是监控应用流量的QPS(每秒查询率) 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。
• 点击簇点链路，我们就可以看到访问过的接口地址，然后点击对应的流控按钮，进入流控规则配置页面。
• 资源名：唯一名称，默认是请求路径，可自定义
• 针对来源：指定对哪个微服务进行限流，默认指default，意思是不区分来源，全部限制
• 阈值类型/单机阈值：
  • QPS（每秒请求数量）: 当调用该接口的QPS达到阈值的时候，进行限流
  • 线程数：当调用该接口的线程数达到阈值的时候，进行限流
• 是否集群：暂不需要集群

1.1、流控配置

• 做一个基础配置，设置阈值类型为QPS，单机阈值为3，也就是请求大于3的时候就开始限流

• 访问设置网址及端口，查看响应效果，当QPS > 3时，服务就不能正常响应，返回Blocked by Sentinel (flow limiting)

1.2、配置流控模式

• 在编辑中点击高级选项，可以查看流控模式
• 流控模式
  • 直接（默认）：接口达到限流条件时，开启限流
    直接流控模式是最简单的模式，当指定的接口达到限流条件时开启限流。上面案例使用的就是直接流控模式
  • 关联：当关联的资源达到限流条件时，开启限流 [适合做应用让步]
    关联流控模式指的是，当指定接口关联的接口达到限流条件时，开启对指定接口开启限流
    • 配置限流规则, 将流控模式设置为关联，关联资源设置为/order/message2
    • 通过JMeter向/order/message2连续发送请求，注意QPS一定要大于3
      
    • 访问/order/message1，会发现已经被限流
  • 链路：当从某个接口过来的资源达到限流条件时，开启限流
    链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项
    区别在于：针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细
    • 新增service，在里面添加一个方法message

      @Service
      public class OrderServiceImpl3 {
      @SentinelResource("message")
      public void message() {
             System.out.println("message");
      }
      }

  -  在Controller中声明两个方法，分别调用service中的方法message1/2 

@RestController
@Slf4j
public class OrderController3 {
      @Autowired
        private OrderServiceImpl3 orderServiceImpl3;
        @RequestMapping("/order/message1")
        public String message1() {
                orderServiceImpl3.message();
                return "message1";
        }
        @RequestMapping("/order/message2")
        public String message2() {
                orderServiceImpl3.message();
                return "message2";
        }
}

  -  禁止收敛URL的入口 context 

  -  暂时将SpringCloud Alibaba的版本调整为2.1.1.RELEASE 

<spring-cloud-alibaba.version>2.1.1.RELEASE</spring-cloud-alibaba.version>

  -  配置文件中关闭sentinel的CommonFilter实例化 

spring:
        cloud:
            sentinel:
                filter:
                    enabled: false

  -  ) 添加一个配置类，自己构建CommonFilter实例 

package com.itheima.config;
import com.alibaba.csp.sentinel.adapter.servlet.CommonFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class FilterContextConfig {
  @Bean
    public FilterRegistrationBean sentinelFilterRegistration() {
            FilterRegistrationBean registration = new FilterRegistrationBean();                    
            registration.setFilter(new CommonFilter());
            registration.addUrlPatterns("/*");
            // 入口资源关闭聚合
            registration.addInitParameter(CommonFilter.WEB_CONTEXT_UNIFY, "false");
            registration.setName("sentinelFilter");
            registration.setOrder(1);
            return registration;
    }
}

  -  控制台配置限流规则 ![](https://gitee.com/hg14150/blogiamges/raw/master/img/image-20210808224110621.png#crop=0&crop=0&crop=1&crop=1&id=CBlO3&originHeight=383&originWidth=740&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=) 
  -  分别通过 /order/message1 和 /order/message2 访问, 发现2没问题, 1的被限流了 

1.3、流控效果

• 快速失败（默认）: 直接失败，抛出异常，不做任何额外的处理，是最简单的效果
• Warm Up：它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的 1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。
• 排队等待：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待， 它还会设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃。

2、降级规则

2.1、规则说明

• 降级规则就是设置当满足什么条件的时候，对服务进行降级。
• Sentinel提供了三个衡量条件：
  • 平均响应时间 ：当资源的平均响应时间超过阈值（以 ms 为单位）之后，资源进入准降级状态。 当接下来 1s 内持续进入 5 个请求，它们的 RT都持续超过这个阈值，在接下的时间窗口 （以 s 为单位）之内，就会对这个方法进行服务降级。
  • 异常比例：当资源每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，在接下的时间窗口（以 s 为单位）之内，对这个方法的调用都会自动地返回，异常比率的阈值范围是 [0.0, 1.0]。
  • 异常数 ：当资源近 1 分钟的异常数目超过阈值之后会进行服务降级， 统计时间窗口是分钟级别的，若时间窗口小于 60s，则结束熔断状态后仍可能再进入熔断状态。

2.2、场景模拟

• 平均响应时间
• 异常比例
  • 首先模拟一个异常

    int i = 0;
    @RequestMapping("/order/message2")
    public String message2() {
      i++;
      //异常比例为0.333
      if (i % 3 == 0){
              throw new RuntimeException();
      }
      return "message2";
    }

• 设置异常比例为0.25

• 异常数

3、热点规则

• 热点参数流控规则是一种更细粒度的流控规则, 它允许将规则具体到参数上。
• 热点规则简单使用
  • 编写代码

    @RequestMapping("/order/message3")
    @SentinelResource("message3")//注意这里必须使用这个注解标识,热点规则不生效
    public String message3(String name, Integer age) {
          return name + age;
    }

• 配置热点规则
• 分别用两个参数访问,会发现只对第一个参数限流了
  • 热点规则增强使用
• 参数例外项允许对一个参数的具体值进行流控编辑定义的规则，增加参数例外项

4、授权规则

• 在很多场景下，需要要根据调用来源判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源访问控制的功能。
• 当多路请求同时访问，可以对访问来源做简单判断，然后对其进行放行，达到安全访问的效果
• 来源访问控制根据资源的请求来源（origin）限制资源是否通过：
  • 若配置白名单，则只有请求来源位于白名单内时才可通过；
  • 若配置黑名单，则请求来源位于黑名单时不通过，其余的请求通过
• 流控应用的填写
  • Sentinel提供了 RequestOriginParser 接口来处理来源
  • 只要Sentinel保护的接口资源被访问，Sentinel就会调用 RequestOriginParser 的实现类去解析 访问来源。
• 自定义来源处理规则

  @Component
  public class RequestOriginParserDefinition implements RequestOriginParser{
       @Override
       public String parseOrigin(HttpServletRequest request) {
                       String serviceName = request.getParameter("serviceName");
                       return serviceName;
       }
  }

• 授权规则设置
• 访问地址： http://localhost:8091/order/message1?serviceName=pc 观察结果

5、系统规则

• 系统保护规则是从应用级别的入口流量进行控制，从单台机器的总体 Load、RT、入口 QPS 、CPU 使用率和线程数五个维度监控应用数据，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
• 系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量 (进入应用的流量) 生效
• Load（仅对 Linux/Unix-like 机器生效）：
  • 当系统 load1（1分钟加载） 超过阈值，且系统当前的并发线程数超过 系统容量时才会触发系统保护。
  • 系统容量由系统的 maxQps minRt 计算得出，设定参考值一般 是 CPU cores 2.5。
• RT：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
• 线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
• 入口 QPS：当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。
• CPU使用率：当单台机器上所有入口流量的 CPU使用率达到阈值即触发系统保护

3.2.4、规则定义使用及持久化

1、自定义异常返回

//异常处理页面
@Component
public class ExceptionHandlerPage implements UrlBlockHandler {
        // BlockException 异常接口,包含Sentinel的五个异常
        // FlowException 限流异常
        // DegradeException 降级异常
        // ParamFlowException 参数限流异常
        // AuthorityException 授权异常
        // SystemBlockException 系统负载异常
        @Override
        public void blocked(HttpServletRequest request, HttpServletResponse
response, BlockException e) throws IOException {
      response.setContentType("application/json;charset=utf-8");
      ResponseData data = null;
      if (e instanceof FlowException) {
          data = new ResponseData(-1, "接口被限流了...");
      } else if (e instanceof DegradeException) {
          data = new ResponseData(-2, "接口被降级了...");
      }
      response.getWriter().write(JSON.toJSONString(data));
    }
  }
  @Data
  @AllArgsConstructor//全参构造
  @NoArgsConstructor//无参构造
  class ResponseData {
      private int code;
      private String message;
  }

2、@SentinelResource注解使用

2.1、注解介绍

• 在定义了资源点之后，通过Dashboard来设置限流和降级策略来对资源点进行保护，同时还能通过@SentinelResource来指定出现异常时的处理策略

• @SentinelResource 用于定义资源，并提供可选的异常处理和 fallback 配置项
  | 属性 | 作用 | | —- | —- | | value | 资源名称 | | entryType | entry类型，标记流量的方向，取值IN/OUT，默认是OUT | | blockHandler | 处理BlockException的函数名称,函数要求：
  1. 必须是 public
  2.返回类型 参数与原方法一致
  3. 默认需和原方法在同一个类中4.
  若希望使用其他类的函数，可配置 blockHandlerClass ，并指定blockHandlerClass里面的方法。 | | blockHandlerClass | 存放blockHandler的类,对应的处理函数必须static修饰。 | | fallback | 用于在抛出异常的时候提供fallback处理逻辑。fallback函数可以针对所 有类型的异常（除了 exceptionsToIgnore 里面排除掉的异常类型）进 行处理。函数要求：
  1. 返回类型与原方法一致
  2. 参数类型需要和原方法相匹配
  3. 默认需和原方法在同一个类中
  4.若希望使用其他类的函数，可配置 fallbackClass ，并指定fallbackClass里面的方法。 | | fallbackClass | 存放fallback的类。对应的处理函数必须static修饰。 | | defaultFallback | 用于通用的 fallback 逻辑。默认fallback函数可以针对所有类型的异常进 行处理。若同时配置了 fallback 和 defaultFallback，以fallback为准。函 数要求：
  1. 返回类型与原方法一致
  2. 方法参数列表为空，或者有一个 Throwable 类型的参数。 3. 默认需要和原方法在同一个类中
  4.若希望使用其他类的函数，可配置 fallbackClass ，并指定 fallbackClass 里面的方法。 | | exceptionsToIgnore | 指定排除掉哪些异常。排除的异常不会计入异常统计，也不会进入 fallback逻辑，而是原样抛出。 | | exceptionsToTrace | 需要trace的异常 |

• 接口实现方法 ```java package com.hguo.service.impl;

import com.alibaba.csp.sentinel.annotation.SentinelResource; import com.alibaba.csp.sentinel.slots.block.BlockException; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service;

/**

• @author hguo
• @date2021/8/9 10:50
• @title 现世安稳，岁月静好，佛祖保佑，永无bug! */

@Service @Slf4j public class SentinelServiceImpl {

@SentinelResource(
        value = "message",
        //指定发生BlockException时进入的方法
        blockHandler = "blockHandler",
        //指定发生Throwable时进入的方法
        fallback = "fallback"
)
public String message(String name) {
    return "message";
}
//BlockException时进入的方法
public String blockHandler(String name,BlockException ex) {
    log.error("触发异常BlockException", ex);
    return "接口被限流或者降级了...";
}
//Throwable时进入的方法
public String fallback(String name,Throwable throwable) {
    log.error("触发异常Throwable", throwable);
    return "接口发生异常了...";
}

}

-  Ordercontroller请求编写 
```java
package com.hguo.controller;
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.hguo.service.impl.SentinelServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
 * @author hguo
 * @date2021/8/8 18:35
 * @title 现世安稳，岁月静好，佛祖保佑，永无bug!
 */
@RestController
@Slf4j
public class OrderControllerTest2 {
    @Autowired
    private SentinelServiceImpl sentinelService
    @RequestMapping("/order/message2")
    public String message2() {
        return "message2";
    }
}

2.2、限流方法一

• 直接将限流和降级方法定义在方法中

  @Service
  @Slf4j
  public class SentinelServiceImpl {
       int i = 0;
       @SentinelResource(
                       value = "message",
            //指定发生BlockException时进入的方法
                       blockHandler = "blockHandler",
            //指定发生Throwable时进入的方法
                       fallback = "fallback"
       )
       public String message() {
               i++;
               if (i % 3 == 0) {
                       throw new RuntimeException();
               }
               return "message";
       }
       //BlockException时进入的方法
       public String blockHandler(BlockException ex) {
               log.error("{}", ex);
               return "接口被限流或者降级了...";
       }
       //Throwable时进入的方法
       public String fallback(Throwable throwable) {
               log.error("{}", throwable);
               return "接口发生异常了...";
       }
  }