首页 > 编程语言 > 详细

SpringCloud-Alibaba

时间：2021-07-26 22:30:38      阅读：24      评论：0      收藏：0      [点我收藏+]

SpringCloud-Alibaba

概述

Spring Cloud Alibaba致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件，方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。

依托 Spring Cloud Alibaba，您只需要添加一些注解和少量配置，就可以将 Spring Cloud 应用接入阿里微服务解决方案，通过阿里中间件来迅速搭建分布式应用系统。

简单来说：就是在以前的微服务搭建中，如果使用SpringCloudAlibaba，来替代以前的某些产品，那么开发SpringCloud应用会变得更加简单。

主要功能

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

主要组件

Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

RocketMQ：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。

Dubbo：Apache Dubbo? 是一款高性能 Java RPC 框架。

Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。

Alibaba Cloud OSS: 阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。

Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。

Alibaba Cloud SMS: 覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

如何使用

只需要在SpringCloud的父项目中引入以下依赖即可

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

在接下来的子项目中根据需求添加依赖即可

Nacos

概述

Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。

Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施。

简单来说：Nacos就是注册中心+配置中心的组合，就是利用Nacos来代替之前学习的Eureka来做注册中心，代替SpringCloudConfig来做配置中心。

Nacos中文文档：https://nacos.io/zh-cn/docs/what-is-nacos.html

各大注册中心的比较

技术分享图片

CAP原则：指的是在一个分布式系统中，一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）。CAP 原则指的是，这三个要素最多只能同时实现两点，不可能三者兼顾。P原则是必须满足的，即自能又两种原则 CP或者 AP

CP原则：放弃了系统的高可用性，但保证了数据准确唯一

AP原则：维护了系统的高可用，但是得到的数据可能有缺陷，不唯一。

由上图可知Nacos同时支持了CP或者AP原则，对于两个原则，它是可变的，我们只需要启动发送一个命令即可切换（默认是AP）

curl -X PUT ‘nacos服务ip或者主机域名:8848/nacos/v1/ns/operator/switches?entry=serverMode&value=CP‘

CP和AP切换原则：

一般来说：

如果不需要存储服务级别的信息且服务实例是通过nacos-client注册，并能够保持心跳上报，那么就可以选择AP模式。当前主流的服务如Spring cloud和Dubbo服务 ,都适用于AP模式，AP模式为了服务的可用性而减弱了一致性，因此AP模式下只支持注册临时实例。

如果需要在服务级别编辑或者存储配置信息，那么CP是必须的，K8S服务和DNS服务则适用于CP模式
CP模式下则支持注册持久化实例，此时则是以Raft协议为集群运行模式，该模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。

Nacos下载

所有版本下载地址：https://github.com/alibaba/nacos/releases

Nacos-server2.0.1-windows版本下载地址：https://github.com/alibaba/nacos/releases/download/2.0.1/nacos-server-2.0.1.zip

Nacos-server2.0.1-linux版本下载地址：https://github.com/alibaba/nacos/releases/download/2.0.1/nacos-server-2.0.1.tar.gz

Nacos-server1.4.2-windows版本下载地址：https://github.com/alibaba/nacos/releases/download/1.4.2/nacos-server-1.4.2.zip

Nacos-server1.4.2-linux版本下载地址：https://github.com/alibaba/nacos/releases/download/1.4.2/nacos-server-1.4.2.tar.gz

安装与启动

安装：将下载的压缩包解压即可

启动：

  1. 修改解压目录的nacos下的config目录下的 application.yaml，将数据库的注释打开，如下

    技术分享图片

  2. 根据配置文件中的数据库名称建立数据库，默认叫nacos，linux有所不同，字符编码utf8 ，排序规则utf8_general_ci

  3. 将解压目录的nacos下的config目录下的nacos-mysql.sql的数据库脚本放到建立的数据中执行。

  4. 在nacos启动目录下的bin目录下，修改配置文件windows修改startup.cmd，linux修改startup.sh

    # windows 将文件中的 set MODE="cluster" 改为 set MODE="standalone"
# linux 将文件中的 export MODE="cluster" 改为 export MODE="standalone"

  5. 执行启动文件windows 启动startup.cmd linux启动 startup.sh

    然后访问：http://localhost:8848/nacos/，出现如下界面启动成功

    技术分享图片

注意

默认登录用户名和密码都是 nacos

服务注册与发现

微服务父项目搭建参考：https://www.cnblogs.com/Rampant/p/14770855.html

微服务提供者的注册

  1. 创建新模块 nacos-provider-9001

  2. 导入pom.xml依赖

    <dependencies>

    <!--Nacos 服务注册的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--spring-boot-web 模块 常用的3个-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--测试插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok 依赖-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

  3. 配置application.yaml

    server:
  port: 9001  # 端口号

spring:
  application:
    name: cloud-alibaba-provider  # 微服务名称

  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # 连接的注册中心

