devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Springcloud笔记超级详细

作者：花生_TL007 | 2024-04-24 00:52:39

赞

踩

springcloud笔记

目录

1创建简单的springcloud项目

1.1先创建一个maven的空项目

1.2创建子模块

2.将两个模块加入到Eureka服务中

2.1创建Eureka模块

 2.2将其他模块注册到Eureka服务中

2.3实现负载均衡

2.4修改负载均衡策略

3.Nacos

3.1下载配置Nacos

3.2Springcloud集成Nacos

3.3Nacos的集群配置

3.4修改权重

3.5 命名空间和临时实例

3.6Nacos统一管理配置

4.Feign替代RestTemplate

4.1配置Feign

4.2Feign的性能优化

4.3把feign提取出来成为一个服务

5.gateway网关

5.1创建一个服务

2.predicates Factory断言工厂

3.Gatewayfiler网关过滤器

4.GlobaFilter全局过滤器

5.跨域问题处理

6.Sentinel

 6.1流控

6.1.1qps表示每秒只能多少次访问

6.1.2线程表示每秒只能有多少个线程访问​

6.1.3关联流控

6.1.4Warmup

6.1.5排队等待

1创建简单的springcloud项目

1.1先创建一个maven的空项目

这里直接下一步就好

创建好了后直接把src目录删了

 然后就是写xml配置

这里看需求

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  6.  
  7.     <groupId>org.example</groupId>
  8.     <artifactId>Springcloud</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  10.  
  11.  
  12.     <packaging>pom</packaging>
  13.  
  14.     <parent>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-parent</artifactId>
  17.         <version>2.6.1</version>
  18.         <relativePath/>
  19.     </parent>
  20.  
  21.     <properties>
  22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24.         <java.version>1.8</java.version>
  25.         <spring-cloud.version>2021.0.1</spring-cloud.version>
  26.         <mysql.version>5.1.47</mysql.version>
  27.         <mybatis.version>2.1.1</mybatis.version>
  28.     </properties>
  29.     <dependencyManagement>
  30.         <dependencies>
  31.             <!-- springCloud -->
  32.             <dependency>
  33.                 <groupId>org.springframework.cloud</groupId>
  34.                 <artifactId>spring-cloud-dependencies</artifactId>
  35.                 <version>${spring-cloud.version}</version>
  36.                 <type>pom</type>
  37.                 <scope>import</scope>
  38.             </dependency>
  39.             <!-- mysql驱动 -->
  40.             <dependency>
  41.                 <groupId>mysql</groupId>
  42.                 <artifactId>mysql-connector-java</artifactId>
  43.                 <version>${mysql.version}</version>
  44.             </dependency>
  45.             <!--mybatis-->
  46.             <dependency>
  47.                 <groupId>org.mybatis.spring.boot</groupId>
  48.                 <artifactId>mybatis-spring-boot-starter</artifactId>
  49.                 <version>${mybatis.version}</version>
  50.             </dependency>
  51.         </dependencies>
  52.     </dependencyManagement>
  53.     <dependencies>
  54.         <dependency>
  55.             <groupId>org.projectlombok</groupId>
  56.             <artifactId>lombok</artifactId>
  57.         </dependency>
  58.     </dependencies>
  59.  
  60. </project>

1.2创建子模块

配置xml文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>Springcloud</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.     <groupId>org.user</groupId>
  13.     <artifactId>user-service</artifactId>
  14.  
  15.     <properties>
  16.         <maven.compiler.source>8</maven.compiler.source>
  17.         <maven.compiler.target>8</maven.compiler.target>
  18.     </properties>
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-web</artifactId>
  23.         </dependency>
  24.         <dependency>
  25.             <groupId>mysql</groupId>
  26.             <artifactId>mysql-connector-java</artifactId>
  27.         </dependency>
  28.         <dependency>
  29.             <groupId>com.baomidou</groupId>
  30.             <artifactId>mybatis-plus</artifactId>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>com.baomidou</groupId>
  34.             <artifactId>mybatis-plus-boot-starter</artifactId>
  35.         </dependency>
  36.     </dependencies>
  37. </project>

配置创建springboot启动类

在配置文件里面写数据库的连接不然会报错

最后写一个接口测试一下是否成功，端口号是自己设置的

 没问题的话这个user模块就ok了

我们在创建一个模块重复步骤我们就省略了

