0
0

【Spring Cloud】Gateway组件的三种使用方式

🎉🎉欢迎来到我的CSDN主页！🎉🎉

🏅我是Java方文山，一个在CSDN分享笔记的博主。📚📚

🌟推荐给大家我的专栏《Spring Cloud》。🎯🎯

👉点击这里，就可以查看我的主页啦！👇👇

Java方文山的个人主页

🎁如果感觉还不错的话请给我点赞吧！🎁🎁

💖期待你的加入，一起学习，一起进步！💖💖

请添加图片描述

🌟前言

  1.     Spring Cloud Gateway是Spring官方基于Spring5.0、SpringBoot2.0和Project Reactor等技术开发的网关旨在为微服务框架提供一种简单而有效的统一的API路由管理方式，统一访问接口。 
  3.     Spring Cloud Gateway作为Spring Cloud生态体系中的网关，目标是替代Netflix的Zuul，其不仅提供统 一的路由方式，并且基于Filter链的方式提供了网关基本的功能，例如：安全、监控/埋点和限流等等，而且它是基于Netty的响应式开发模式。

✨创建模块

我们的Gatewa既然是负责网络路由的，那么它首先肯定是个模块，所以我们的第一步就是需要创建一个模块。

修改该模块的pom.xml文件，让其继承父模块及导入相应的依赖 

  1.   <parent>
  2.         <groupId>org.example</groupId>
  3.         <artifactId>Cloud</artifactId>
  4.         <version>0.0.1-SNAPSHOT</version>
  5.     </parent>
  7. <dependencies>
  8.     <dependency>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-webflux</artifactId>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework.cloud</groupId>
  14.         <artifactId>spring-cloud-starter-gateway</artifactId>
  15.     </dependency>
  16.     <dependency>
  17.         <groupId>com.alibaba</groupId>
  18.         <artifactId>fastjson</artifactId>
  19.         <version>1.2.35</version>
  20.     </dependency>
  21. </dependencies>

因为所有的服务都要接入网关，而服务都在注册中心有记录，所以我们网关要与Nacos关联，首先需要在配置文件中与Nacos做配置并且在启动类开启Nacos

@EnableDiscoveryClient(启动类打上该注解)

  1. server:
  2.   port: 8083
  3. spring:
  4.   cloud:
  5.     nacos:
  6.       server-addr: localhost:8848
  7.   application:
  8.     name: geteway

将全部服务启动就可以看到我们的gateway也被注册到Nacos中啦

✨使用Gateway的三种方式

🍃方法一

  1. gateway:
  2.   discovery:
  3.     locator:
  4. #是否与服务发现组件进行结合,通过service-id(必须设置成大写)转发到具体的服务实例。默认 false
  5. #为true代表开启基于服务发现的路由规则。
  6.         enabled: true
  7. #配置之后访问时service-id无需大写
  8.         lower-case-service-id: true

注意：我们的gateway是与spring下的nacos的标签同级别可不要将它写在nacos下面

前面是通过服务直接访问的，后面则是通过网关向服务发起的请求，此时我们的请求已经被官网处理了。

🍃方法二