management:
  endpoints:
    web:
      exposure:
        include: ‘*‘    #暴露端口

  4. 主启动类

    package com.wyx.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@SpringBootApplication
@EnableDiscoveryClient
public class NacosProviderMain9001 {

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

  5. 业务类

    package com.wyx.cloud.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ProviderController {

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/provider/{id}")
    public String provider(@PathVariable String id){
        return "使用Nacos服务注册中心，当前服务端口： "+serverPort+"\t"+"查询参数："+id;
    }
}

    启动测试，访问：http://localhost:9001/provider/1

  6. 为了实现后面的负载均衡，我们在用相同的步骤搭建一个9002端口的服务

微服务消费者的注册

  1. 创建模块nacos-consumer-80

  2. 添加依赖

    <dependencies>

    <!--Nacos 服务注册的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--spring-boot-web 模块 常用的3个-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--测试插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok 依赖-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

  3. 修改yaml

    server:
  port: 80  # 端口号

spring:
  application:
    name: cloud-alibaba-consumer  # 微服务名称

  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # 连接的注册中心


service-url:
  nacos-service: http://cloud-alibaba-provider #将微服务提供者的名字放入配置文件，后面读取即可

  4. 主启动类

    package com.wyx.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

  5. 业务类

    RestTemplate注入

    package com.wyx.cloud.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

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

    服务调用

    package com.wyx.cloud.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
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 javax.annotation.Resource;

@RestController
public class ConsumerController {

    @Value("${service-url.nacos-service}")
    private String serviceUrl;

    @Resource
    RestTemplate restTemplate;

    @GetMapping("/consumer/{id}")
    public String getConsumer(@PathVariable String id){
        return restTemplate.getForObject(serviceUrl+"/provider/"+id,String.class);
    }
}

负载均衡

概述

对于Nacos服务注册中心，天生集成了 ribbon做负载均衡，

使用Ribbon做负载均衡，就是它默认给我们写了很多负载均衡类

1、随机策略——RandomRule

2、轮询策略——RoundRobinRule
注：Ribbon默认策略

3、重试策略——RetryRule

4、最低并发策略——BestAvailableRule

5、可用过滤策略——AvailabilityFilteringRule
过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的的后端server（active connections 超过配置的阈值）

性能仅次于最低并发策略。

6、响应时间加权策略——WeightedResponseTimeRule
每隔30秒计算一次服务器响应时间，以响应时间作为权重，响应时间越短的服务器被选中的概率越大。

7、区域权衡策略——ZoneAvoidanceRule

Ribbon的负载均衡策略使用建议
一般情况下，推荐使用最低并发策略，这个性能比默认的轮询策略高很多。

负载均衡替换

  1. 编写配置类

    // 编写一个类注入负载均衡算法类，该类必须不能让springboot扫描到，不能放在同级，或者子包下面,必须放在其它地方
@Configuration
public class RibbonConfiguration {
  @Bean
  public IRule ribbonRule() {
    // 负载均衡规则，改为随机,可以new的类，参考上面提供的类名，官方写好的的类，也可以自定义负载均衡类
    return new RandomRule();
  }
}

  2. 在RestTemplate注入配置类添加注解

    package com.wyx.cloud.config;

import com.wyx.loadbalance.RibbonConfiguration;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.ribbon.RibbonClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

// name 是微服务的应用名
@Configuration
@RibbonClient(name = "cloud-alibaba-provider", configuration = RibbonConfiguration.class)
public class RestTemplateConfig {

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

  3. 其他配置不修改，启动即可。

  4. 当然如果对提供的负载均衡算法，不满意，也可以自定义负载均衡算法，只需要编写一个类，实现IRule接口即可。

配置中心的使用

项目创建

  1. 创建新模块nacos-config-3344

  2. 导入 pom.xml

    <dependencies>

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

    <!--这个依赖，看版本来修改版本是20版之后的最好导入，因为在版后默认剔除了，不导入启动项目会出错-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-bootstrap</artifactId>
    </dependency>

    <!--Nacos 服务注册的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--spring-boot-web 模块 常用的3个-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--测试插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok 依赖-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

  3. 添加application.yaml、bootstrap.yml

    # application.yml
server:
  port: 3344

spring:
  profiles:
    active: dev

    # bootstrap.yml
spring:
  application:
    name: nacos-config-client
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #服务注册中心地址
      config:
        server-addr: localhost:8848 #配置中心地址
        file-extension: yaml #指定文件后缀名，切记配置中心的后缀，必须一样，不能一个是yml 一个是yaml

  4. 主启动类

    package com.wyx.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

  5. 业务类

    package com.wyx.cloud.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RefreshScope	//动态刷新功能，nacos修改后，不需要在发送什么命令，直接会自动刷新
public class ConfigClientController {

    @Value("${config.info}")
    private String configInfo;