我们可以看到订单模块有一个用户我们让订单模块调用户模块的服务

RestTemplate这个是夸模块调用的核心

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.web.client.RestTemplate;
  5.  
  6. /**
  7.  * @Classname OrderApplication
  8.  * @Description TODO
  9.  * @Date 2022/3/26 17:09
  10.  * @Created lijiafen
  11.  */
  12. @SpringBootApplication
  13. public class OrderApplication {
  14.     public static void main(String[] args) {
  15.         SpringApplication.run(OrderApplication.class,args);
  16.     }
  17.     @Bean
  18.     public RestTemplate restTemplate() {
  19.         return new RestTemplate();
  20.     }
  21. }
  1. import com.order.dao.OrderMapper;
  2. import com.order.pojo.tbOrder;
  3. import com.order.pojo.tbUser;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.http.ResponseEntity;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10. import org.springframework.web.client.RestTemplate;
  11.  
  12. /**
  13.  * @Classname OrderController
  14.  * @Description TODO
  15.  * @Date 2022/3/26 17:14
  16.  * @Created lijiafen
  17.  */
  18. @RestController()
  19. @RequestMapping("order")
  20. public class OrderController {
  21.     @Autowired
  22.     OrderMapper mapper;
  23.     @Autowired
  24.     RestTemplate restTemplate;
  25.     @GetMapping("{id}")
  26.     public Object getOrder(@PathVariable("id") Long id) {
  27.         if (id==null){
  28.             return "未输入id";
  29.         }
  30.         tbOrder tbOrder = mapper.selectById(id);
  31.         String url = "http://localhost:8890/user/"+tbOrder.getUserId();
  32.        tbUser user = restTemplate.getForObject(url, tbUser.class);
  33.        tbOrder.setUser(user);
  34.        return tbOrder;
  35.     }
  36. }

这里就是调用用户模块的实现

 但是你怎么知道用户模块没有挂呢，下面我们引入一个springcloud的核心之一Euake

2.将两个模块加入到Eureka服务中

2.1创建Eureka模块

一样的我们先创建一个子模块这个是依赖文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>Springcloud</artifactId>
  7.         <groupId>org.example</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.  
  12.     <artifactId>Springclude-eureka</artifactId>
  13.  
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.     </properties>
  18.     <dependencies>
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter-web</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.cloud</groupId>
  25.             <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  26.         </dependency>
  27.     </dependencies>
  28. </project>

这个是配置文件

  1. server:
  2.   port: 5561
  3. eureka:
  4.   instance:
  5.     hostname: localhost
  6.   client:
  7.     fetch-registry: false
  8.     register-with-eureka: false//这个是是否把自己添加到服务中
  9.     service-url:
  10.       defaultZone: http://localhost:5561/eureka/

一定要在启动类上加上这个注解

  1. package com.fen;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  6.  
  7. /**
  8.  * @Classname Application
  9.  * @Description TODO
  10.  * @Date 2022/3/26 18:54
  11.  * @Created lijiafen
  12.  */
  13. @SpringBootApplication
  14. @EnableEurekaServer
  15. public class Application {
  16.     public static void main(String[] args) {
  17.         SpringApplication.run(Application.class,args);
  18.     }
  19. }

如果进入这个页面的话就说明ok了

 2.2将其他模块注册到Eureka服务中

在其他模块中引入这个依赖

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

配置文件中加入这些配置端口你们的Eureka模块是什么端口这里就写什么

  1. eureka:
  2.   client:
  3.     service-url:
  4.       defaultZone: http://localhost:5561/eureka/

在主类上加上这个注解@EnableEurekaClient

  1.  
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.web.client.RestTemplate;
  7.  
  8. /**
  9.  * @Classname OrderApplication
  10.  * @Description TODO
  11.  * @Date 2022/3/26 17:09
  12.  * @Created lijiafen
  13.  */
  14. @SpringBootApplication
  15. @EnableEurekaClient
  16. public class OrderApplication {
  17.     public static void main(String[] args) {
  18.         SpringApplication.run(OrderApplication.class,args);
  19.     }
  20.     @Bean
  21.     public RestTemplate restTemplate() {
  22.         return new RestTemplate();
  23.     }
  24. }

 如果出现这个就ok了

2.3实现负载均衡

我们把实例都注册的到eureka中之后前面有订单模块调用用户模块

