Springcloud alibaba环境搭建

可是我还饿啊

已于 2022-05-14 17:17:21 修改

阅读量373

点赞数

文章标签： spring cloud java 阿里云

于 2022-05-10 21:43:37 首次发布

本文链接：https://blog.csdn.net/m0_55627541/article/details/124695913

版权

一.创建全局父项目

二、安装Nacos组件

安装Nacos

安装jdk，因为nacos基于java语言写的。要求8.0以后

解压缩Nacos压缩包

启动nacos服务

访问Nacos的web地址

三、nacos client 创建(也就是以后一个个微服务项目)

四、Nacos server 服务注册中心细节

一.创建全局父项目

维护springcloud依赖 Hoxton.SR6

维护alibaba依赖 2.2.1.RELEASE

继承springboot父项目 2.2.5.RELEASE

构建一个maven，当作全局父项目，取名为springcloudalibaba_parent

父项目中不写代码，把src目录删除

在setting里面先配置maven仓库和maven地址。

在pom文件里面添加依赖

继承springboot父项目维护两个依赖：springcloud依赖 springcloud alibaba依赖

<?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>com.baizhi</groupId>
    <artifactId>springcloudalibaba_parent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--        继承springboot父项目-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
    </parent>
<!--    定义版本号-->
    <properties>
        <spring.cloud.version>Hoxton.SR6</spring.cloud.version>
        <spring.cloud.alibaba.version>2.2.1.RELEASE</spring.cloud.alibaba.version>
    </properties>
<!--    维护依赖-->
    <dependencyManagement>
        <dependencies>
<!--        维护springcloud依赖 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring.cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
<!--         维护springcloud alibaba依赖-->
            <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>

以上就是pringcloud alibaba的环境搭建。

二、安装Nacos组件

分为两步：先把安装包拉到linux，然后在linux上安装配置好jdk之后再解压缩Nacos压缩包。

安装Nacos

作用：服务注册中心统一配置中心

使用：有可视化界面

a.访问官方地址

home (nacos.io)

b.下载地址

https://github.com/alibaba/nacos/releases

下载1.4.1 最稳定版本，linux安装。

链接：https://pan.baidu.com/s/1Vg1pZ65ZCBmaEffj8aDRWA
提取码：1314
--来自百度网盘超级会员V2的分享

启动centor os，finalshell连接，把安装包拉过来

安装jdk，因为nacos基于java语言写的。要求8.0以后

链接：https://pan.baidu.com/s/1OFDGvvwOtSOW9KuN4UviLw
提取码：1314
--来自百度网盘超级会员V2的分享

通过finalshell上传linux，执行安装命令

rpm -ivh jdk-8u221-linux-x64.rpm

配置环境变量

先看一下安装到哪了

find / -name java

/usr/java/jdk1.8.0_221-amd64/bin这个就是安装位置，开始配置

vim /etc/profile这个就是环境变量的位置，在这里加入环境变量

点击字母i，进入编辑模式，拉到最后，写下面两段话，按Esc键，退出编辑，按下shift+; 输入wq之后点击enter。

export JAVA_HOME=/usr/java/jdk1.8.0_221-amd64
export PATH=$PATH:$JAVA_HOME/bin

完成上步之后重新加载配置文件,使其生效

source /etc/profile

输入java -version，提示如下就说明成功

解压缩Nacos压缩包

输入命令

tar -zxvf nacos-server-1.4.1.tar.gz

解压完成后，会出现一个nacos的目录。

进入之后会出现这几个文件

bin：启动关闭nacos脚本目录

conf：配置nacos配置文件目录

target：核心jar包

启动nacos服务

在bin目录执行脚本，但是默认nacos启动是以集群模式启动，必须满足多个节点。所以我们进行单机启动

单机启动:在bin目录中 ./startup.sh -m standalone

默认后台启动，要查看日志，退出到上一级，会出现一个logs的文件

查看一个名为nacos.log

访问Nacos的web地址

http://192.168.72.130:8848/nacos

linuxip地址+8848/nacos

默认账户密码：nacos

三、nacos client 创建(也就是以后一个个微服务项目)

确认nacos已经开启

创建一个独立的springboot应用，基于父项目,以下所有模块都是基于父项目

引入依赖

<?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">
    <parent>
        <artifactId>springcloudalibaba_parent</artifactId>
        <groupId>com.baizhi</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloudalibaba_01nacosclient</artifactId>

    <dependencies>
