Spring Cloud Gateway -动态路由篇

• 动态路由
• 1 创建基本模型
• 2 创建动态路由服务Service
• 3 提供动态路由服务接口API

​ Gateway提供了Endpoint断点，暴露路由信息，有获取所有路由，刷新路由，查看单个路由，删除路由等方法。要访问断点中的方法需要添加spring-boot-starter-actuator注解，并在配置文件中暴露所有端点。

# 暴露监控断点
management:
  endpoints:
    web:
      exposure:
        include:
        - '*'
      health:
        show-details: always

所需依赖：

	
        org.springframework.cloud
        spring-cloud-starter-netflix-eureka-client
    
  	
  		org.springframework.cloud
  		spring-cloud-starter-gateway
  	
  	
  		org.springframework.boot
  		spring-boot-starter-actuator
  	

根据路由的结构创建模型（路由模型，断言模型，过滤器模型）

路由模型：

public class GatewayRouteDefinition {

	
	private String id;
	
	private List predicates = new ArrayList<>();
	
	private List filters = new ArrayList<>();
	
	private String uri;
	
	private int order = 0;
}

断言模型：

public class GatewayPredicateDefinition {
	
	private String name;
	
	private Map args = new linkedHashMap();
}

过滤器模型：

public class GatewayFilterDefinition {
	
	private String name;
	
	private Map args = new linkedHashMap<>();
}

动态路由服务主要提供：增加路由，修改路由，删除路由这三个服务，需要实现ApplicationEventPublisherAware接口。

DynamicRouteServiceImpl：

package com.lmc.service;

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.cloud.gateway.support.NotFoundException;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;

import reactor.core.publisher.Mono;


@Service
public class DynamicRouteServiceImpl implements ApplicationEventPublisherAware {
	
	@Autowired
	private RouteDefinitionWriter routeDefinitionWriter;
	private ApplicationEventPublisher applicationEventPublisher;

	@Override
	public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
		// TODO Auto-generated method stub
		this.applicationEventPublisher = applicationEventPublisher;
	}
	
	//增加路由
	public String add(RouteDefinition definition) {
		routeDefinitionWriter.save(Mono.just(definition)).subscribe();
		this.applicationEventPublisher.publishEvent(new RefreshRoutesEvent(this));
		return "success";
	}
	
	//更新路由
	public String update(RouteDefinition definition) {
		try {
			delete(definition.getId());
		} catch (Exception e) {
			return "update fail, not find route routeId: " + definition.getId();
		}
		try {
			routeDefinitionWriter.save(Mono.just(definition)).subscribe();
			this.applicationEventPublisher.publishEvent(new RefreshRoutesEvent(this));
			return "success";
		} catch (Exception e) {
			return "update route fail";
		}
		
	}

	//删除路由
	public Mono> delete(String id) {
		return this.routeDefinitionWriter.delete(Mono.just(id)).then(Mono.defer(() -> {
			return Mono.just(ResponseEntity.ok().build());
		})).onErrorResume((t) -> {
			return t instanceof NotFoundException;
		}, (t) -> {
			return Mono.just(ResponseEntity.notFound().build());
		});
		
	}
}

提供对外接口,可以通过接口对gateway的路由进行操作

package com.lmc.controller;

import java.net.URI;
import java.util.ArrayList;
import java.util.List;

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.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.util.UriComponentsBuilder;

import com.lmc.definition.GatewayFilterDefinition;
import com.lmc.definition.GatewayPredicateDefinition;
import com.lmc.definition.GatewayRouteDefinition;
import com.lmc.service.DynamicRouteServiceImpl;

import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/route")
public class RouteController {

	@Autowired
	private DynamicRouteServiceImpl dynamicRouteService;
	
    
	@PostMapping("/add")
	public String add(@RequestBody GatewayRouteDefinition gwdefinition) {
		System.out.println("add = " + gwdefinition.toString());
		String flag = "fail";
		try {
			RouteDefinition definition = assembleRouteDefinition(gwdefinition);
			flag = this.dynamicRouteService.add(definition);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return flag;
	}
	
    
	@PostMapping("/routes/{id}")
	public Mono> delete(@PathVariable String id) {
		try {
			return this.dynamicRouteService.delete(id);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
    
	@PostMapping("/update")
	public String update(@RequestBody GatewayRouteDefinition gwdefinition) {
		System.out.println("update = " + gwdefinition.toString());
		RouteDefinition definition = assembleRouteDefinition(gwdefinition);
		return this.dynamicRouteService.update(definition);
	}

	private RouteDefinition assembleRouteDefinition(GatewayRouteDefinition gwdefinition) {
		RouteDefinition definition = new RouteDefinition();
		definition.setId(gwdefinition.getId());
		definition.setOrder(gwdefinition.getOrder());
		//设置断言
		List pdList = new ArrayList();
		List gatewayPredicateDefinitionList = gwdefinition.getPredicates();
		for (GatewayPredicateDefinition gPDefinition : gatewayPredicateDefinitionList) {
			PredicateDefinition predicate = new PredicateDefinition();
			predicate.setArgs(gPDefinition.getArgs());
			predicate.setName(gPDefinition.getName());
			pdList.add(predicate);
		}
		definition.setPredicates(pdList);
		
		//设置过滤器
		List fdList = new ArrayList<>();
		List gatewayFilterDefinitionList = gwdefinition.getFilters();
		for (GatewayFilterDefinition gFDefinition : gatewayFilterDefinitionList) {
			FilterDefinition filter = new FilterDefinition();
			filter.setArgs(gFDefinition.getArgs());
			filter.setName(gFDefinition.getName());
			fdList.add(filter);
		}
		definition.setFilters(fdList);
		System.out.println("gatewayFilterDefinitionList = " + gatewayFilterDefinitionList.toString());
		System.out.println("fdList = " + fdList.toString());
		URI uri = null;
		if (gwdefinition.getUri().startsWith("http")) {
			uri = UriComponentsBuilder.fromHttpUrl(gwdefinition.getUri()).build().toUri();
		} else {
			uri = URI.create(gwdefinition.getUri());
		}
		definition.setUri(uri);
		return definition;
	}
}

以上配置完成发布服务之后，以后添加新服务就可以通过接口来动态操作路由。