    @GetMapping("/config/info")
    public String getConfigInfo() {
        return configInfo;
    }
}

在配置中心准备配置的文件

文件名要求规则如下（dataId）即为文件名

在 Nacos Spring Cloud 中，dataId 的完整格式如下：

${prefix}-${spring.profiles.active}.${file-extension}
  • prefix 默认为 spring.application.name 的值，也可以通过配置项 spring.cloud.nacos.config.prefix来配置。
  • spring.profiles.active 即为当前环境对应的 profile，详情可以参考 Spring Boot文档。 注意：当 spring.profiles.active 为空时，对应的连接符 - 也将不存在，dataId 的拼接格式变成 ${prefix}.${file-extension}
  • file-exetension 为配置内容的数据格式，可以通过配置项 spring.cloud.nacos.config.file-extension 来配置。目前只支持 properties 和 yaml 类型。

由文件命名规则可知，我们该项目的配置文件命令为：nacos-config-client-dev.yml

添加配置文件如下图

技术分享图片

技术分享图片

启动项目测试即可：访问，http://localhost:3344/config/info

在修改配置文件后继续访问，发现是动态刷新的，不在像 springcloud-config 一样需要实时的刷新配置。

多环境多项目管理

对于SpringCloud-config一般情况下都是通过修改文件名字来实现生产环境，测试环境的使用，但是在Nacos中，利用了Java的包名类名管理思想。

它存在三级管理配置文件的功能，具体来说就是命名空间 + GROUP + Data ID，三者之间的关系命名空间 > GROUP > Data ID，

命名空间的使用

下面我们来看一下如何创建命令空间

技术分享图片

技术分享图片

我们可以通过修改application.yaml来获取我们的命名空间，如下

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #服务注册中心地址
      config:
        server-addr: localhost:8848 #配置中心地址
        file-extension: yaml #指定文件后缀名，切记配置中心的后缀，必须一样，不能一个是yml 一个是yaml
        namespace: f50332a2-9b31-479c-9111-102c125d97d7 # 这个数字是刚刚创建时自动生成的命名空间ID
组的使用

在新建配置的时候可以自定义组名

技术分享图片

我们在配置中如何配置组

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #服务注册中心地址
      config:
        server-addr: localhost:8848 #配置中心地址
        file-extension: yaml #指定文件后缀名，切记配置中心的后缀，必须一样，不能一个是yml 一个是yaml
        namespace: f50332a2-9b31-479c-9111-102c125d97d7 # 这个数字是刚刚创建时自动生成的命名空间ID
        group: DEV_GROUP	# 指定组名
Data ID的使用

Data ID就是一个对应文件名的配置，上面已经解释过了。

Nacos集群配置

架构部署

官方集群架构部署图

技术分享图片

可能开起来不是很理解，下面是根据官网修改后的集群部署图：

技术分享图片

简单来说：

  1. 就是我们访问一个域名，给我们解析成为一个虚拟IP。
  2. 虚拟IP映射到对应的Nginx服务器。
  3. 在由Nginx服务器反向代理到我们的需要正规访问的Nacos。
  4. Nacos的一些操作（比如保持配置文件）在将其持久化到我们的高可用的MySQL数据库。

持久化配置

默认Nacos使用的是内嵌式数据库实现数据存储（derby）。如果采用集群配置，每个Nacos节点都有自己的配置，就会存在数据一致性的问题。为了解决这个问题，Nacos采用了集中式存储方式来支持集群化部署（目前只支持MySQL）。

切换默认的数据源

  1. 创建数据库nacos_devtest，字符编码utf8 ，排序规则utf8_general_ci

  2. 将在安装nacos的目录下的conf下的nacos-mysql.sql文件复制到自己刚刚创建的数据库中执行SQL命令

  3. 修改在安装nacos的目录下的conf下的application.properties文件，添加如下配置

    #使用的数据源
spring.datasource.platform=mysql	
# 数据库的数量
db.num=1	

#连接的URL注意数据库名称
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos_devtest?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
#用户名
db.user.0=root	
#密码
db.password.0=970699

重新启动即可。

特别注意，数据库的名字不能改变，必须使用 nacos_devtest否则不能用

MySQL 8.0，需要加上时区配置。

开始配置

环境准备

  1. 环境准备（3台虚拟机+阿里云服务器一台）

    环境说明，由于服务器不够所以这里数据库就不集群了。其他的都集群配置

    master	192.168.137.129
slave1	192.168.137.130
slave2	192.168.137.131
阿里云服务器	47.97.218.81

  2. 三台虚拟机上都先安装JDK，教程很多不在说明

    准备Nginx安装包，Nacos安装包

    下载地址：

    Nginx（1.20.0版本）：http://nginx.org/download/nginx-1.20.0.tar.gz

    Nacos（nacos-server2.0.1版本）：https://github.com/alibaba/nacos/releases/download/2.0.1/nacos-server-2.0.1.tar.gz