@LoadBalanced我们加上这个注解

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class OrderApplication {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(OrderApplication.class,args);
  6.     }
  7.     @Bean
  8.     @LoadBalanced //这个注解是开启负载均衡
  9.     public RestTemplate restTemplate() {
  10.         return new RestTemplate();
  11.     }
  12. }

我们把user模块分出一个服务

 点击复制配置修改端口

 然后就变成这样的

 我们全部重启一下看看Eureka里面有了两个user的服务

  1. package com.order.controller;
  2.  
  3. import com.order.dao.OrderMapper;
  4. import com.order.pojo.tbOrder;
  5. import com.order.pojo.tbUser;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.http.ResponseEntity;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.PathVariable;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RestController;
  12. import org.springframework.web.client.RestTemplate;
  13.  
  14. /**
  15.  * @Classname OrderController
  16.  * @Description TODO
  17.  * @Date 2022/3/26 17:14
  18.  * @Created lijiafen
  19.  */
  20. @RestController()
  21. @RequestMapping("order")
  22. public class OrderController {
  23.     @Autowired
  24.     OrderMapper mapper;
  25.     @Autowired
  26.     RestTemplate restTemplate;
  27.     @GetMapping("{id}")
  28.     public tbOrder getOrder(@PathVariable("id") Long id) {
  29.         tbOrder tbOrder = mapper.selectById(id);
  30.         String url = "http://userservice/user/"+tbOrder.getUserId();
  31.     这里就不填端口号了我们直接填userservice不指定端口
  32.        tbUser user = restTemplate.getForObject(url, tbUser.class);
  33.        tbOrder.setUser(user);
  34.        return tbOrder;
  35.     }
  36. }

我们用postman多测试几遍这个接口

 

我们可以看到两个user模块都输出了日志那说明就ok了

2.4修改负载均衡策略

默认的话是轮询的策略我们这里配置一个bean修改为随机

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class OrderApplication {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(OrderApplication.class,args);
  6.     }
  7.     @Bean
  8.     @LoadBalanced //这个注解是开启负载均
  9.     public RestTemplate restTemplate() {
  10.         return new RestTemplate();
  11.     }
  12.  
  13.     @Bean
  14.     public IRule iRule(){
  15.         return new RandomRule();/*改变负载均衡的策略这个是随机默认是轮训方式*/
  16.     }
  17. }

3.Nacos

3.1下载配置Nacos

https://nacos.io/zh-cn/

下载好了之后解压到一个没有中文目录的文件夹里面

startup.sh -m standalone

cmd运行起来

我这里因为有浏览器缓存所以不用密码账号和密码是nacos

3.2Springcloud集成Nacos

因为我们这前用了Eureka所以我们先把Eureka的配置注释掉

在到父文件里面引入Nacos的依赖

  1. <dependency>
  2.                 <groupId>com.alibaba.cloud</groupId>
  3.                 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  4.                 <version>2.2.6.RELEASE</version>
  5.                 <type>pom</type>
  6.                 <scope>import</scope>
  7.             </dependency>

在到用户和订单模块里面添加Nacos的依赖

  1.  <dependency>
  2.             <groupId>com.alibaba.cloud</groupId>
  3.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  4.         </dependency>

在配置文件里面添加Nacos的服务地址配置

  1.  spring:
  2.     cloud:
  3.       nacos:
  4.         server-addr: 127.0.0.1:8848

注意要把之前Eureka的配置全部注释掉然后运行服务要先把Nacos的服务开启

如果出现这个界面显示了三个服务就ok了

3.3Nacos的集群配置

  1.  cloud:
  2.     nacos:
  3.       server-addr: 127.0.0.1:8848
  4.       discovery:
  5.         cluster-name: NC #集群名称南昌

我们运行两个userService的服务

然后在修改配置文件把南昌改成别的城市

  1.  cloud:
  2.     nacos:
  3.       server-addr: 127.0.0.1:8848
  4.       discovery:
  5.         cluster-name: SZ #集群名称深圳

然后打开Nacos的控制台

 这样的话那就是配置成功了

总结一下

 我们为orderservice也配置一下集群和上面做法一样

我们让他优先访问本地集群配置yml文件就会优先访问本地集群

  1. userservice:
  2.   ribbon:
  3.     NFLoadBalancerRuleClassNane: com.alibaba.cloud.nacos.ribbon.NacosRule