第二种方式是为了防止使用第一种方式的时候服务名字太长而导致的麻烦，这种方式类似于为服务名又起了一个别名。

  1.     gateway:
  2.       routes:
  3.       # 路由标识(id：标识,具有唯一性)
  4.       - id: user-consumer-api
  5.       #目标服务地址(uri：地址,请求转发后的地址),会自动从注册中心获得服务的IP,不需要手动写死
  6.         uri: lb://consume
  7.       #优先级,越小越优先
  8.         predicates:
  9.         # 路径匹配,
  10.            - Path=/aa/**
  11.         filters:
  12.       #前缀过滤,请求地址：http://localhost:8084/usr/hello
  13.       #此处配置去掉1个路径前缀,再配置上面的 Path=/usr/**,就将**转发到指定的微服务
  14.             - StripPrefix=1

这里如果使用的是http://localhost:8083/aa/test01就会映射到consume这个服务，并且通过前缀过滤会过滤掉aa拿到test01就会映射到consume/test01上，得到如下结果👇👇

🍃方法三

第三种方式是结合配置读取类进行的，我们将对服务的网关配置写在Nacos，然后再用这个读取类去进行读取，获取我们想要的路由信息。

  1.     gateway:
  2.       nacos:
  3.       server-addr: ${spring.cloud.nacos.server-addr}
  4.       data-id: dynamic-routing.json
  5.       group: DEFAULT_GROUP

首先需要新建一个POJO包将以下类进行创建

  1. package org.example.geteway.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import lombok.experimental.Accessors;
  8. import java.util.LinkedHashMap;
  9. import java.util.Map;
  11. /**
  12.  * @author hgh
  13.  */
  14. @SuppressWarnings("all")
  15. @Data
  16. @NoArgsConstructor
  17. @AllArgsConstructor
  18. @Accessors(chain = true)
  19. public class FilterEntity {
  21.     //过滤器对应的Name
  22.     private String name;
  24.     //路由规则
  25.     private Map<String, String> args = new LinkedHashMap<>();
  27. }
  1. package org.example.geteway.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import lombok.experimental.Accessors;
  7. import org.springframework.boot.context.properties.ConfigurationProperties;
  8. import org.springframework.stereotype.Component;
  10. @SuppressWarnings("all")
  11. @Data
  12. @NoArgsConstructor
  13. @AllArgsConstructor
  14. @Accessors(chain = true)
  15. @ConfigurationProperties(prefix = "gateway.nacos")
  16. @Component
  17. public class GatewayNacosProperties {
  19.     private String serverAddr;
  20.     private String dataId;
  21.     private String namespace;
  22.     private String group;
  24. }
  1. package org.example.geteway.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import lombok.experimental.Accessors;
  8. import java.util.LinkedHashMap;
  9. import java.util.Map;
  11. /**
  12.  * @author hgh
  13.  */
  14. @SuppressWarnings("all")
  15. @Data
  16. @NoArgsConstructor
  17. @AllArgsConstructor
  18. @Accessors(chain = true)
  19. public class PredicateEntity {
  21.     //断言对应的Name
  22.     private String name;
  24.     //断言规则
  25.     private Map<String, String> args = new LinkedHashMap<>();
  27. }
  1. package org.example.geteway.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import lombok.experimental.Accessors;
  8. import java.util.ArrayList;
  9. import java.util.List;
  11. /**
  12.  * @author hgh
  13.  */
  14. @SuppressWarnings("all")
  15. @Data
  16. @NoArgsConstructor
  17. @AllArgsConstructor
  18. @Accessors(chain = true)
  19. public class RouteEntity {
  21.     //路由id
  22.     private String id;
  24.     //路由断言集合
  25.     private List<PredicateEntity> predicates = new ArrayList<>();
  27.     //路由过滤器集合
  28.     private List<FilterEntity> filters = new ArrayList<>();
  30.     //路由转发的目标uri
  31.     private String uri;
  33.     //路由执行的顺序
  34.     private int order = 0;
  36. }

