使用Nacos实现动态路由的步骤和代码示例_Java

最近写到使用 nacos 实现动态路由的问题，整理了一下思路和案例，分享给大家。

使用 nacos 实现 spring cloud gateway 的动态路由，主要涉及到以下几个步骤：

添加依赖：在 spring cloud gateway 应用的 pom.xml 文件中添加 nacos 相关依赖。
配置 nacos：在 application.yml 或 application.properties 文件中配置 nacos 服务地址。
启用动态路由：在配置文件中启用 nacos 动态路由功能。
创建动态路由配置：在 nacos 配置中心创建动态路由的配置信息。
监听配置变化：在 spring cloud gateway 应用中监听 nacos 配置变化，动态更新路由规则。

下面是具体的实现步骤和代码案例，来看一下：

1. 添加依赖

在 pom.xml 文件中添加 spring cloud gateway 和 nacos 相关依赖：

<dependencies>
    <!-- spring cloud gateway -->
    <dependency>
        <groupid>org.springframework.cloud</groupid>
        <artifactid>spring-cloud-starter-gateway</artifactid>
    </dependency>
    <!-- spring cloud alibaba nacos discovery -->
    <dependency>
        <groupid>com.alibaba.cloud</groupid>
        <artifactid>spring-cloud-starter-alibaba-nacos-discovery</artifactid>
    </dependency>
    <!-- spring cloud alibaba nacos config -->
    <dependency>
        <groupid>com.alibaba.cloud</groupid>
        <artifactid>spring-cloud-starter-alibaba-nacos-config</artifactid>
    </dependency>
</dependencies>

2. 配置 nacos

在 application.yml 文件中配置 nacos 服务地址：

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # nacos 服务地址
      config:
        server-addr: 127.0.0.1:8848 # nacos 配置中心地址
        file-extension: yml # 配置文件格式
        group: default_group # 配置分组
        namespace: # 配置命名空间

3. 启用动态路由

在 application.yml 文件中启用 nacos 动态路由功能：

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 开启从注册中心动态创建路由的功能
          lower-case-service-id: true # 使用小写服务名，默认是大写

4. 创建动态路由配置

在 nacos 配置中心创建一个配置文件，例如 gateway-routes.yml，内容如下：

