微服务网关springcloud gateway整合nacos实现动态路由

1. 添加依赖

    com.alibaba.cloud
    spring-cloud-starter-alibaba-nacos-config

2. 添加配置

spring:
  cloud:
    nacos:
      config:
        # 配置中心地址
        server-addr: 127.0.0.1:8848
        # 配置文件格式
        file-extension: yml
        username:
        password:

3. 定义读取配置和监听类

package com.demo.config;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executor;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;
import com.ftsafe.gateway.filter.AuthFilter;

import reactor.core.publisher.Mono;

@Component
public class NacosDynamicRouteService implements ApplicationEventPublisherAware {
 
	private static final Logger log = LoggerFactory.getLogger(AuthFilter.class);
	
	private String dataId = "app-gateway-route-dev.yml"; 
    private String group = "DEFAULT_GROUP";    
    public static final long DEFAULT_TIMEOUT = 30000;
 
    @Value("${spring.cloud.nacos.config.server-addr}")
    private String serverAddr;
 
    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;
 
    private ApplicationEventPublisher applicationEventPublisher;
 
    private static final List ROUTE_LIST = new ArrayList<>();
    
    // 增加网关启动时，更新一次配置
    @PostConstruct
    public void init() {        
    	log.info("gateway route init...");
    	
        try{
        	ConfigService configService = NacosFactory.createConfigService(serverAddr);
        	
            if(configService == null){
                log.warn("initConfigService fail");
                return;
            }
            String configInfo = configService.getConfig(dataId, group, DEFAULT_TIMEOUT);
            log.info("获取网关当前配置:\r\n{}",configInfo);
            List definitionList = JSON.parseArray(configInfo, RouteDefinition.class);
            for(RouteDefinition definition : definitionList){
                log.info("update route : {}",definition.toString());                            	
            	addRoute(definition);
            }
        } catch (Exception e) {
            log.error("初始化网关路由时发生错误",e);
        }        
    }
 
    @PostConstruct
    public void dynamicRouteByNacosListener() {
        try {
            ConfigService configService = NacosFactory.createConfigService(serverAddr);
            configService.getConfig(dataId, group, 5000);
            configService.addListener(dataId, group, new Listener() {
                @Override
                public void receiveConfigInfo(String configInfo) {
                    
                	// 手动新配置以后，先清除原来的配置
                	clearRoute();
                    
                    try {
                    	
                    	List gatewayRouteDefinitions = JSONObject.parseArray(configInfo, RouteDefinition.class);
               		
                        for (RouteDefinition routeDefinition : gatewayRouteDefinitions) {
                            addRoute(routeDefinition);
                        }
                        publish();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
 
                @Override
                public Executor getExecutor() {
                    return null;
                }
            });
        } catch (NacosException e) {
            e.printStackTrace();
        }
    }
 
    
    private void clearRoute() {
        for(String id : ROUTE_LIST) {
            this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
        }
        ROUTE_LIST.clear();
    }
 
    private void addRoute(RouteDefinition definition) {
        try {
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            ROUTE_LIST.add(definition.getId());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private void publish() {
        this.applicationEventPublisher.publishEvent(new RefreshRoutesEvent(this.routeDefinitionWriter));
    }
 
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }
}

总体思路是，程序启动的时候，读取一次配置，并更新到网关规则，并添加一个配置监听，当配置变更时，重新读取一次配置，更新到网关规则中。

4. 在nacos中添加配置

dataId:app-gateway-route-dev.yml

格式：json

内容：

[{
  "id": "test-route",
  "uri": "lb://ftcsp-springcloud-demo-web",
  "predicates":[{
    "args":{"pattern":"/api-test/**"},
    "name":"Path"
  }],
  "filters":[{
    "name":"StripPrefix",
    "args":[{"parts":"0"}]
    }]           
}]

因为读取配置数据的时候，采用的是json方式，所以配置信息只能以json方式进行配置。