学习gateway网关时，是以产品应用为目的，打算做一个类似于SAAS平台，网关负责统一的鉴权，日志记录，对外屏蔽真实的访问地址。路由信息也不能是写死在配置文件的，必须是提供管理页面可维护的。所以就略过配置文件，直接开启动态路由的实现。

一、gateway动态路由需要的jar包

我的springboot及springCloud版本

            
                org.springframework.boot
                spring-boot-dependencies
                2.6.11
                pom
                import
            

            
                org.springframework.cloud
                spring-cloud-dependencies
                2021.0.1
                pom
                import
            

依赖包

   org.springframework.cloud
   spring-cloud-starter-gateway



   org.springframework.cloud
   spring-cloud-starter-loadbalancer
 


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



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

二、修改application.yml文件

开启服务与发现，路由的真实地址可设置为“lb:{应用名称}”格式的地址，可实现通过fegin进行负载均衡地址访问

spring:
  cloud:
    nacos:
      discovery: ##配置服务与发现
        server-addr: 127.0.0.1:8848
        namespace: d5afac56-78a0-48e5-ac76-c6e13c96f35f
    gateway:
      discovery:
        locator:
          ##指定是否启用服务发现定位器。当设置为true时，Gateway将通过服务发现来定位后端服务
          enabled: true

三、动态路由的代码实现

路由信息的持久化此处不做解释，无非就是将json格式的路由数据保存到数据库，以下代码有将JSON格式的路由数据转换为路由对象的方法。以下代码为维护路由信息的业务层，包含路由信息的增、删、改、刷新等方法。

package com.zhangzz.gateway.route.service.impl;
import com.alibaba.fastjson2.JSON;
import com.zhangzz.gateway.domain.CustomPredicateDefinition;
import com.zhangzz.gateway.domain.CustomRouteDefinition;
import com.zhangzz.gateway.domain.RouteInfo;
import com.zhangzz.core.entity.AjaxResult;
import com.zhangzz.gateway.route.service.IRouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
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.RouteDefinitionWriter;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.util.UriComponentsBuilder;
import reactor.core.publisher.Mono;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@Service
@Transactional
public class DynamicRouteService implements ApplicationEventPublisherAware , ApplicationRunner {
    private final RouteDefinitionWriter routeDefinitionWriter;
    //路由信息持久化业务层，无需关注
    @Autowired
    private IRouteService routeService;
    //通过构造方法进行注入，此处通过跟踪代码，RouteDefinitionWriter的实现类是基于内存的，非redis的
    private ApplicationEventPublisher publisher;
    public DynamicRouteService(RouteDefinitionWriter routeDefinitionWriter) {
        this.routeDefinitionWriter = routeDefinitionWriter;
    }
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    /**
     * 增加路由
     *
     * @param routeForm
     * @return
     */
    public AjaxResult add(CustomRouteDefinition routeForm) {
        RouteDefinition definition = convert(routeForm);
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        enduranceRule(routeForm.getName(), routeForm.getDescription(), definition);
        publishRouteEvent();
//        System.out.println(JSON.toJSONString(definition));
        return AjaxResult.success(true);
    }
    /**
     * 更新路由
     *
     * @param routeForm
     * @return
     */
    public AjaxResult update(CustomRouteDefinition routeForm) {
        RouteDefinition definition = convert(routeForm);
        try {
            this.routeDefinitionWriter.delete(Mono.just(definition.getId())).subscribe();
        } catch (Exception e) {
            return AjaxResult.error("未知路由信息",500);
        }
        try {
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            enduranceRule(routeForm.getName(), routeForm.getDescription(), definition);
            publishRouteEvent();
            return AjaxResult.success(true);
        } catch (Exception e) {
            return AjaxResult.error("路由信息修改失败!",500);
        }
    }
    /**
     * 删除路由
     *
     * @param id
     * @return
     */
    public AjaxResult delete(String id) {
        this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
        routeService.deleteByRouteId(id);
        publishRouteEvent();
        return AjaxResult.success();
    }
    private void publishRouteEvent() {
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
    }
    /**
     * 刷新路由信息
     **/
    public AjaxResult flushRoute() {
        publishRouteEvent();
        return AjaxResult.success(true);
    }
    /**
     * 获取路由信息列表
     * @return
     */
    public List getRouteList(){
        List list = routeService.selectList();
        List routeList = new ArrayList<>();
        if(list != null && !list.isEmpty()){
            for (RouteInfo info:list) {
                routeList.add(this.convertCustomRouteDefinition(info));
            }
        }
        return routeList;
    }
    public CustomRouteDefinition getRouteById(String routeId){
        RouteInfo info = routeService.selectByRouteId(routeId);
        return this.convertCustomRouteDefinition(info);
    }
    /**
     * 转换为自定义路由
     * @param info 路由持久化对象
     * @return 自定义路由
     */
    private CustomRouteDefinition convertCustomRouteDefinition(RouteInfo info){
        CustomRouteDefinition routeDefinition = new CustomRouteDefinition();
        routeDefinition.setDescription(info.getDescription());
        routeDefinition.setFilters(JSON.parseArray(info.getFilters(),FilterDefinition.class));
        routeDefinition.setId(info.getRouteId());
        routeDefinition.setName(info.getRouteName());
        routeDefinition.setOrder(info.getOrderNum());
        routeDefinition.setPredicateDefinitions(JSON.parseArray(info.getPredicates(), CustomPredicateDefinition.class));
        routeDefinition.setUrl(info.getUrl());
        return routeDefinition;
    }
    /**
     * 把自定义请求模型转换为RouteDefinition
     *
     * @param form
     * @return
     */
    private RouteDefinition convert(CustomRouteDefinition form) {
        RouteDefinition definition = new RouteDefinition();
        definition.setId(form.getId());
        definition.setOrder(form.getOrder());
        //设置断言
        List predicateDefinitions = form.getPredicateDefinitions().stream()
                .distinct().map(predicateInfo -> {
                    PredicateDefinition predicate = new PredicateDefinition();
                    predicate.setArgs(predicateInfo.getArgs());
                    predicate.setName(predicateInfo.getName());
                    return predicate;
                }).collect(Collectors.toList());
        definition.setPredicates(predicateDefinitions);
        if(form.getFilters() != null) {
            // 设置过滤
            List filterList = form.getFilters().stream().distinct().map(x -> {
                FilterDefinition filter = new FilterDefinition();
                filter.setName(x.getName());
                filter.setArgs(x.getArgs());
                return filter;
            }).collect(Collectors.toList());
            definition.setFilters(filterList);
        }
        // 设置URI,判断是否进行负载均衡
        URI uri;
        if (form.getUrl().startsWith("http")) {
            uri = UriComponentsBuilder.fromHttpUrl(form.getUrl()).build().toUri();
        } else {
            uri = URI.create(form.getUrl());
        }
        definition.setUri(uri);
        return definition;
    }
    /**
     * 持久化至数据库
     */
    public void enduranceRule(String name, String description, RouteDefinition definition) {
        String id = definition.getId();
        List predicates = definition.getPredicates();
        List filters = definition.getFilters();
        int order = definition.getOrder();
        URI uri = definition.getUri();
        RouteInfo routeInfo = new RouteInfo();
        routeInfo.setRouteName(name);
        routeInfo.setRouteId(id);
        routeInfo.setUrl(uri.toString());
        routeInfo.setPredicates(JSON.toJSONString(predicates));
        routeInfo.setFilters(JSON.toJSONString(filters));
        routeInfo.setDescription(description);
        routeInfo.setOrderNum(order);
        RouteInfo one = routeService.selectByRouteId(id);
        if (one == null) {
            routeService.add(routeInfo);
        } else {
            routeInfo.setId(one.getId());
            routeService.update(routeInfo);
        }
    }
    /**
     * 该方法会在网关启动时，从数据库读取路由信息，并加载至内存中。
     */
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("----------加载路由信息Start---------");
        List list = routeService.selectList();
        if(list != null && !list.isEmpty()){
            CustomRouteDefinition definition = null;
            for (RouteInfo info:list) {
                System.out.println("----------加载路由“"+info.getRouteName()+"”---------");
                definition = convertCustomRouteDefinition(info);
                RouteDefinition routedefinition = convert(definition);
                routeDefinitionWriter.save(Mono.just(routedefinition)).subscribe();
            }
            publishRouteEvent();
        }
        System.out.println("----------加载路由信息End---------");
    }
}