spring:
  cloud:
    gateway:
      routes:
        - id: my-service-route
          uri: lb://my-service
          predicates:
            - path=/my-service/**
          filters:
            - stripprefix=1

5. 监听配置变化

在 spring cloud gateway 应用中，创建一个配置类来监听 nacos 配置变化，并刷新路由规则：

import org.springframework.cloud.context.environment.environmentchangeevent;
import org.springframework.cloud.gateway.route.routedefinitionlocator;
import org.springframework.cloud.gateway.route.routedefinitionwriter;
import org.springframework.context.event.eventlistener;
import org.springframework.stereotype.component;

@component
public class dynamicrouteservice {

    private final routedefinitionwriter routedefinitionwriter;
    private final routedefinitionlocator routedefinitionlocator;

    public dynamicrouteservice(routedefinitionwriter routedefinitionwriter,
                                routedefinitionlocator routedefinitionlocator) {
        this.routedefinitionwriter = routedefinitionwriter;
        this.routedefinitionlocator = routedefinitionlocator;
    }

    @eventlistener
    public void onenvironmentchange(environmentchangeevent event) {
        if (event.getkeys().contains("spring.cloud.gateway.routes")) {
            routedefinitionlocator.getroutedefinitions()
                .subscribe(routedefinitions -> {
                    routedefinitionwriter.delete("*").subscribe();
                    routedefinitionwriter.save(routedefinitions).subscribe();
                });
        }
    }
}

这个类会监听环境变化事件，当检测到 spring.cloud.gateway.routes 配置项发生变化时，会重新加载和刷新路由规则。

我们通过使用 nacos 实现 spring cloud gateway 的动态路由。通过在 nacos 配置中心维护路由配置，可以实现不重启网关服务的情况下动态更新路由规则，这对于微服务架构中的服务治理非常有用。

在使用 nacos 动态路由时，如果服务下线了，spring cloud gateway 会如何响应？

当使用 nacos 动态路由时，如果服务下线，spring cloud gateway 会通过 nacos 的服务发现机制感知到这一变化，并根据配置的动态路由规则进行调整。如何配置 spring cloud gateway 以响应服务下线的情况呢？来，上代码：

首先，确保咱们的项目中已经添加了 spring cloud gateway 和 spring cloud alibaba nacos discovery 的依赖。

1. application.yml 配置

在 application.yml 中配置 nacos 服务发现和动态路由：

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848 # nacos 服务地址
    gateway:
      routes:
        - id: my-service-route
          uri: lb://my-service
          predicates:
            - path=/my-service/**
          filters:
            - stripprefix=1
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true

2. nacos 配置中心的动态路由配置

在 nacos 配置中心创建一个名为 gateway-routes.json 的配置文件，内容如下：

{
  "spring": {
    "cloud": {
      "gateway": {
        "routes": [
          {
            "id": "my-service-route",
            "uri": "lb://my-service",
            "predicates": [
              {
                "name": "path",
                "args": {
                  "_genkey_0": "/my-service/**"
                }
              }
            ],
            "filters": [
              {
                "name": "stripprefix",
                "args": {
                  "_genkey_1": "1"
                }
              }
            ]
          }
        ]
      }
    }
  }
}

3. 动态路由配置监听

创建一个配置类来监听 nacos 配置变化，并刷新路由规则：

import com.alibaba.cloud.nacos.nacosconfigmanager;
import com.alibaba.cloud.nacos.nacosconfigproperties;
import com.alibaba.nacos.api.nacosfactory;
import com.alibaba.nacos.api.config.configservice;
import com.alibaba.nacos.api.exception.nacosexception;
import com.alibaba.nacos.api.model.properties;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.boot.applicationarguments;
import org.springframework.boot.applicationrunner;
import org.springframework.cloud.gateway.route.routedefinition;
import org.springframework.cloud.gateway.route.routedefinitionrepository;
import org.springframework.cloud.gateway.route.routesrefreshedevent;
import org.springframework.context.applicationeventpublisher;
import org.springframework.stereotype.component;

import java.util.properties as javaproperties;

@component
public class nacosdynamicroute implements applicationrunner {

    @autowired
    private routedefinitionrepository routedefinitionrepository;

    @autowired
    private applicationeventpublisher publisher;

    private configservice configservice;

    public nacosdynamicroute(nacosconfigproperties properties) throws nacosexception {
        javaproperties javaproperties = new javaproperties();
        javaproperties.setproperty("serveraddr", properties.getserveraddr());
        javaproperties.setproperty("namespace", properties.getnamespace());
        configservice = nacosfactory.createconfigservice(javaproperties);
    }

    @override
    public void run(applicationarguments args) {
        try {
            string routejson = configservice.getconfig("gateway-routes.json", "default_group", 5000);
            refreshroutes(routejson);
            configservice.addlistener("gateway-routes.json", "default_group", s -> refreshroutes(s));
        } catch (nacosexception e) {
            e.printstacktrace();
        }
    }

    private void refreshroutes(string routejson) {
        springcloudroutedefinition routedefinition = jsonutils.deserialize(routejson, springcloudroutedefinition.class);
        routedefinitionrepository.delete("*").subscribe();
        routedefinitionrepository.save(routedefinition.getroutedefinitions()).subscribe();
        publisher.publishevent(new routesrefreshedevent(this));
    }

    // 内部类，用于反序列化 nacos 配置
    static class springcloudroutedefinition {
        private routedefinition[] routedefinitions;

        // getter 和 setter 省略
    }
}

nacosdynamicroute 类会在应用启动时从 nacos 配置中心加载路由配置，并注册一个监听器来监听配置变化。当配置发生变化时，它会重新加载路由配置并刷新路由规则。

以上就是使用nacos实现动态路由的步骤和代码示例的详细内容，更多关于nacos动态路由的资料请关注代码网其它相关文章！