使用mysql数据库、nacos配置中心两种方式实现gateway动态路由_gateway动态路由数据库 nacos redis-程序员宅基地

1、MYSQL实现

表结构设计
在这里插入图片描述

代码设计

package com.example.config;

import com.alibaba.fastjson.JSON;
import com.example.domain.Filters;
import com.example.domain.Predicates;
import com.example.domain.Routes;
import com.example.service.IFiltersService;
import com.example.service.IPredicatesService;
import com.example.service.IRoutesService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.FilterDefinition;
import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionLocator;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.*;
import java.util.stream.Collectors;

@Component
@EnableScheduling
public class DynamicRouteServiceImplByMysql {
    

	@Autowired
	private DynamicRouteServiceImpl dynamicRouteService;
	@Autowired
	private RouteDefinitionLocator routeDefinitionLocator;

	@Autowired
	private IFiltersService iFiltersService;

	@Autowired
	private IRoutesService iRoutesService;

	@Autowired
	private IPredicatesService iPredicatesService;


	@PostConstruct
	public void init() {
    
		dynamicRouteByMysql();
	}

	/**
	 * 从数据库加载路由
	 *
	 */
	public void dynamicRouteByMysql() {
    
		try {
    
			List<Routes> routes = iRoutesService.selectRoutesAll();
			for (Routes route:routes){
    
				//获取filters
				List<FilterDefinition> filters=HandlerFilterList(route);
				//predicates
				List<PredicateDefinition> predicates =HandlerPredicateList(route);
				//给routeDefinition对象赋值
				RouteDefinition routeDefinition=new RouteDefinition();
				routeDefinition.setId(route.getId());
				URI url=new URI(route.getUri());
				routeDefinition.setUri(url);
				routeDefinition.setFilters(filters);
				routeDefinition.setPredicates(predicates);
				route.setStatus("Y");
				iRoutesService.updateRoutes(route);
				//RouteDefinition routeDefinition = (RouteDefinition)JSON.parse(routeJson);
				dynamicRouteService.add(routeDefinition);
			}
		} catch (Exception e) {
    
			e.printStackTrace();
		}
	}

	@Scheduled(fixedRate=1000*10)
	public void updateRoute() {
    
		try {
    
			List<Routes> routes = iRoutesService.selectRoutesAll();
			List<RouteDefinition> definitionList=new ArrayList<>();
			List<RouteDefinition> runningDefinitionList = Optional.ofNullable(routeDefinitionLocator.getRouteDefinitions()).map(Flux::collectList).map(Mono::block).orElse(Collections.emptyList());
			for (Routes route:routes){
    
				//获取filters
				List<FilterDefinition> filters=HandlerFilterList(route);
				//predicates
				List<PredicateDefinition> predicates =HandlerPredicateList(route);
				//给routeDefinition对象赋值
				RouteDefinition routeDefinition=new RouteDefinition();
				routeDefinition.setId(route.getId());
				URI url=new URI(route.getUri());
				routeDefinition.setUri(url);
				routeDefinition.setFilters(filters);
				routeDefinition.setPredicates(predicates);
				//RouteDefinition routeDefinition = (RouteDefinition)JSON.parse(routeJson);
				dynamicRouteService.update(routeDefinition);
				route.setStatus("Y");
				iRoutesService.updateRoutes(route);
				definitionList.add(routeDefinition);
			}
		/*List<RouteDefinition> definitionList = JSON.parseArray(configInfo, RouteDefinition.class);
		for (RouteDefinition definition : definitionList) {
			dynamicRouteService.update(definition);
		}*/
			List<String> newRunningDefinitionIds = definitionList.stream().map(RouteDefinition::getId).collect(Collectors.toList());
			runningDefinitionList.stream().map(RouteDefinition::getId)
					.filter(routeId -> !newRunningDefinitionIds.contains(routeId)).forEach(this::deleteRoute);
		}catch (Exception e){
    
			e.printStackTrace();
		}

	}
	private void deleteRoute(String routeId) {
    
		dynamicRouteService.delete(routeId);
	}