<!--        声明是一个springboot项目-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        引入nacos客户端依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>

</project>

编写启动类

package com.baizhi;

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

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

配置properties

server.port=8989
#指定当前服务端口
spring.application.name=NACOSCLIENT
#指定nacos服务地址
spring.cloud.nacos.server-addr=192.168.72.130:8848

启动项目，然后进入nacosweb地址查看，服务管理=>服务列表。

四、Nacos server 服务注册中心细节

Nacos：服务注册中心配置中心

spring.cloud.nacos.discovery.server-addr=${spring.cloud.nacos.server-addr}服务注册地址

spring.cloud.nacos.server-addr=192.168.72.130:8848 总地址

spring.cloud.nacos.discovery.service=${spring.application.name} 指定服务名称以这个为主

服务间的通信

http rest rpc

http rest： RestTemplate、Ribbon、Openfeign

创建两个微服务进行通信测试。users、products

users调用products中的服务，有三种方式RestTemplate、Ribbon、Openfeign

推荐使用Openfeign 因为它路径既没有写死，也实现了负载均衡

users代码结构

config中的BeansConfig是Ribbon组件的第三种实现方式@LoadBalance注解。它注入了RestTemplate。

feignclient包是Openfign的实现。三个步骤1.添加依赖2.启动类加注解3.写接口

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






@EnableFeignClients //开启Openfeign





@FeignClient("PRODUCTS")
public interface ProductClient {
    @GetMapping("/product")
    String product(@RequestParam("id") Integer id);
}

UserController中介绍三种实现服务调用的方式

package com.baizhi.controller;

import com.baizhi.feignclients.ProductClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
public class UserController {
//    @Autowired
//    private DiscoveryClient discoveryClient;//服务发现的客户端
//    @Autowired
//    private LoadBalancerClient loadBalancerClient;//负载均衡的客户端组件
//    上面这两个是依赖注入自动集成的直接通过autowired注入就可以
//    下面这个是需要自己手动创建一个配置类，通过bean，让工厂管理，也就是config包下的BeansConfig
//    @Autowired
//    private RestTemplate restTemplate;//@LoadBalance注解 创建一个Bean名为RestTemplate
    @Autowired
    private ProductClient productClient;
    @GetMapping("/user")
    public String user(){

//使用Openfeign组件解决 "http://PRODUCTS/product?id=21"
//1.引入依赖调用方 2.开启注解支持在启动类上 @EnableFeignClients //开启Openfeign3.创建feignclients 创建接口
        String product = productClient.product(21);
        return product;
        //调用商品服务 缺点：无法实现请求的负载均衡  路径写死在代码中
        //String result=new RestTemplate().getForObject("http://localhost:8990/product?id=21",String.class);

        //使用Ribbon组件，实现负载均衡,alibaba也集成了Ribbon不用再引入
        //三个客户端：DiscoveryClient LoadBalanceClient @LoadBalance注解

        //DiscoveryClient:根据服务id去注册中心找与之对应的服务列表 缺点：只是拉取所有的，没有负载均衡
        //List<ServiceInstance> serviceInstances = discoveryClient.getInstances("PRODUCTS");
        // for (ServiceInstance serviceInstance : serviceInstances) {
        //}

        //LoadBalanceClient 根据id选择一个节点,缺点:需要手动写需要调用哪一个节点
        //ServiceInstance serviceInstance = loadBalancerClient.choose("PRODUCTS");

        //@LoadBalance注解 创建一个Bean 缺点：参数写死。
        //String result = this.restTemplate.getForObject("http://PRODUCTS/product?id=21", String.class);


    }
}

ProductController只负责提供接口，让UserController来调用

package com.baizhi.controller;

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

@RestController
public class ProductController {
    @Value("${server.port}")
    private int port;
    @GetMapping("/product")
    public String product(Integer id){
        return "商品服务返回:"+id+",当前提供服务的端口为:"+port;
    }
}

五、Nacos统一配置中心

1.确保nacos已经开启

2.开发微服务模块作为统一配置中心客户端，将配置交给Nacos进行管理

新建maven 名为configclient，让他作为统一配置中心客户端

添加依赖