最后创建一个配置信息读取类，这个类是一个基于 Spring Cloud Gateway 和 Nacos 的动态路由配置类，它实现了一个 Spring 提供的事件推送接口 ApplicationEventPublisherAware。它的功能主要包括监听 Nacos 的配置变化、解析从 Nacos 读取的路由配置信息（json格式）、路由更新、以及组装和定义路由信息等。通过这个类，可以实现路由信息的动态管理和更新。

  1. package org.example.geteway;
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.alibaba.nacos.api.NacosFactory;
  6. import com.alibaba.nacos.api.PropertyKeyConst;
  7. import com.alibaba.nacos.api.config.ConfigService;
  8. import com.alibaba.nacos.api.config.listener.Listener;
  9. import com.alibaba.nacos.api.exception.NacosException;
  10. import com.fasterxml.jackson.databind.ObjectMapper;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.example.geteway.pojo.FilterEntity;
  13. import org.example.geteway.pojo.GatewayNacosProperties;
  14. import org.example.geteway.pojo.PredicateEntity;
  15. import org.example.geteway.pojo.RouteEntity;
  16. import org.springframework.beans.factory.annotation.Autowired;
  17. import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
  18. import org.springframework.cloud.gateway.filter.FilterDefinition;
  19. import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
  20. import org.springframework.cloud.gateway.route.RouteDefinition;
  21. import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
  22. import org.springframework.context.ApplicationEventPublisher;
  23. import org.springframework.context.ApplicationEventPublisherAware;
  24. import org.springframework.context.annotation.Bean;
  25. import org.springframework.stereotype.Component;
  26. import org.springframework.web.util.UriComponentsBuilder;
  27. import reactor.core.publisher.Mono;
  29. import java.net.URI;
  30. import java.util.ArrayList;
  31. import java.util.List;
  32. import java.util.Properties;
  33. import java.util.concurrent.Executor;
  35. /**
  36.  * 此类实现了Spring Cloud Gateway + nacos 的动态路由,
  37.  * 它实现一个Spring提供的事件推送接口ApplicationEventPublisherAware
  38.  */
  39. @SuppressWarnings("all")
  40. @Slf4j
  41. @Component
  42. public class DynamicRoutingConfig implements ApplicationEventPublisherAware {
  44.     @Autowired
  45.     private RouteDefinitionWriter routeDefinitionWriter;
  47.     @Autowired
  48.     private GatewayNacosProperties gatewayProperties;
  50.     @Autowired
  51.     private ObjectMapper mapper;
  53.     private ApplicationEventPublisher applicationEventPublisher;
  55.     @Override
  56.     public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
  57.         this.applicationEventPublisher = applicationEventPublisher;
  58.     }
  60.     /**
  61.      * 这个方法主要负责监听Nacos的配置变化,这里先使用参数构建一个ConfigService,
  62.      * 再使用ConfigService开启一个监听,
  63.      * 并且在监听的方法中刷新路由信息。
  64.      */
  65.     @Bean
  66.     public void refreshRouting() throws NacosException {
  67.         //创建Properties配置类
  68.         Properties properties = new Properties();
  69.         System.out.println(gatewayProperties);
  70.         //设置nacos的服务器地址,从配置类GatewayProperties中获取
  71.         properties.put(PropertyKeyConst.SERVER_ADDR, gatewayProperties.getServerAddr());
  72.         //设置nacos的命名空间,表示从具体的命名空间中获取配置信息,不填代表默认从public获得
  73.         if (gatewayProperties.getNamespace() != null) {
  74.             properties.put(PropertyKeyConst.NAMESPACE, gatewayProperties.getNamespace());
  75.         }
  76.         //根据Properties配置创建ConfigService类
  77.         ConfigService configService = NacosFactory.createConfigService(properties);
  78.         //获得nacos中已有的路由配置
  79.         String json = configService.getConfig(gatewayProperties.getDataId(), gatewayProperties.getGroup(), 5000);
  80.         this.parseJson(json);
  82.         //添加监听器,监听nacos中的数据修改事件
  83.         configService.addListener(gatewayProperties.getDataId(), gatewayProperties.getGroup(), new Listener() {
  84.             @Override
  85.             public Executor getExecutor() {
  86.                 return null;
  87.             }
  89.             /**
  90.              * 用于接收远端nacos中数据修改后的回调方法
  91.              */
  92.             @Override
  93.             public void receiveConfigInfo(String configInfo) {
  94.                 log.warn(configInfo);
  95.                 //获取nacos中修改的数据并进行转换
  96.                 parseJson(configInfo);
  97.             }
  98.         });
  100.     }
  102.     /**
  103.      * 解析从nacos读取的路由配置信息(json格式)
  104.      */
  105.     public void parseJson(String json) {
  106.         log.warn("从Nacos返回的路由配置(JSON格式)：" + json);
  107.         boolean refreshGatewayRoute = JSONObject.parseObject(json).getBoolean("refreshGatewayRoute");
  108.         if (refreshGatewayRoute) {
  109.             List<RouteEntity> list = JSON.parseArray(JSONObject.parseObject(json).getString("routeList")).toJavaList(RouteEntity.class);
  110.             for (RouteEntity route : list) {
  111.                 update(assembleRouteDefinition(route));
  112.             }
  113.         } else {
  114.             log.warn("路由未发生变更");
  115.         }
  116.     }
  118.     /**
  119.      * 路由更新
  120.      */
  121.     public void update(RouteDefinition routeDefinition) {
  123.         try {
  124.             this.routeDefinitionWriter.delete(Mono.just(routeDefinition.getId()));
  125.             log.warn("路由删除成功:" + routeDefinition.getId());
  126.         } catch (Exception e) {
  127.             log.error(e.getMessage(), e);
  128.         }
  129.         try {
  130.             routeDefinitionWriter.save(Mono.just(routeDefinition)).subscribe();
  131.             this.applicationEventPublisher.publishEvent(new RefreshRoutesEvent(this));
  132.             log.warn("路由更新成功:" + routeDefinition.getId());
  133.         } catch (Exception e) {
  134.             log.error(e.getMessage(), e);
  135.         }
  137.     }
  139.     /**
  140.      * 路由定义
  141.      */
  142.     public RouteDefinition assembleRouteDefinition(RouteEntity routeEntity) {
  144.         RouteDefinition definition = new RouteDefinition();
  146.         // ID
  147.         definition.setId(routeEntity.getId());
  149.         // Predicates
  150.         List<PredicateDefinition> pdList = new ArrayList<>();
  151.         for (PredicateEntity predicateEntity : routeEntity.getPredicates()) {
  152.             PredicateDefinition predicateDefinition = new PredicateDefinition();
  153.             predicateDefinition.setArgs(predicateEntity.getArgs());
  154.             predicateDefinition.setName(predicateEntity.getName());
  155.             pdList.add(predicateDefinition);
  156.         }
  157.         definition.setPredicates(pdList);
  159.         // Filters
  160.         List<FilterDefinition> fdList = new ArrayList<>();
  161.         for (FilterEntity filterEntity : routeEntity.getFilters()) {
  162.             FilterDefinition filterDefinition = new FilterDefinition();
  163.             filterDefinition.setArgs(filterEntity.getArgs());
  164.             filterDefinition.setName(filterEntity.getName());
  165.             fdList.add(filterDefinition);
  166.         }
  167.         definition.setFilters(fdList);
  169.         // URI
  170.         URI uri = UriComponentsBuilder.fromUriString(routeEntity.getUri()).build().toUri();
  171.         definition.setUri(uri);
  173.         return definition;
  174.     }
  176. }