	/**
	 * 处理PredicateDefinition
	 * @return
	 */
	public List<PredicateDefinition> HandlerPredicateList(Routes route) {
    
		List<PredicateDefinition> predicates = new ArrayList<>();
		List<Predicates> predicateList = iPredicatesService.selectPredicatesListByRoutes_id(route.getId());
		for (Predicates predicate:predicateList){
    
			PredicateDefinition predicateDefinition = new PredicateDefinition();
			Map<String, String> args = predicate.getArgs();
			String[] strings = predicate.getValue().split(",");
			for (int i=0;i<strings.length;i++){
    
				String key = "_genkey_"+i;
				args.put(key,strings[i]);
			}
			predicateDefinition.setName(predicate.getName());
			predicateDefinition.setArgs(args);
			predicates.add(predicateDefinition);
		}
		return predicates;
	}
	/**
	 *处理FilterDefinition
	 * @return
	 */
	public List<FilterDefinition> HandlerFilterList(Routes route) {
    
		List<FilterDefinition> filters = new ArrayList<>();
		List<Filters> filterList = iFiltersService.selectFiltersListByRoutes_id(route.getId());
		for (Filters filter:filterList){
    
			FilterDefinition filterDefinition = new FilterDefinition();
			Map<String, String> args = filter.getArgs();
			String[] strings = filter.getValue().split(",");
			for (int i=0;i<strings.length;i++){
    
				String key = "_genkey_"+i;
				args.put(key,strings[i]);
			}
			filterDefinition.setName(filter.getName());
			filterDefinition.setArgs(args);
			filters.add(filterDefinition);
		}
		return filters;
	}

}
码片

package com.example.config;

import org.springframework.beans.factory.annotation.Autowired;
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.Service;
import reactor.core.publisher.Mono;

@Service
public class DynamicRouteServiceImpl implements ApplicationEventPublisherAware {
    

    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;

    private ApplicationEventPublisher publisher;

    /**
     * ����·��
     *
     * @param definition
     * @return
     */
    public String add(RouteDefinition definition) {
    
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
        return "success";
    }


    /**
     * ����·��
     *
     * @param definition
     * @return
     */
    public String update(RouteDefinition definition) {
    
        try {
    
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "success";
        } catch (Exception e) {
    
            return "update route  fail";
        }


    }

    /**
     * ɾ��·��
     *
     * @param id
     * @return
     */
    public String delete(String id) {
    
        try {
    
            this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "delete success";
        } catch (Exception e) {
    
            e.printStackTrace();
            return "delete fail";
        }

    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
    
        this.publisher = applicationEventPublisher;
    }

}

说明：数据库这种方式是我们领导要求的，加了定时器轮询，误差和定时器轮询的间隔时间有关，这样做的好处是可以做成界面话展示，方便操作，界面大致如下：

在这里插入图片描述

2、nacos配置中心实现

代码设计

package com.example.config;

import org.springframework.beans.factory.annotation.Autowired;
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.Service;
import reactor.core.publisher.Mono;

@Service
public class DynamicRouteServiceImpl implements ApplicationEventPublisherAware {
    

    @Autowired
    private RouteDefinitionWriter routeDefinitionWriter;

    private ApplicationEventPublisher publisher;

    /**
     * ����·��
     *
     * @param definition
     * @return
     */
    public String add(RouteDefinition definition) {
    
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
        return "success";
    }


    /**
     * ����·��
     *
     * @param definition
     * @return
     */
    public String update(RouteDefinition definition) {
    
        try {
    
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "success";
        } catch (Exception e) {
    
            return "update route  fail";
        }


    }

    /**
     * ɾ��·��
     *
     * @param id
     * @return
     */
    public String delete(String id) {
    
        try {
    
            this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "delete success";
        } catch (Exception e) {
    
            e.printStackTrace();
            return "delete fail";
        }

    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
    
        this.publisher = applicationEventPublisher;
    }

}

package com.example.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

@Configuration
public class GatewayConfig {
    

    @Value("${spring.cloud.nacos.config.server-addr}")
    private String nacosServerAddr;
    @Value("${spring.cloud.nacos.config.namespace}")
    private String nacosNamespace;

    @Value("${nacos.gateway.route.config.data-id}")
    private String nacosRouteDataId;
    @Value("${nacos.gateway.route.config.group}")
    private String nacosRouteGroup;

    public String getNacosServerAddr() {
    
        return nacosServerAddr;
    }

    public void setNacosServerAddr(String nacosServerAddr) {
    
        this.nacosServerAddr = nacosServerAddr;
    }

    public String getNacosNamespace() {
    
        return nacosNamespace;
    }

    public void setNacosNamespace(String nacosNamespace) {
    
        this.nacosNamespace = nacosNamespace;
    }

    public String getNacosRouteDataId() {
    
        return nacosRouteDataId;
    }

    public void setNacosRouteDataId(String nacosRouteDataId) {
    
        this.nacosRouteDataId = nacosRouteDataId;
    }

    public String getNacosRouteGroup() {
    
        return nacosRouteGroup;
    }

    public void setNacosRouteGroup(String nacosRouteGroup) {
    
        this.nacosRouteGroup = nacosRouteGroup;
    }
}

package com.example.config;

import com.alibaba.fastjson.JSON;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionLocator;
import org.springframework.stereotype.Component;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import javax.annotation.PostConstruct;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Properties;
import java.util.concurrent.Executor;
import java.util.stream.Collectors;

//@Component
public class DynamicRouteServiceImplByNacos {
    