<?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">
    <parent>
        <artifactId>springcloudalibaba_parent</artifactId>
        <groupId>com.baizhi</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloudalibaba_04configclientx</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--        引入nacosserver 注册中心客户端依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--        引入nacosserver 配置中心客户端依赖-->
        <!-- https://mvnrepository.com/artifact/com.alibaba.cloud/spring-cloud-starter-alibaba-nacos-config -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>

    </dependencies>

</project>

配置文件

#原来写这个
server.port=8888
spring.application.name=CONFIGCLIENT
#nacos server 地址
spring.cloud.nacos.server-addr=192.168.72.130:8848
#??nacos????
spring.cloud.nacos.discovery.server-addr=${spring.cloud.nacos.server-addr}
zsp=zhangsan



#现在写这个，并且把名字更改为bootstrap.properties
#config server 配置中心的地址
spring.cloud.nacos.config.server-addr=192.168.72.130:8848
#group
spring.cloud.nacos.config.group=DEFAULT_GROUP
#id
spring.cloud.nacos.config.name=configclient-prod
#houzhui
spring.cloud.nacos.config.file-extension=properties

启动类

package com.baizhi;

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

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

controller

package com.baizhi.controller;

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

@RestController
@RefreshScope //允许远端配置修改自动刷新
public class ConfigClientController {
    @Value("${zsp}")
    private String name;
    @GetMapping("demo")
    public String demo(){
        return "demo ok";
    }
}

去nacos配置管理，配置列表新建一个。配置跟configclient一样。properties不能有中文

启动服务。

六、Nacos配置中心细节

1.获取Nacos配置的两种方式：

spring.cloud.nacos.config.name=configclient-prod 名称
spring.cloud.nacos.config.file-extension=properties 后缀

spring.cloud.nacos.config.prefix=configclient 前缀
spring.profiles.active=prod 环境
spring.cloud.nacos.config.file-extension=properties 后缀

2.统一配置中心Nacos三个重要概念

命名空间：namespace 默认安装完成之后，会有一个public命名空间

自定义命名空间。每个项目有每个项目的命名空间

站在项目的角度，进行项目之间配置文件的隔离

组：group 默认名称为DEFAULT_GROUP

站在项目中每一个服务的角度，隔离同一个项目中不同服务的配置信息

文件名：dataId 获取一个配置文件的唯一标识

这个时候配置文件：获取命名空间获取组获取id 获取环境获取后缀。。。以这样的方式获取远端的配置文件

七、Nacos持久化配置

a.统一配置中心的持久化

默认内嵌数据库debery

缺点：无法友好的展示数据

官方建议：在生产情况下，将配置存入msql数据库 nacos默认存储在data文件夹

b.将nacos持久化到mysql中

第一步：在linux中安装mysql 版本要求 5.6.5+

加载数据源

1.vi /etc/yum.repos.d/mysql-community.repo

2.进入之后编写

[mysql57-community]
name=Mysql 5.7 Community Server
baseurl=http://repo.mysql.com/yum/mysql-5.7-community/el/7/$basearch/
enabled=1
gpgcheck=0
gpgkep=file:///etc/pki/rpm=gpg/RPM-GPG-KEY-mysql
3.运行

yum install mysql-community-server -y

4.启动mysql

systemctl status mysqld

systemctl start mysqld

5.获取临时密码临时密码在日志里面

grep 'temporary password' /var/log/mysqld.log 返回值就是临时密码

6.修改root用户密码

mysqladmin -u root -p password

回车之后，输入临时密码，再输入新密码新密码大小写特殊字符

7.使用root用户以及修改之后的密码登录mysql

mysql -u root -p 回车，输入修改后的密码

解决linux-mysql 登录时，报异常：Access denied for user 'root'@'localhost'

第一步：停服务

/etc/init.d/mysql stop
或者

service mysqld stop


第二步：跳过密码验证
vi /etc/my.cnf
执行命令行：
# /usr/bin/mysqld_safe --skip-grant-tables
报：
151104 09:07:56 mysqld_safe Logging to '/var/lib/mysql/iZ23dq2wm0jZ.err'.
151104 09:07:56 mysqld_safe Starting mysqld daemon with databases from /var/lib/mysql

第三步：无密码登录
执行命令行：
mysql -u root 

第四步：授权
mysql>
grant all privileges on *.* to 'root'@'localhost' identified by 'root' with grant option;
关键词解释：
root'@'localhost:是用户
root：是密码