    并将 Nginx和Nacos放到三台虚拟机上

Nacos集群安装

说明以下，这里三台服务器的Nacos安装教程都一样，只对一台讲解

  1. 解压配置上传的压缩包

    # 我是安装在 /opt目录下
[root@localhost opt]# pwd
/opt
[root@localhost opt]# tar -xzvf nacos-server-2.0.1.tar.gz

  2. 配置MySQL数据源（我选用的是阿里云的服务器来配置数据源，如果条件不允许，可以自己用虚拟机来装MySQL也可以）

    首先：查看数据库配置文件在解压目录下的nacos 下的 conf目录下的数据库名称

    [root@localhost opt]# vim /opt/nacos/conf/nacos-mysql.sql

    技术分享图片

    使用navicat连接我的阿里云服务器的数据库建立数据库名为nacos_config，字符集为 utf8，排序规则为utf8_general_ci

    将刚刚我们查看的nacos-mysql.sql脚本，拿到navicat中运行数据库脚本。具体简单，不在操作。

  3. 配置nacos目录下的conf目录下的application.properties文件

    # 首先将文件备份，防止修改错
[root@localhost conf]# cp application.properties application.properties.bk
# 修改文件
[root@localhost conf]# vim application.properties

    在文件最后配置数据源的位置，就是在文件最后添加如下内容

    #使用的数据源
spring.datasource.platform=mysql	
# 数据库的数量
db.num=1	

#连接的URL注意数据库名称,及其数据源的位置IP
db.url.0=jdbc:mysql://xxx.xxx.xxx.xxx:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=UTC
#用户名
db.user.0=root	
#密码
db.password.0=970699

  4. 配置集群文件

    # j将集群文件先复制一份，并改名为 cluster.conf
[root@localhost conf]# cp cluster.conf.example cluster.conf
# 编辑 cluster.conf
[root@localhost conf]# vim cluster.conf

    技术分享图片

    上面修改的这个文件 3个服务器上都需要配置

    在三台服务器上都启动nacos

    # 启动命令，三台都要启动
[root@localhost conf]# sh /opt/nacos/bin/startup.sh 
# 关闭防火墙，如果是阿里云服务器建议开启端口，并配置安全组规则不要关闭防火墙
systemctl stop firewalld.service
# 查看防火墙状态
firewall-cmd --state

    访问：http://192.168.100.129:8848/nacos/

    注意：启动实在太慢了，需要多等一会。我3G的运行内存启动差不多花了3分钟，这里可能是网络原因。所以记得等，如果等不了，使用如下命令查看启动日志

    1G内存启动花了6分钟左右

    # 默认就是安装目录下的logs下的start.out
[root@localhost bin]# vim /opt/nacos/logs/start.out

    看到出现如下信息才算启动成功，看服务器配置启动时间。

    技术分享图片

全部启动成功后可以查看节点状态

技术分享图片

Nginx集群接入

  1. 两台服务器安装Nginx

    安装教程参考：Nginx安装教程

  2. 这里使用192.168.100.129和192.168.100.130来搭建Nginx

    安装完成后测试访问没有问题后开始搭建

    搭建过程如果看不到可以参考这里：https://www.cnblogs.com/Rampant/p/14785179.html 的反向代理模式中的负载均衡，和Nginx高可用两个部分

  3. 修改Nginx启动配置文件

    # 编辑配置文件 
[root@localhost conf]# vim /usr/local/nginx/conf/nginx.conf

    编辑后如下

    技术分享图片

        upstream nacoscluster{
         server 192.168.100.129:8848;
         server 192.168.100.130:8848;
         server 192.168.100.131:8848;
        }
    server {
        listen     5000;
        server_name  192.168.137.129;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
           # root   html;
           # index  index.html index.htm;
           proxy_pass http://nacoscluster
        }

    另外一台也做配置