	@Autowired
	private DynamicRouteServiceImpl dynamicRouteService;
	@Autowired
	private GatewayConfig gatewayConfig;
	@Autowired
	private RouteDefinitionLocator routeDefinitionLocator;

	@PostConstruct
	public void init() {
    
		dynamicRouteByNacosListener(gatewayConfig.getNacosRouteDataId(), gatewayConfig.getNacosRouteGroup());
	}

	/**
	 * ����Nacos Server�·��Ķ�̬·������
	 *
	 * @param dataId
	 * @param group
	 */
	public void dynamicRouteByNacosListener(String dataId, String group) {
    
		try {
    
			Properties properties = new Properties();
			properties.setProperty("serverAddr", gatewayConfig.getNacosServerAddr());
			properties.setProperty("namespace", gatewayConfig.getNacosNamespace());
			ConfigService configService = NacosFactory.createConfigService(properties);
			String configInfo = configService.getConfig(dataId, group, 5000);
			List<RouteDefinition> definitionList = JSON.parseArray(configInfo, RouteDefinition.class);
			for (RouteDefinition definition : definitionList) {
    
				dynamicRouteService.add(definition);
			}
			configService.addListener(dataId, group, new Listener() {
    
				@Override
				public void receiveConfigInfo(String configInfo) {
    
					List<RouteDefinition> runningDefinitionList = Optional.ofNullable(routeDefinitionLocator.getRouteDefinitions()).map(Flux::collectList).map(Mono::block).orElse(Collections.emptyList());
					List<RouteDefinition> definitionList = JSON.parseArray(configInfo, RouteDefinition.class);
					for (RouteDefinition definition : definitionList) {
    
						dynamicRouteService.update(definition);
					}
					List<String> newRunningDefinitionIds = definitionList.stream().map(RouteDefinition::getId).collect(Collectors.toList());
					runningDefinitionList.stream().map(RouteDefinition::getId)
							.filter(routeId -> !newRunningDefinitionIds.contains(routeId)).forEach(this::deleteRoute);
				}

				@Override
				public Executor getExecutor() {
    
					return null;
				}

				private void deleteRoute(String routeId) {
    
					dynamicRouteService.delete(routeId);
				}
			});
		} catch (NacosException e) {
    
		}
	}

}

naocs配置中心配置

[{
    
    "id":"user-service",
    "order":0,
    "predicates":[{
    
        "args":{
    
            "_genkey_0":"/user-service/**"
    
        },
        "name":"Path"
        },
        {
    
        "args":{
    
            "_genkey_0":"2017-01-20T17:42:47.789-07:00[America/Denver]"
        },
        "name":"After"
        }],
    "uri":"lb://user-service",
    "filters":[{
    
         "args":{
    
            "_genkey_0":1
        },
        "name":"StripPrefix"
    }]
}]

在这里插入图片描述
说明：相对于数据库来说，使用nacos需要每次改动json配置，可能存在误操作的情况居多，但是可以实现实时生效。不像数据库，有一定的延迟。

本文链接：https://blog.csdn.net/weixin_42074606/article/details/114833317

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

安卓开发--proj4j坐标转换快速上手_android proj4j-程序员宅基地

文章浏览阅读1k次，点赞23次，收藏14次。本节专门讲解proj4j的使用，关于坐标转换原理，等我后面有时间了再讲解下。现在最新版本的1.3.0版本使用起来很方面，不需要你手动导包，只要配置下gradle就行了。_android proj4j

什么是信息熵？_信息熵的概念-程序员宅基地

文章浏览阅读4.8k次，点赞2次，收藏7次。1948 年，伟大的信息论之父**香农（Shannon）**将热力学中熵的概念引入到了信息论中，提出了“信息熵”这一概念。信息熵用于解决信息的量化问题，将原本模糊的信息概念进行计算得出精确的信息熵值，信息熵是描述消息中，不确定性的值。理解起来需要一点耐心，可以先这么说，信息熵就是用来描述信息中不确定性的值，熵越低，不确定性越低，我们也就更容易得到确定的信息。举个栗子，张三的女朋友小红又要过生日了，他现在挑选礼物有三个选择：口红、包、机械键盘。张三并不知道小红到底喜欢那种礼物，因此对于张三来说，小红喜欢_信息熵的概念

英伟达Jetson：Jetson Nano视频编解码测试_no element "nvoverlaysink-程序员宅基地

文章浏览阅读6.6k次，点赞4次，收藏51次。前言本文主要测试Jetson Nano的编解码的能力是否符合官方文档所展示，本文主要基于1080P和4K的两类分辨率视频进行H.264和H.265的编解码测试，测试内容主要有：1080P，4K视频的直接解码测试；从1080P的USB摄像头和4K的CSI摄像头获取图像进行编码再进行解码显示。一、安装 GStreamer首先使用以下命令来安装Gstreamer1.0sudo add-apt-repository universesudo add-apt-repository multiverse_no element "nvoverlaysink