问题一：发现无密码条件下，没有授权的写权限
The MySQL server is running with the --skip-grant-tables option so it cannot execute this statement
解决方法：
mysql> set global read_only=0;//（关掉新主库的只读属性）
mysql>flush privileges;
再次执行第四步授权语句：grant all privileges on *.* to 'root'@'localhost' identified by 'root' with grant option;

mysql>set global read_only=1;//(读写属性)
mysql>flush privileges;
（注意刷新是必须项）

第五步：重启数据库
/etc/init.d/mysql restart
或者
service mysql restart
————————————————
版权声明：本文为CSDN博主「小努蛋」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/hhj724/article/details/73277506/

8.开启mysql远程连接权限

登录之后输入以下命令

grant all privileges on *.* to 'root'@'%' identified by 'Zsp123+' with grant option; 123456是你自己的密码

9.刷新权限

flush privileges;

c.把nacos持久化到msql数据库

1.新建一个数据库 nacos——config 编码：utf-8

2.在nacos数据库中执行nacos-mysql.sql

链接：https://pan.baidu.com/s/1m2LpJODRU6qnUpg2JjMZEA
提取码：1314
--来自百度网盘超级会员V2的分享

3.修改nacos配置文件，持久化信息到mysql

修改application.properties

vim application.properties

1改使用平台mysql

db编号为1

账户密码

重启nacos standalone 表示单机启动nacos

启动之后，进入nacosweb页面，发现之前的都没有了。

现在创建一个命名空间，导入之前的properties，更改项目中bootstrap.properties文件的命名空间id

连接测试。

八、Nacos Server集群搭建

域名解析DNS --->负载均衡SLB ---->Nacos集群（奇数个）必须把数据持久化到mysql数据库

Nacos集群

a.集群规划

nacos01 192.168.72.130:8845

nacos02 192.168.72.130:8846

nacos03 192.168.72.130:8847

mysql 192.168.72.130:3306

nginx(负载均衡组件) 192.168.72.130:8999

b.搭建Nacos集群注意事项

1.数据持久化

2.要求在一个机器启动时当前虚拟机内存不能少于3G

c.搭建Nacos集群

准备3个Nacos节点，并连接mysql数据库

1.清空原始data数据

2.拷贝nacos nacos01 02 03

3.关闭防火墙

systemctl stop firewalld

4.清掉mysql原有的数据

5.重新初始化一次，在nacos执行nacos-mysql.sql

6.配置nacos01 02 03 分别启动端口不一样，且这三个在一个集群里面：

修改nacos conf目录中的cluster.conf配置文件添加所有的集群节点

改名字

mv nacos01/conf/cluster.conf.example nacos01/conf/cluster.conf

在每个cluster.conf 中编辑节点信息，编辑一个其他的复制

vim nacos01/conf/cluster.conf

拷贝到另外两个

cp nacos01/conf/cluster.conf nacos02/conf/cluster.conf

查看是否更改

cat nacos01/conf/cluster.conf

7.修改各自的端口号

vim nacos01/conf/application.properties 8845

vim nacos02/conf/application.properties 8846

vim nacos03/conf/application.properties 8847

8.启动Nacos 默认就是集群方式启动不用加-m

./nacos01/bin/startup.sh

./nacos02/bin/startup.sh

./nacos03/bin/startup.sh

9.启动完之后，在项目01nacosclient测试一下，修改nacos地址为8845，启动运行，观察nacosweb页面是否另外两个nacos也注册上

Nginx实现Nacos高可用

负载均衡SLB

1.在linux系统安装Nginx

安装必要依赖

yum install -y gcc pcre-devel zlib-devel

解压Nginx

tar -zxvf nginx-1.12.2.tar.gz

进入目录编译安装

指定安装位置

./configure --prefix=/usr/nginx

编译并安装

make && make install

启动nginx

进入sbin目录中 usr/nginx/sbin 执行./nginx命令

查看直接输入linux系统的ip默认监听80端口

配置反向代理，这样启动的Nginx是作为服务器进行处理请求，我们要的是通过nginx转发给nacos让他处理请求。所以进行一些配置

配置之前关闭nginx ./nginx -s stop

进入nginx的配置文件进行编辑

在http里面，server外面配置端口

upstream nacos-servers {
        server 192.168.72.134:8845;
        server 192.168.72.134:8846;
        server 192.168.72.134:8847;
}