现在需要我们去Nacos创建对应的配置 dynamic-routing.json

  1. {
  2.   "refreshGatewayRoute": true,
  3.   "routeList": [
  4.     {
  5.       "id": "consumer-api",
  6.       "predicates": [
  7.         {
  8.           "name": "Path",
  9.           "args": {
  10.             "_genkey_0": "/cum/**"
  11.           }
  12.         }
  13.       ],
  14.       "filters": [
  15.         {
  16.           "name": "StripPrefix",
  17.           "args": {
  18.             "_genkey_0": "1"
  19.           }
  20.         }
  21.       ],
  22.       "uri": "lb://consumer",
  23.       "order": 0
  24.     },
  25.     {
  26.       "id": "provider-api",
  27.       "predicates": [
  28.         {
  29.           "name": "Path",
  30.           "args": {
  31.             "_genkey_0": "/pvr/**"
  32.           }
  33.         }
  34.       ],
  35.       "filters": [
  36.         {
  37.           "name": "StripPrefix",
  38.           "args": {
  39.             "_genkey_0": "1"
  40.           }
  41.         }
  42.       ],
  43.       "uri": "lb://provider",
  44.       "order": 0
  45.     }
  46.   ]
  47. }

现在我们就可以通过获取Nacos所配置的路由进行访问了

如果你更改了Nacos的信息也会实时发送改变不用重启服务器

请添加图片描述​

到这里我的分享就结束了，欢迎到评论区探讨交流！！

💖如果觉得有用的话还请点个赞吧 💖

标签： spring cloud spring 后端
本文转载自: https://blog.csdn.net/weixin_74318097/article/details/135487568
版权归原作者 Java方文山 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Spring Cloud】Gateway组件的三种使用方式”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？