Controller层代码如下：

package com.zhangzz.gateway.route.controller;
import com.zhangzz.gateway.domain.CustomRouteDefinition;
import com.zhangzz.core.entity.AjaxResult;
import com.zhangzz.gateway.route.service.impl.DynamicRouteService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/route")
public class RouteController {
    @Autowired
    private DynamicRouteService service;
    @PostMapping
    public AjaxResult addRoute(@RequestBody CustomRouteDefinition routeDefinition){
        return service.add(routeDefinition);
    }
    @PutMapping
    public AjaxResult updateRoute(@RequestBody CustomRouteDefinition routeDefinition){
        return service.update(routeDefinition);
    }
    @DeleteMapping("/{routeId}")
    public AjaxResult deleteRoute(@PathVariable String routeId){
        return service.delete(routeId);
    }
    /**
     * 刷新路由
     * @return
     */
    @GetMapping("/flushRoute")
    public AjaxResult flushRoute(){
        return service.flushRoute();
    }
    @GetMapping
    public AjaxResult getList(){
        return AjaxResult.success(service.getRouteList());
    }
    @GetMapping("/routeId/{routeId}")
    public AjaxResult getByRouteId(@PathVariable String routeId){
        return AjaxResult.success(service.getRouteById(routeId));
    }
}

四、网关的启动类

@SpringBootApplication
@EnableDiscoveryClient
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class,args);
    }
}

启动网关服务后，通过postman或apipost等工具添加路由信息，同时路由信息会保存入库，下次服务启动会重新装载。

请求地址（POST）：http://localhost/route

请求报文：

{
    "id":"test1",
    "name":"routeTest1",
    "description":"路由测试1",
    "order":1,
    "predicateDefinitions":[
        {
            "name":"Path",
            "args":{
                "_genkey_0":"/b3/**",
                "_genkey_1":"/b4/**"
            }
        }
    ],
    "filters":[
        {
            "name":"StripPrefix",
            "args":{
                "_genkey_0":"1"
            }
        }
    ],
    "url":"lb://content"
}

浏览器中访问http://localhost/b3或http://localhost/b4，则会直接访问nacos服务中的content服务