        upstream nacoscluster{
         server 192.168.100.129:8848;
         server 192.168.100.130:8848;
         server 192.168.100.131:8848;
        }
    server {
        listen     5000;
        # 只需要这里的IP是本机IP,其他不变
        server_name  192.168.137.130;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
           # root   html;
           # index  index.html index.htm;
           proxy_pass http://nacoscluster
        }

Nginx高可用接入

参考：Nginx高可用搭建

安装 keeplived

# 安装命令
yum install keepalived

编辑配置文件

# 进入配置文件目录
cd /etc/keepalived/
# 编辑配置文件
vim keepalived.conf 

! Configuration File for keepalived
## 两台服务器都要配置
global_defs {

   notification_email { # keepalived服务宕机异常出现的时候，发送通知邮件 可以是多个

     acassen@firewall.loc  #  收件人邮箱1

     failover@firewall.loc #  收件人邮箱2

     sysadmin@firewall.loc #  收件人邮箱3

   }

   notification_email_from Alexandre.Cassen@firewall.loc  #邮件发件人

   smtp_server 192.168.200.1  # 邮件服务器地址

   smtp_connect_timeout 30   # 超时时间

   router_id LVS_DEVEL   # 机器标识 局域网内唯一即可

   vrrp_skip_check_adv_addr # 默认是不跳过检查。检查收到的VRRP通告中的所有地址可能会比较耗时，设置此命令的意思是，如果通告与接收的上一个通告来自相同的master路由器，则不执行检查(跳过检查)。

   #vrrp_strict   # 严格遵守VRRP协议。下列情况将会阻止启动Keepalived：1. 没有VIP地址。2. 单播邻居。3. 在VRRP版本2中有IPv6地址。

   vrrp_garp_interval 0  # 小数类型，单位秒，在一个网卡上每组gratuitous arp消息之间的延迟时间，默认为0，一个发送的消息=n组 arp报文

   vrrp_gna_interval 0 # 小数类型，单位秒， 在一个网卡上每组na消息之间的延迟时间，默认为0

}

# 检测 nginx 的活动状态
vrrp_script chk_http_port{
	# 检测脚本路径
        script "/etc/keepalived/nginx_chech.sh"  

        interval 2

        weight 2
}

 

# vrrp实例  我们集群设置 多机配置，除了state和priority不一样，其他都一样
vrrp_instance VI_1 {

    state MASTER  # 服务器状态 MASTER是主服务器  BACKUP是备份服务器 主服务器的priority要比备份服务器大

    interface ens33 # 通信端口 通过ip addr可以看到 根据自己的机器配置

    virtual_router_id 51  # vrrp实例id  keepalived集群，实例id必须一致

    priority 100  # 权重比 主服务器的priority要比备份服务器大

    advert_int 1  # 心跳间隔  单位秒  keepalived多机器集群 通过心跳检测，如果发送心跳没反应 就立刻接管；

    authentication { # 服务器之间通信密码

        auth_type PASS

        auth_pass 1111

    }

    virtual_ipaddress { # 自定义虚拟IP 
		# 虚拟IP池，要求必须在一个网段内，必须192.168.100开头
        192.168.100.80

    }
}

配置检测脚本

#!/bin/bash
A=`ps -C nginx -no-header | wc -l`
if [$A -eq 0 ];then
        /usr/local/neginx/sbin/nginx
        sleep 2
        if [`PS -C nginx --no-header |wc -1` -eq 0 ]; then
                killall keepalived
        fi  
fi

访问：192.168.100.80:5000/nacos/测试，当主服务器192.168.100.129宕机后，测试访问依然成功，搭建完成。

Sentinel

概述

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

简单来说：它是一个轻量级的流量控制、熔断降级的Java库，就是以前学习的Hystrix的加强版。

中文官方文档：SpringCloudalibaba Sentinel中文官方文档

Sentinel 分为两个部分:

  • 核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
  • 控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

特点

  • 丰富的应用场景：Sentinel 承接了阿里巴巴近 10 年的双十一大促流量的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
  • 完备的实时监控：Sentinel 同时提供实时的监控功能。您可以在控制台中看到接入应用的单台机器秒级数据，甚至 500 台以下规模的集群的汇总运行情况。
  • 广泛的开源生态：Sentinel 提供开箱即用的与其它开源框架/库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要引入相应的依赖并进行简单的配置即可快速地接入 Sentinel。
  • 完善的 SPI 扩展点：Sentinel 提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

主要功能

技术分享图片

安装启动

  1. 下载Setinel

    下载地址（全部版本）：https://github.com/alibaba/Sentinel/releases

    1.8.2版本：https://github.com/alibaba/Sentinel/releases/download/1.8.2/sentinel-dashboard-1.8.2.jar

  2. 启动，运行下载出来的jar包就可以了

    # 运行jar包
java -jar Sentinel-dashboard-1.8.2.jar

  3. 访问：http://localhost:8080/ 如下启动成功

    登录用户和密码都是 sentinel

    技术分享图片

服务搭建

  1. 创建新模块nacos-sentinel-service-9003

  2. pom.xml

    <dependencies>
    <!--Sentinel 服务监控的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>

    <!--Nacos 服务注册的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--spring-boot-web 模块 常用的3个-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--测试插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok 依赖-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

  3. application.yaml

    server:
  port: 9003

spring:
  application:
    name: nacos-sentinel-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #注册到nacos注册中心
    sentinel:
      transport:
        dashboard: localhost:8080	#在8080d
        port: 8719  #默认8719，假如被占用了会自动从8719开始依次+1扫描。直至找到未被占用的端口

management:   #凡是涉及监控的都需要暴露端口
  endpoints:
    web:
      exposure:
        include: ‘*‘

  4. 主启动类

    package com.wyx.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

  5. 业务类

