0
0

【SpringCloud Alibaba】Nacos Config配置管理与Gateway 网关

一、Config 远程配置

1.1 config 介绍

  1.     微服务意味着要将单体应用中的业务拆分成一个个子服务,每个服务的粒度相对较小,因此系统中会出现大 量的服务。 由于每个服务都需要必要的配置信息才能运行,所以一套集中式的,动态的配置管理设施是必不可少的。
  3.     Spring Cloud 提供了 ConfigServer来解决这个问题，Spring Cloud Config 为微服务架构中的微服务提供集中化的外部配置支持,配置服务器为各个不同微服 务应用的所有环境提供了一个中心化的外部配置。

一个使用微服务架构的应用系统可能会包括成百上千个微服务,配置各部相同,需求各不相同：

  • 不同环境不同配置：例如数据源在不同的环境（开发,测试,生产）是不同的
  • 运行期间可以动态调整。例如根据各个微服务的负载状况,动态调整数据源连接池大小或者熔断阀 值,并且调整时不停止微服务（配置修改后可以自动更新）

** 使用 Spring Cloud Alibaba Nacos Config,您可以在 Nacos Server 集中管理你 Spring Cloud 应用的外 部属性配置。 **

1.2 bootstrap.yml 配置文件

SpringBoot 默认支持properties和YAML两种格式的配置文件。

  1. bootstrap.yml（bootstrap.properties）用来程序引导时执行,应用于更加早期配置信息读取,如可以使用来配置application.yml中使用到参数等
  2. application.yml（application.properties) 应用程序特有配置信息,可以用来配置后续各个模块中需使用 的公共参数等。

bootstrap.yml 先于 application.yml 加载 ！！！

1、添加依赖

  1.         <!--config配置管理-->
  2.         <dependency>
  3.             <groupId>com.alibaba.cloud</groupId>
  4.             <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.cloud</groupId>
  8.             <artifactId>spring-cloud-starter-bootstrap</artifactId>
  9.         </dependency>

2、添加bootsrap.yml配置

  1. server:
  2.   port: 8080
  3. spring:
  4.   application:
  5.     name: basketball
  6.   cloud:
  7.     nacos:
  8.       server-addr: localhost:8848
  9.       config:
  10.         server-addr: ${spring.cloud.nacos.server-addr}
  11.         #指定nacos配置中心地址
  12.         prefix: ${spring.application.name}
  13.         file-extension: yaml # 使用的 nacos 配置集的 dataId 的文件拓展名，同时也是Nacos 配置集的配置格式，默认为 properties
  14.         group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
  15.         # 共享配置集数组
  16.         shared-configs:
  17.           - data-id: redis.yml
  18.             group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
  19.             refresh: true # 是否自动刷新配置，默认为 fals
  20.           - data-id: basketball.yml
  21.             group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
  22.             refresh: true # 是否自动刷新配置，默认为 false
  23.         # 使用的 nacos 的命名空间（指定项目环境），
  24.         namespace: 363830b6-d72e-4868-a028-6be9c2cfd267

3、对应Nacos也添加配置信息

redis.yml：

basketball.yml：

4、编写两个配置类读取Nacos配置文件属性值

5、编写测试接口类

  1. package com.example.basketball.controller;
  3. import com.example.basketball.config.EmailProperies;
  4. import com.example.basketball.config.RedisProperies;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.*;
  8. import pojo.dto.IkunDto;
  10. import java.util.Map;
  12. @Slf4j
  13. @RestController
  14. @RequestMapping("/user")
  15. public class ConfigController {
  17.     @Autowired
  18.     private EmailProperies emailProperies;
  19.     @Autowired
  20.     private RedisProperies redisProperies;
  22.     /*编写测试接口读取远程配置信息*/
  23.     @RequestMapping("/test1")
  24.     public Object test01() {
  25.         return emailProperies;
  26.     }
  28.     @RequestMapping("/test2")
  29.     public Object test02() {
  30.         return redisProperies;
  31.     }
  33. }

6、启动类添加刷新配置注解