Spring Boot（4）：@Import注解和@Conditional注解_springboot启动类需要加import吗-程序员宅基地

文章浏览阅读474次。@Import注解和@Conditional注解_springboot启动类需要加import吗

Windows 窗口置顶工具推荐如何始终置顶窗口窗口前置窗口固定窗口钉在桌面始终保持在其他窗口前端在其他窗口之上 PowerToys MouseInc_窗口最上层工具-程序员宅基地

文章浏览阅读975次，点赞26次，收藏13次。Microsoft PowerToys - Microsoft Store 中的官方应用。置顶后，窗口会出现边框提示你窗口处于置顶状态，可自行设置。置顶后，没有任何提示。_窗口最上层工具

弹性云服务器（ECS）结合 Docker 容器_ecs 华为 docker-程序员宅基地

文章浏览阅读380次。介绍容器（Container）是一种轻量级的虚拟化技术，所谓的轻量级虚拟化，就是使用了一种操作系统虚拟化技术，这种技术允许一个操作系统上用户空间被分割成几个独立的单元在内核中运行，彼此互不干扰，这样一个独立的空间，就被称之为一个容器。本实验介绍了弹性云服务器（ECS）结合Docker容器的综合实验，包括弹性云服务器（ECS的创建登录，Docker容器的创建、查看、运行，Docker镜像的构建，私有registry的搭建等。_ecs 华为 docker

随便推点

反NP监视原理(+Bypass NP in ring0) -程序员宅基地

文章浏览阅读1.7k次。标题: 【原创】反NP监视原理(+Bypass NP in ring0)作者: 堕落天才时间: 2007-01-03,11:58链接: http://bbs.pediy.com/showthread.php?t=37353NP=nProtect GameGuard(如果你不知道这是什么，请不要往下看)********************************************标

【路径规划】基于自适应蚁群算法移动机器人路径规划附Matlab代码_自适应改进蚁群算法的路径规-程序员宅基地

文章浏览阅读451次。路径规划一直是移动机器人领域的重要研究方向之一。随着自动化技术的不断发展，移动机器人在各个领域的应用也越来越广泛。然而，移动机器人在执行任务时需要根据环境的不同条件选择最佳路径，以避免碰撞和优化运动效率。为了解决这一问题，研究者们提出了各种路径规划算法，其中自适应蚁群算法是一种非常有效的方法。自适应蚁群算法是基于蚁群行为的启发式搜索算法。它模拟了蚂蚁在寻找食物时的行为，通过蚁群中个体之间的信息交流和信息素的释放来寻找最佳路径。_自适应改进蚁群算法的路径规

windows11 安装WSL2全流程_win11安装wsl2-程序员宅基地

文章浏览阅读9.2k次，点赞17次，收藏89次。本文介绍了win11安装wsl做开发环境_win11安装wsl2

【附源码】计算机毕业设计智慧医院信息管理系统（java+springboot+mysql+mybatis+论文）-程序员宅基地

文章浏览阅读397次，点赞4次，收藏9次。后端服务接收到请求后，执行相应的业务逻辑处理，这通常包括与MySQL数据库的交互，如查询数据、插入记录、更新或删除数据等操作。Vue.js前端应用接收到这些数据后，进行解析并更新Web页面，以反映最新的信息或状态给用户。这样，前端Vue.js和后端Spring Boot框架的接口紧密协作，而MySQL数据库则作为数据存储和管理的核心，确保了整个系统的数据一致性和高效处理。系统可以实现病历管理、预约挂号、药品流通、医疗服务、财务核算等功能的自动化，并提供决策支持系统，帮助提升医疗决策的准确性和时效性。

centos7下安装php+memcached简单记录-程序员宅基地

文章浏览阅读68次。 1）centos7下安装php需要再添加一个yum源来安装php-fpm，可以使用webtatic（这个yum源对国内网络来说恐怕有些慢，当然你也可以选择其它的yum源）[root@nextcloud-server ~]# rpm -Uvh https://mirror.webtatic.com/yum/el7/webtatic-release.rpm 安装php7-fpm和一些其..._php7 fatal error: ext/standard/php_smart_st

nginx-413-Request Entity Too Large-程序员宅基地

文章浏览阅读81次。文章目录Request Entity Too Large1. 问题描述2. 解决Request Entity Too Large1. 问题描述[!NOTE]在使用nginx时，在上传文件接口通过nginx转发到服务器时，发现抛出“error”错误，仔细发现抛出错误内容为：413-Request Entity Too Large，发现是nginx限制了文件上传的大小，直接将请求拦截了。这报错是因为nginx的默认上传文件大小配置client_max_body_size只有2MB。2. 解决[