3.4修改权重

我们可以通过修改改服务的权重来控制服务器的访问量

3.5 命名空间和临时实例

新建一个命名空间

 然后在配置文件里面配置

  1.   cloud:
  2.     nacos:
  3.       server-addr: 127.0.0.1:8848
  4.       discovery:
  5.         cluster-name: SZ #集群名称南昌
  6.         namespace: lijia520 #命名空间
  7.         ephemeral: false #是否为临时实例

然后就是临时实例的问题如果不是临时实例的话服务挂了之后Nacos是不会把该服务剔除的

如果是临时实例的话就会把该服务剔除而是会一直等待该服务恢复，除非你主动把他剔除

3.6Nacos统一管理配置

点击加号新建配置

 

 然后就是写bootstrap文件因为这个文件会比application文件先被读取

  1. spring:
  2.   application:
  3.     name: orderservice-dev
  4.   cloud:
  5.     nacos:
  6.       server-addr: localhost:8848
  7.       config:
  8.         file-extension: yaml

 添加依赖，如果cloud的版本是2020.0以上的还要多加一个依赖

  1. <dependency>
  2.             <groupId>com.alibaba.cloud</groupId>
  3.             <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  4.         </dependency>
  5.         <!--让这个模块先加载bootstrap文件-->
  6.         <dependency>
  7.             <groupId>org.springframework.cloud</groupId>
  8.             <artifactId>spring-cloud-starter-bootstrap</artifactId>
  9.         </dependency>

然后我们写一个接口测试一下

  1.   @Value("${pattern.dateformat}")
  2.     String name;
  3.  
  4.  
  5.  @GetMapping("/name")
  6.     public String name(){
  7.  
  8.       return LocalDateTime.now().format(DateTimeFormatter.ofPattern(name));
  9.     }

那就说明读取到了里面的配置，如果需要热加载的话在controller上面加一个注解

@RefreshScope

这个注解是配置热更新的注解

4.Feign替代RestTemplate

4.1配置Feign

导依赖开启注解支持

  1.  <!--feign依赖-->
  2.         <dependency>
  3.             <groupId>org.springframework.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  5.         </dependency>

在启动 类上添加这个注解开启自动装配

@EnableFeignClients //开启feign自动装配支持

然后我们创建一个包

 里面创建一个接口

  1. package com.order.clients;
  2.  
  3. import com.order.pojo.tbUser;
  4. import org.springframework.cloud.openfeign.FeignClient;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.PathVariable;
  7.  
  8. @FeignClient("userservice")
  9. public interface UserClient {
  10.     @GetMapping("/user/{id}")
  11.     tbUser GetById(@PathVariable("id") Long id);
  12. }

这里的参数对应提供者的参数下面是调用的代码

  1.  @Autowired
  2.     UserClient userClient;
  1.  @GetMapping("{id}")
  2.     public tbOrder getOrder(@PathVariable("id") Long id) {
  3.         tbOrder tbOrder = mapper.selectById(id);
  4.         Long userId= tbOrder.getUserId();
  5.        tbUser user = userClient.GetById(userId);
  6.        tbOrder.setUser(user);
  7.        return tbOrder;
  8.     }

还要注意的就是如果使用的是springcloud是2021.0.1的话我们要改一下因为fegin自带了rebbin

我们要把nacos里面的不使用

  1. <dependency>
  2.             <groupId>com.alibaba.cloud</groupId>
  3.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  4.             <version>2.2.6.RELEASE</version>
  5.             <exclusions>
  6.                 <exclusion>
  7.                     <groupId>org.springframework.cloud</groupId>
  8.                     <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  9.                 </exclusion>
  10.             </exclusions>
  11.         </dependency>

这个困扰了我一下午终于解决

4.2Feign的性能优化

我们这边用阿帕奇的http连接池

  1.   <dependency>
  2.             <groupId>io.github.openfeign</groupId>
  3.             <artifactId>feign-httpclient</artifactId>
  4.         </dependency>

编写配置文件

  1. feign:
  2.   client:
  3.     config:
  4.       default: #全局日志
  5.         loggerLevel: BASIC #日志级别
  6.   httpclient:
  7.     enabled: true  #开启feign对httpclient的支持
  8.       max-connections: 200 #最大连接数
  9.       max-connections-per-route: 50 #每个路径的最大连接数