    package com.wyx.cloud.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SentinelController {

    private Integer contA=0;

    private Integer contB=0;

    @GetMapping("/getInfoA")
    public String getInfoA(){
        contA++;
        return "提供A服务次数"+contA;
    }

    @GetMapping("/getInfoB")
    public String getInfoB(){
        contB++;
        return "提供B服务次数"+contB;
    }
}

    访问 http://localhost:8080/ 查看监控信息，发现没有上面，是因为Sentinel使用懒加载模式

    只有访问服务后才会进入监控列表。

    我们访问 http://localhost:9003/getInfoA

    再次查看监控信息

    技术分享图片

仪表盘介绍

技术分享图片

实时监控

技术分享图片

显示在一段时间内对服务的每个请求的访问量，并以秒吉显示出来

簇点链路

触电链路主要有两种显示方式 树状视图和列表视图，主要功能就是显示某个服务的请求路径，并可用为其添加 流控、熔断、热点、授权等规则

技术分享图片

技术分享图片

流控规则

通过一定的规则来配置限流规则，来对服务提供一种保护作用，具体如何实现请看后面

热点规则

也是一种限流规则，具体参考后面。

系统规则

授权规则

集群流控

机器列表

技术分享图片

查看当前服务名下有多少台实例的服务。

流控规则设置

在学习流控规则前，我们先来了解几个基本概念

技术分享图片

技术分享图片

阈值类型

QPS：单位时间类的请求如果超过设定的规则就返回失败

技术分享图片

默认返回错误的页面，后期可用自定义

技术分享图片

并发线程数：给定固定线程数，如果请求大于线程数的处理范围就快速失败

技术分享图片

流控模式

直接：针对自己的流控规则，满足规则就对自己限流。这个很简单不在解释

关联：将两个资源名进行关联，当关联资源达到限流规则时，来限流与之关联的资源。

简单理解：如下图，当/getInfoB在单位时间内的访问次数超过2次以上，那么/getInfoA将会被限流

，如果是并发线程数也是一样。当两个线程数处理不过来时，那么/getInfoA限流。（适用于当支付模块处理不过来时，可以对下单模块限流）

技术分享图片

链路：在微服务调用过程中，如果入口资源调用资源名的服务，满足限流规则，则开始限流。

简单来说：假设微服务之间互相调用，那么当/getIfoB服务调用/getInfoA满足单位时间内超过2次以上触发限流

技术分享图片

流控效果

流控效果只能针对QPS模式，并发线程模式，只能时快速失败

快速失败：就是快速放回默认的错误信息如下图（可以自定义）。

技术分享图片

Warm UP（缓慢唤醒）：即预热/冷启动方式。当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。

简单理解如下：起始单机阈值是3（在源码WarmUpController类中）当请求量突然增大时，系统会自动的在5秒钟内将我们的单机阈值调到我们设定的最大值10。（使用场景：抢购东西时，避免一开始就出现系统死机的情况）

技术分享图片

等待排队：等待排队利用的原理是漏桶算法，就是对所有请求都不返回错误（在不超时的情况下，超时也会返回错误），而是将请求拿过来后，经行排队，以此处理。什么是漏桶算法

技术分享图片

熔断规则设置

熔断规则又称服务熔断：但是这里的服务熔断和Hystrix有区别，它并没有半开状态，就只有两种状态可用，不可用。

慢比例调用模式

慢比例调用：在设置的统计时间内，如果满足最小请求数，且响应时间（最大RT）大于设定值的比例高于阈值就熔断设定的时长，当过了熔断时长，若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。

下图的例子：/getInfoA请求，如果在统计时长（1秒内）内，请求次数大于4次（最小请求数），并且响应时间大于50毫秒（最大RT）的比例大于0.4（比例阈值），就会进入熔断 10秒（熔断时长）。过了熔断时长就恢复访问。熔断界面为默认的出错界面，可用修改。

技术分享图片

异常比例模式

异常比例模式：当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。

例如，表示在一秒钟内，请求次数大于5次，并且出现异常的的次数大于请求次数的百分之四十，就会开启熔断，熔断时间过了后，如果请求还是异常继续熔断，等待下一次可用。

技术分享图片

异常数模式

异常数模式：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

热点规则设置

何为热点？热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的 Top K 数据，并对其访问进行限制。比如：

  • 商品 ID 为参数，统计一段时间内最常购买的商品 ID 并进行限制
  • 用户 ID 为参数，针对一段时间内频繁访问的用户 ID 进行限制

热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参数的资源调用生效。

技术分享图片

Sentinel 利用 LRU 策略统计最近最常访问的热点参数，结合令牌桶算法来进行参数级别的流控。热点参数限流支持集群模式。

热点设置

  1. 环境准备，在业务类新加一个请求