还需要配置一个，告诉nginx不要自己处理请求，让后面的节点处理

注释原有的，配置一下新的，保存退出

重新启动nginx，加载配置启动

./nginx -c /usr/nginx/conf/nginx.conf

项目中配置文件的nacos.server-addr=nginx的ip地址：80，也就是linux的ip地址：80，因为他监听的就是80端口

最好的就是写域名，通过域名去映射这个端口。

九、Sentinel 哨兵

作用：

替换原有的Hystrix

两大概念：

资源：java一切皆资源

规则：流量控制、熔断、负载规则

Sentinel （项目中实现流量控制熔断降级） Sentinel dashBoard（仪表盘）

实现原理

Sentinel dashBorad会连接到每个配置了Sentiel组件的微服务，他会在自己内部配置与资源与之对应的规则，并通过协议，传给每个Sentiel组件对应的微服务，每个微服务里面的Sentiel感知到Sentinel dashBorad传过来的规则时会在自己内部形成这一套规则，当用户调用某个服务里面的资源时，会检测该资源有没有规则，如果有就应用该规则。

下载与使用：

1.下载

Sentinel dashBorad这个jar包，github搜索Sentinel 之后，点进第一个，点进tags，选择版本。

2.在linux下执行这个jar包，指定端口，默认是8080

java -jar -Dserver.port=9191 sentinel-dashboard-1.7.2.jar

3.访问dashboard管理界面

4.账户密码：sentinel

创建sentinel客户端

要想在项目中实现sentinel，需要在使用的微服务模块中加入seninel依赖，并且注册到nacos中。下面新建一个微服务模块，前提开启nacos(单机模式)和sentinel dashboard。

另起一个窗口，开启nacos单机模式。

新建一个maven，用来测试sentinel

application.properties

server.port=8998
spring.application.name=SENTINEL

#NACOS Server
spring.cloud.nacos.server-addr=192.168.72.134:8848

#打开 sentinel 保护
spring.cloud.sentinel.enabled=true
#指定 sentinel dashboard web地址
spring.cloud.sentinel.transport.dashboard=192.168.72.134:9191
#指定 sentinel 组件与sentinel dashboard组件通信地址
spring.cloud.sentinel.transport.port=8719

pom

<?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">
    <parent>
        <artifactId>springcloudalibaba_parent</artifactId>
        <groupId>com.baizhi</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springcloudalibaba_05sentinel</artifactId>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
<!--        nacos注册中心依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
<!--        sentinel依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        </dependency>
    </dependencies>
</project>

controller

package com.baizhi.controller;

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

@RestController
public class SentinelController {
    @GetMapping("demo")
    public String demo(){
        return "你好 Sentinel";
    }
}

启动，测试。

在sentinel dashboard流控规则设置QPS 单机阈值为2，就是每秒最多执行2个请求，超过就报错。

流控模式：

直接：超过之后，对剩下的做什么处理

关联：超过这个阈值之后它反向关联的资源做什么处理

关联资源/aa,原始为demo，对aa的请求超过两个之后，此时对demo的请求访问是失败的

链路：超过阈值之后，所在的链路做什么处理

demo->product->user 这是一条链路，如果对demo的请求超过2条，则对后续链路都会产生影响

流控效果：只适用于QPS限流

快速失败：直接拒绝请求，并抛出相应的异常

Warm Up：冷启动(预热)

排队等待：始终匀速通过

熔断降级

Sentinel提供的熔断策略

RT：根据请求响应时间熔断

异常比例：根据请求调用过程中出现异常的百分比进行熔断

异常数：根据请求调用过程中出现异常数进行熔断

热点参数限流

注意：使用热点参数限流时，不能使用资源路径，必须使用资源别名

sentinel中提供的资源别名的注解 @SentinelResource(value="别名",blockHandler="热点参数限流之后执行的方法",fallback="业务出现异常时，自定义处理方案")

可是我还饿啊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Springcloud alibaba环境搭建

一.创建全局父项目维护springcloud依赖 Hoxton.SR6维护alibaba依赖 2.2.1.RELEASE 继承springboot父项目 2.2.5.RELEASE构建一个maven，当作全局父项目，取名为springcloudalibaba_parent父项目中不写代码，把src目录删除在setting里面先配置maven仓库和maven地址。在pom文件里面添加依赖继承...
复制链接

扫一扫