4.3把feign提取出来成为一个服务

 

然后调用这个接口就ok了

  1.  @Autowired
  2.     UserClient userClient;
  3.  
  4.     @GetMapping("{id}")
  5.     public tbOrder getOrder(@PathVariable("id") Long id) {
  6.         tbOrder tbOrder = mapper.selectById(id);
  7.         Long userId= tbOrder.getUserId();
  8.        tbUser user = userClient.GetById(userId);
  9.        tbOrder.setUser(user);
  10.        return tbOrder;
  11.     }

 


5.gateway网关

5.1创建一个服务

  1.         <dependency>
  2.             <!--nacos服务发现依赖-->
  3.             <groupId>com.alibaba.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  5.         </dependency>
  6.  
  7.         <dependency>
  8.             <!--gateway网关依赖-->
  9.             <groupId>org.springframework.cloud</groupId>
  10.             <artifactId>spring-cloud-starter-gateway</artifactId>
  11.         </dependency>
  12.  
  13.         <!--负载均衡-->
  14.         <dependency>
  15.             <groupId>org.springframework.cloud</groupId>
  16.             <artifactId>spring-cloud-starter-loadbalancer</artifactId>
  17.         </dependency>

 配置文件

  1. spring:
  2.   application:
  3.     name: gateway
  4.   cloud:
  5.     nacos:
  6.       server-addr: 127.0.0.1:8848 #加入到nacos里面
  7.     gateway:
  8.       routes:
  9.         - id: user-service #路由标识必须唯一
  10.           uri: lb://userservice #路由的目标地址
  11.           predicates:
  12.             - Path=/user/** #断言判断请求路径是否以/user开头如果是就符合规则这里一定要大写P
  13.         - id: order-service
  14.           uri: lb://orderservice-dev
  15.           predicates:
  16.             - Path=/order/**
  17. server:
  18.   port: 10086

 这里我们请求的是网关的端口通过网关转发到user服务里面

2.predicates Factory断言工厂

上面我们用的就是Path

 https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gateway-request-predicates-factoriesz

这个是链接可以去看看

我们来试一个

  1. gateway:
  2.       routes:
  3.         - id: user-service #路由标识必须唯一
  4.           uri: lb://userservice #路由的目标地址
  5.           predicates:
  6.             - Path=/user/** #断言判断请求路径是否以/user开头如果是就符合规则这里一定要大写P
  7.             - After=2032-01-20T17:42:47.789-07:00[Asia/Shanghai]
  8.         - id: order-service
  9.           uri: lb://orderservice-dev
  10.           predicates:
  11.             - Path=/order/**
  12.             - After=2032-01-20T17:42:47.789-07:00[Asia/Shanghai] #这个规则是需要在2017年之后就符合规则

 我们就设置成功，还有很多断言可以去试试

3.Gatewayfiler网关过滤器

spring官网有很多的过滤器可以去看看

  1.     gateway:
  2.       routes:
  3.         - id: user-service #路由标识必须唯一
  4.           uri: lb://userservice #路由的目标地址
  5.           predicates:
  6.             - Path=/user/** #断言判断请求路径是否以/user开头如果是就符合规则这里一定要大写P
  7.             - After=2021-01-20T17:42:47.789-07:00[Asia/Shanghai]
  8.           filters:
  9.             - AddRequestHeader=Name,lijiafen #请求头添加信息

我们来试一个，我们配的是user服务我们在user服务的controller接口里面接收一下看看能不能接收的名字

  1.   @RequestMapping("{id}")
  2.     public tbUser selectUser(@PathVariable("id") int id,@RequestHeader("Name") String name) {
  3.         System.out.println("name是"+name);
  4.         return userDao.selectById(id);
  5.     }

控制台也打印了就ok了这样一个一个服务配有点麻烦我们有一种全局配置的方法

  1.     gateway:
  2.       routes:
  3.         - id: user-service #路由标识必须唯一
  4.           uri: lb://userservice #路由的目标地址
  5.           predicates:
  6.             - Path=/user/** #断言判断请求路径是否以/user开头如果是就符合规则这里一定要大写P
  7.             - After=2021-01-20T17:42:47.789-07:00[Asia/Shanghai]
  8.           filters:
  9.             - AddRequestHeader=Name,lijiafen #请求头添加信息
  10.         - id: order-service
  11.           uri: lb://orderservice-dev
  12.           predicates:
  13.             - Path=/order/**
  14.             - After=2021-01-20T17:42:47.789-07:00[Asia/Shanghai] #这个规则是需要在2017年之后就符合规则
  15.       default-filters: #全局配置过滤器
  16.         - AddRequestHeader=Name,lijiafen #请求头添加信息

我们在order服务里面也添加一下看看能不能生效

说明我们全局配置就ok了

4.GlobaFilter全局过滤器

 具体代码

  1.  
  2. /**
  3.  * @Classname LandFilter
  4.  * @Description TODO
  5.  * @Date 2022/4/28 17:27
  6.  * @Created lijiafen
  7.  */
  8.  
  9. public class LandFilter implements GatewayFilter , Ordered {
  10.     @Override
  11.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  12.         //我们获取前端传来的参数
  13.         ServerHttpRequest request = exchange.getRequest();
  14.         //获取请求的参数
  15.         MultiValueMap<String, String> queryParams = request.getQueryParams();
  16.         String name = queryParams.getFirst("Name");
  17.         if ("小p".equals(name)){
  18.             /*如果相等就放行*/
  19.             return chain.filter(exchange);
  20.         }
  21.         /*设置状态码*/
  22.         exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
  23.         return exchange.getResponse().setComplete();
  24.     }
  25.  
  26.     @Override
  27.     public int getOrder() {
  28.         return -1; /*这里是定义过滤器的执行顺序*/
  29.     }
  30. }