7、测试

  1.     这样我们就能将一些基本配置信息添加到Nacot进行远程配置管理，**其实这里还有一个缺点：如果我们要个更换环境需要修改指定的nacos命名空间**。![](https://img-blog.csdnimg.cn/direct/30e1b3d486da4626a2436951248f0591.png)在这我们其实可以不写，把项目导成jar包，直接设置指定命名空间运行项目：

cmd指令示例：

java -jar** xxx.jar** --spring.cloud.nacos.config.namespace=xxx

二、Gateway 网关

2.1 gateway 介绍

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

1️⃣路由（route）：路由是网关最基础的部分，路由信息由一个ID，一个目的URL、一组断言（predicates）工厂和一 组Filter组成。如果断言为真，则说明请求URL和配置的路由匹配。

2️⃣断言（Predicate）：Java8中的断言函数，Spring Cloud Gateway中的断言函数输入类型是 Spring5.0框架中的ServerWebExchange。Spring Cloud Gateway中的断言函数允许开发者去定义匹配 来自http Request中的任何信息，比如请求头和参数等。

3️⃣过滤器（Filter）：一个标准的Spring WebFilter，Spring Cloud Gateway中的Filter分为两种类型： Gateway Filter和Global Filter。过滤器Filter可以对请求和响应进行处理

2.2 gateway 使用

创建网关服务：

添加依赖 ：

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-webflux</artifactId>
  5.         </dependency>
  6.         <dependency>
  7.             <groupId>org.springframework.cloud</groupId>
  8.             <artifactId>spring-cloud-starter-gateway</artifactId>
  9.         </dependency>
  10.         <!--阿里json解析-->
  11.         <dependency>
  12.             <groupId>com.alibaba</groupId>
  13.             <artifactId>fastjson</artifactId>
  14.             <version>1.2.35</version>
  15.         </dependency>
  16.     </dependencies>

2.2.1 方式一

本地yml配置

  1. server:
  2.   port: 8082
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.     nacos:
  8.       server-addr: localhost:8848
  9.     gateway:
  10.       routes:
  11.         #路由标识(id：标识,具有唯一性)配合读取类使用
  12.         - id: user-basketball-api
  13.           #目标服务地址(uri：地址,请求转发后的地址),会自动从注册中心获得服务的IP,不需要手动写死
  14.           uri: lb://ikun
  15.           #优先级,越小越优先
  16.           order: 999
  17.           #路由条件(predicates：断言)
  18.           predicates:
  19.             # 路径匹配,
  20.             - Path=/kun/**
  21.           filters:
  22.             #路径前缀删除示例
  23.             - StripPrefix=1
  1.     这**样同时启动gateway和ikun（消费者）服务，通过网关端口8082路径kun就能访问ikun服务的接口方法。但是这样还是不太方便，建议使用方法二动态路由远程配置**👇

2.2.2 方式二（动态路由）

**如果是跳到该目录的小帅和小美请看上面的服务创建与依赖配置哦！ **

1、修改yml配置 ：

  1. server:
  2.   port: 8082
  3. spring:
  4.   application:
  5.     name: gateway
  6.   cloud:
  7.     nacos:
  8.       server-addr: localhost:8848
  9. #自定义读取配置
  10. gateway:
  11.   nacos:
  12.     server-addr: ${spring.cloud.nacos.server-addr}
  13.     #namespace: xxx-xx-xx-xx （指定环境命名空降如[dev,test,pro...]）
  14.     data-id: dynamic-routing.json
  15.     group: DEFAULT_GROUP

2、添加Nacos远程配置信息

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

3、添加相关远程配置解析类

  1. GatewayNacosProperties:
  1. package com.example.gateway.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; //nacos服务地址
  20.     private String dataId; //配置文件名称
  21.     private String namespace; //指定命名空间
  22.     private String group; //分组
  24. }
  1. RouteEntity：
  1. package com.example.gateway.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 云村小威
  13.  */
  14. @SuppressWarnings("all")
  15. @Data
  16. @NoArgsConstructor
  17. @AllArgsConstructor
  18. @Accessors(chain = true)
  19. public class RouteEntity {
  21.     //路由id
  22.     private String id;
  23.     //路由断言集合
  24.     private List<PredicateEntity> predicates = new ArrayList<>();
  25.     //路由过滤器集合
  26.     private List<FilterEntity> filters = new ArrayList<>();
  27.     //路由转发的目标uri
  28.     private String uri;
  29.     //路由执行的顺序
  30.     private int order = 0;
  32. }
  1. PredicateEntity：
  1. package com.example.gateway.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 云村小威
  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. FilterEntity：
  1. package com.example.gateway.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 云村小威
  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. }

DynamicRoutingConfig ： 🌟

  1. package com.example.gateway;
  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.example.gateway.pojo.FilterEntity;
  11. import com.example.gateway.pojo.GatewayNacosProperties;
  12. import com.example.gateway.pojo.PredicateEntity;
  13. import com.example.gateway.pojo.RouteEntity;
  14. import com.fasterxml.jackson.databind.ObjectMapper;
  15. import lombok.extern.slf4j.Slf4j;
  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. }

4、接口调用测试

** 这样就可以通过配置统一管理服务接口， 如下图所示；通过网关端口8082可访问不同服务的接口实现路由转发、处理请求和响应。**

标签： spring cloud gateway java
本文转载自: https://blog.csdn.net/Justw320/article/details/135442845
版权归原作者 云村小威 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【SpringCloud Alibaba】Nacos Config配置管理与Gateway 网关”的评论:

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

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

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

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

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

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

Kafka学习笔记

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