    // 新增一个请求参数为非必须，这里只能用 SentinelResource，单独使用/hotKey是没效果的
@GetMapping("/hotKey")
@SentinelResource(value = "hotKey", blockHandler = "del_hotKet")    //定义访问的资源名，和失败后走的处理方法
public String hotKet(@RequestParam(value = "p1", required = false) String p1,
                     @RequestParam(value = "p2", required = false) String p2){
    return "热点访问成功";
}

// 失败后的处理方法
public String del_hotKet(String p1, String p2 , BlockException exception){
    return "热点新闻访问失败！????????";
}

  2. 重启，添加热点规则

    技术分享图片

    上面的规则代表当访问/hotKey时，如果添加第一个参数（参数索引0开始），对应代码中的第一个参数为 p1，即当带有p1参数的访问在统计时间内，访问超过2次，就进行熔断。

    效果如下

    技术分享图片

参数例外项配置

简单来说：对于上述的请求，当p1等于任何值是，只要单机访问超过2个QPS，那么他就会熔断，对于参数例外项配置，就是可用当p1等于特殊的某个值，进行重新的定义限流规则。

如下，即当我们请求的参数为第一个（对于代码中的p1）本来限流是每秒钟超过2次进行限流，但是现在如果请求参数 p1 = 5并且请求类型为String类型，那么他的限流就为200。

技术分享图片

系统规则设置

系统保护规则是从应用级别的入口流量进行控制，从单台机器的 load、CPU 使用率、平均 RT、入口 QPS 和并发线程数等几个维度监控应用指标，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。

简单来说：就是对我们之前定义的限流规则在外面包裹一层，来做新的限流规则，必须满足系统的限流规则，才能走到里面的限流规则

参考：系统自适应限流

系统规则支持以下的模式：（一般不是很常用，因为会如果配置不好，可能会导致下一层的一些规则失效不可用。导致系统瘫痪）

  • Load 自适应（仅对 Linux/Unix-like 机器生效）：系统的 load1 作为启发指标，进行自适应系统保护。当系统 load1 超过设定的启发值，且系统当前的并发线程数超过估算的系统容量时才会触发系统保护（BBR 阶段）。系统容量由系统的 maxQps * minRt 估算得出。设定参考值一般是 CPU cores * 2.5。
  • CPU usage（1.5.0+ 版本）：当系统 CPU 使用率超过阈值即触发系统保护（取值范围 0.0-1.0），比较灵敏。
  • 平均 RT：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
  • 并发线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
  • 入口 QPS：当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。

@SentinelResource

参考官网：@SentinelResource注解详解

技术分享图片

控制台资源限流配置

用来配置访问资源名和达到限流规则后应该怎么处理

@GetMapping("/hotKey")
@SentinelResource(value = "hotKey", blockHandler = "del_hotKet")    //定义访问的资源名，和失败后走的处理方法
public String hotKet(@RequestParam(value = "p1", required = false) String p1,
                     @RequestParam(value = "p2", required = false) String p2){
    return "热点访问成功";
}

// 失败后的处理方法
public String del_hotKet(String p1, String p2 , BlockException exception){
    return "热点新闻访问失败！????????";
}

当然也可用只用定义的访问资源名称，就算定义了资源名称，配置流控规则时依然可以使用URL来做资源名，就是请求地址，但是热点规则除外，不能使用URL

// 达到限流规则时默认走，系统默认的
@SentinelResource(value = "hotKey")

问题存在：

  1. 当我们不想使用系统默认时，自定义替换。
  2. 但是每个方法一个替换，会显得代码膨胀，不直观
  3. 没有体现全局统一管理等问题

问题解决：

  1. 自定义一个类，用来写异常的方法

    package com.wyx.cloud.myHandler;

import com.alibaba.csp.sentinel.slots.block.BlockException;

public class ConsumerHandler {

    // 因为JVM 的加载机制只能使用 static 返回值和要处理的方法的返回值相同
    public static String handlerEx(BlockException exception){
        return "自定义异常处理方法";
    }
    
}

  2. 在方法中调用自定义的异常处理

    @GetMapping("/handlerEx")
// blockHandlerClass 指定处理异常的类， blockHandler 指定处理异常类中的那个方法，如果没有异常类就是在自己的类中找方法
@SentinelResource(value = "hotKey", blockHandlerClass = ConsumerHandler.class ,blockHandler = "handlerEx")
public String handlerEx(){
    return "访问成功";
}

运行时Java异常处理

fallback：

// 参数中还有defaultFallback，代表默认的处理，当与fallback同时标注时，fallback优先级高于defaultFallback
@GetMapping("/fallBack")
@SentinelResource(value = "fallBack",fallback = "fallbackMethod")
public String fallBack(){
    return "访问成功";
}
// 失败后的处理方法
public String fallbackMethod(Throwable exception){
    return "运行时异常处理方法";
}

上面的配置方式还是存在代码膨胀的问题

我们这里也可以用控制台资源处理的方法来处理。即创建一个fallbackMethod的类，然后通过fallbackClass来处理