5.跨域问题处理

 这是一个很明显的跨域问题

配置如下

  1.       globalcors:
  2.         cors-configurations:
  3.           '[/**]':
  4.             # 允许任何域名使用
  5.             allowedOrigins: "*"
  6.             # 允许任何头
  7.             allowedHeaders: "*"
  8.             # 允许任何方法(post、get等)
  9.             allowedMethods: "*"
  10.             # sessionid 多次访问一致
  11.             allowCredentials: true
  12.         # 允许来自所有域名(allowedOrigins)的所有请求方式(allowedMethods)发出CORS请求
  13.         add-to-simple-url-handler-mapping: true   # 允许来自所有域名(allowedOrigins)的所有请求方式(allowedMethods)发出CORS请求

6.Sentinel

这个是他的中文文档介绍 · alibaba/Sentinel Wiki · GitHub

我们下好了后直接java-jar运行

 账号密码都是sentinel

然后我们创建一个服务把它接入nacos

  1. dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-web</artifactId>
  4.         </dependency>
  5.  
  6.         <dependency>
  7.             <!--nacos服务发现依赖-->
  8.             <groupId>com.alibaba.cloud</groupId>
  9.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  10.         </dependency>
  11.  
  12.         <dependency>
  13.             <!--sentinel核心依赖-->
  14.             <groupId>com.alibaba.cloud</groupId>
  15.             <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  16.         </dependency>
  17.  
  18.         <dependency>
  19.             <!--为了以后持久化作准备-->
  20.             <groupId>com.alibaba.csp</groupId>
  21.             <artifactId>sentinel-datasource-nacos</artifactId>
  22.         </dependency>
  23.  
  24.         <dependency>
  25.             <groupId>org.springframework.cloud</groupId>
  26.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  27.         </dependency>

配置文件

  1. server:
  2.   port: 1314
  3. spring:
  4.   application:
  5.     name: sentinel
  6.   cloud:
  7.     nacos:
  8.       server-addr: 127.0.0.1:8848
  9.     sentinel:
  10.       transport:
  11.         dashboard: 127.0.0.1:8080 #这个是sentinel前台端口
  12.         port: 8719 #这个是后台端口
  13.   main:
  14.     allow-circular-references: true #如果是使用的2021.0的话加这个配置

要执行一次之后就可以显示

这个是我们开放的两个后端接口也就是一个链路下面的两个节点

 

 6.1流控

添加流控规则

6.1.1qps表示每秒只能多少次访问

 这个就是每秒超过了1次访问就报错

 6.1.2线程表示每秒只能有多少个线程访问

 这边手速不够就不试了。。。。。

6.1.3关联流控

 如果name这个接口访问数超标的话我们user就会挂掉

我们用apipost一直访问这个 接口然后我们的user就挂掉了

 6.1.4Warmup

6.1.5排队等待

 这个就不必多说了吧

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。