  1. 创建类ConsumerFallbackMethod

    package com.wyx.cloud.myHandler;

public class ConsumerFallbackMethod {

    // 因为JVM 的加载机制只能使用 static 返回值和要处理的方法的返回值相同
    public static String fallback(Throwable exception){
        return "自定义运行时异常处理方法";
    }
}

  2. 在方法中调用

    @GetMapping("/fallBack")
@SentinelResource(value = "fallBack", fallbackClass = ConsumerFallbackMethod.class, fallback = "fallback")
public String fallBack(){
    int a=10/0;
    return "访问成功";
}

特别说明：当Java运行时异常和控制台限流规则同时配置，且同时生效时，优先使用控制台的限流或熔断处理方法

Sentinel中使用openfeign做服务降级

使用方法和在Hystrix中使用类似，有一点点微小差异（开启的yaml支持不一样），可以参考

OpenFeign的使用：OpenFeign使用流程

Hystrix中使用OpenFeign做服务降级：Hystrix配合OpenFeign使用服务降级

具体步骤如下：

微服务提供者搭建：（2个微服务提供者）

  1. 新建模块Nacos-Sentinel-OpenFeign-Provider-8001，Nacos-Sentinel-OpenFeign-Provider-8002，两个搭建的东西都一样改端口即可

  2. pom.xml

    <dependencies>

    <!--Nacos 服务注册的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--spring-boot-web 模块 常用的3个-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--测试插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok 依赖-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

  3. yaml

    server:
  port: 8001  # 端口号

spring:
  application:
    name: nacos-sentinel-openfeign  # 微服务名称

  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # 连接的注册中心

management:
  endpoints:
    web:
      exposure:
        include: ‘*‘    #暴露端口

  4. 主启动类

    package com.wyx.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

  5. 业务类

    OpenFeign调用服务

    package com.wyx.cloud.service;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class Provider {

    @Value("${server.port}")
    private String serverPort;

    public String getService(){
        return "提供服务成功，当前服务端口："+serverPort;
    }
}

    控制层

    package com.wyx.cloud.controller;

import com.wyx.cloud.service.Provider;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class ProviderController {

    @Resource
    Provider provider;

    @GetMapping("/getServer")
    public String getService(){
        return provider.getService();
    }
}

微服务消费者搭建：

  1. 创建新模块Nacos-Sentinel-OpenFeign-Consumer-80

  2. pom.xml

    <dependencies>
    <!--添加 openfeign 的启动依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

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

    <!--Sentinel 服务监控的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>

    <!--Nacos 服务注册的依赖-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
            </exclusion>
        </exclusions>
    </dependency>

    <!--spring-boot-web 模块 常用的3个-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!--热部署插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--测试插件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--lombok 依赖-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

  3. yaml

    server:
  port: 80


spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8719

service-url:
  nacos-user-service: http://nacos-sentinel-openfeign

#对Feign的支持
feign:
  sentinel:
    enabled: true

  4. 主启动类

    package com.wyx.cloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

  5. 业务类

    OpenFeign调用接口

    package com.wyx.cloud.service;

import com.wyx.cloud.fallback.ProviderFallBackImpl;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(value = "nacos-sentinel-openfeign",fallback = ProviderFallBackImpl.class)
public interface ProviderService {

    @GetMapping("/getServer")
    public String getService();
}

    出错处理类

    package com.wyx.cloud.fallback;


import com.wyx.cloud.service.ProviderService;
import org.springframework.stereotype.Component;

@Component
public class ProviderFallBackImpl implements ProviderService {

    @Override
    public String getService() {
        return "Nacos下Sentinel的程序运行出错方法调用";
    }

}

    控制层

    package com.wyx.cloud.controller;

import com.wyx.cloud.service.ProviderService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class ConsumerController {

    @Resource
    private ProviderService provider;

    @GetMapping("/getServer")
    public String getServer(){
        int a = 10/0;
        return provider.getService();
    }
}

    启动测试即可

配置规则持久化

一旦我们重启应用，Sentinel规则将消失，生产环境需要将配置规则进行持久化。那么如何持久化呢？

  1. 导入依赖

    <dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

  2. 添加yaml配置

    spring:
  cloud:
    sentinel:
      datasource:
        ds1:
          nacos:
            server-addr: localhost:8848
            dataid: ${spring.application.name}
            groupid: DEFAULT_GROUP
            data-type: json
            rule-type: flow

  3. 在Nacos中添加配置Data Id配置文件名：是spring.application.name，服务名称，类型为json

    [
    {
         "resource": "/getInfoB",
         "limitApp": "default",
         "grade":   1,
         "count":   1,
         "strategy": 0,
         "controlBehavior": 0,
         "clusterMode": false    
    }
]

    技术分享图片

    技术分享图片

重启即可

SpringCloud-Alibaba

原文：https://www.cnblogs.com/Rampant/p/15063358.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！