[spring-cloud-gateway-进阶]

前言：

1. 上一篇 我们将网关的简单使用已经实现了，但是实际生产环境下这种方式显得很不灵活。因为我们将路由，过滤器，限流方案都写死在了配置文件中，随着微服务的不断开发，服务越来越多，配置信息就不能及时更新到网关当中。因此需要重启网关。造成其他服务暂行不可使用，生产环境下是不允许的。因此这一篇就讲讲如何进阶，实现简单的动态路由，去配置常用的配置，灵活使用。

话不多说开始撸代码

1. 我们要用到几个服务，分别是，eureka-server ，consumer-service ，dynamic-route，gateway-dynamic-route，
2. eureka-server 提供注册中心
3. consumer-service 提供服务，有hello方法。
4. dynamic-route 管理路由。
5. gateway-dynamic-route 网关，客户端需要请求到网关，网关分发请求。

1、dynamic-route相关

1. 这是一个MVC项目，提供restApi接口，操作路由的CRUD。
2. 结合数据库和redis，将新增路由信息存入数据库，并更新到redis。

2、gateway-dynamic-route相关

1. 供外部访问。
2. 定时从redis获取路由版本号，网关启动默认版本号为0，如果版本号不一致就会将，新的路由加载到网关当中，实现动态路由。
3. 所需要的依赖

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-gateway</artifactId>
			<version>2.0.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
			<version>2.0.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.47</version>
		</dependency>

4. 提供获取网关信息的接口

/**
 * 获取网关的路由相关信息
 */
@RestController
@RequestMapping("/route")
public class DynamicRouteController {

    @Resource
    private RouteDefinitionLocator routeDefinitionLocator;
    
    @RequestMapping("/routes")
    public Flux<RouteDefinition> getRouteDefinitions(){
        return routeDefinitionLocator.getRouteDefinitions();
    }

5. 定时任务拉取路由信息

/**
 * 定时任务，拉取路由信息
 * 路由信息由路由项目单独维护
 */
@Component
public class DynamicRouteScheduling {

    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private DynamicRouteService dynamicRouteService;

    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private static final String dynamicRouteServerName = "dynamic-route-service";

    private static final Logger logger = LoggerFactory.getLogger(DynamicRouteScheduling.class);

    //发布路由信息的版本号
    private static Long versionId = 0L;

    //每60秒中执行一次
    //如果版本号不相等则获取最新路由信息并更新网关路由
    @Scheduled(cron = "*/60 * * * * ?")
    public void getDynamicRouteInfo() {
        try {
            logger.info("redis拉取时间: {}", dateFormat.format(new Date()));
            //先拉取版本信息，如果版本号不想等则更新路由
            Long resultVersionId = restTemplate.getForObject("http://" + dynamicRouteServerName + "/version/lastVersion", Long.class);
            logger.info("路由版本信息：本地版本号：{} ，远程版本号：{}", versionId, resultVersionId);
            if (resultVersionId != null && versionId != resultVersionId) {
                logger.info("开始拉取路由信息......");
                String resultRoutes = restTemplate.getForObject("http://" + dynamicRouteServerName + "/gateway-routes/routes", String.class);
                logger.info("路由信息为：{}", resultRoutes);
                if (!StringUtils.isEmpty(resultRoutes)) {
                    List<GatewayRouteDefinition> list = JSON.parseArray(resultRoutes, GatewayRouteDefinition.class);
                    for (GatewayRouteDefinition definition : list) {
                        //更新路由
                        RouteDefinition routeDefinition = assembleRouteDefinition(definition);
                        dynamicRouteService.update(routeDefinition);
                    }
                    versionId = resultVersionId;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private RouteDefinition assembleRouteDefinition(GatewayRouteDefinition gwdefinition) {
        RouteDefinition definition = new RouteDefinition();
        definition.setId(gwdefinition.getId());
        definition.setOrder(gwdefinition.getOrder());

        //设置断言
        List<PredicateDefinition> pdList = new ArrayList<>();
        List<GatewayPredicateDefinition> 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<FilterDefinition> filters = new ArrayList<>();
        List<GatewayFilterDefinition> gatewayFilters = gwdefinition.getFilters();
        for (GatewayFilterDefinition filterDefinition : gatewayFilters) {
            FilterDefinition filter = new FilterDefinition();
            filter.setName(filterDefinition.getName());
            filter.setArgs(filterDefinition.getArgs());
            filters.add(filter);
        }
        definition.setFilters(filters);
        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;
    }
}

6. 操作增删改

/**
 * 操作路由的操作，新增，更新，删除。
 */
@Service
public class DynamicRouteService implements ApplicationEventPublisherAware {
    @Resource
    private RouteDefinitionWriter routeDefinitionWriter;
    private ApplicationEventPublisher publisher;
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.publisher = applicationEventPublisher;
    }

    //增加路由
    public String add(RouteDefinition definition) {
        routeDefinitionWriter.save(Mono.just(definition)).subscribe();
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
        return "success";
    }
    //更新路由，在此处会将原来service-Id完全删除，之后新建路由，因此不可以新增相同service-Id的不同路由。
    public String update(RouteDefinition definition) {
        try {
            delete(definition.getId());
        } catch (Exception e) {
            return "更新路由失败:路由ID为 " + definition.getId();
        }
        try {
            routeDefinitionWriter.save(Mono.just(definition)).subscribe();
            this.publisher.publishEvent(new RefreshRoutesEvent(this));
            return "success";
        } catch (Exception e) {
            return "更新路由失败";
        }
    }
    //删除路由
    public Mono<ResponseEntity<Object>> 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());
        });
    }

7. 配置文件就显得简单了许多

server:
  port: 9996
spring:
  application:
    name: gateway-dynamic-route
  redis:
    host: 127.0.0.1
    port: 6379
    password: 123456
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          # 服务名小写
          lower-case-service-id: true

# 注册中心
eureka:
  instance:
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
  client:
    service-url:
      defaultZone: http://localhost:8899/eureka/

这个时候我们访问我们的Gateway路由,上面我们说过，Gateway的负载均衡规则是通过服务注册中心的服务名/接口实现负载均衡的能力
我们启动两个实例名称相同的服务注册到eureka，如下：

启动我们所有的服务,然后访问网关。


分别访问到了不通的项目。
有点跑偏了啊，咱们的动态路由还没有讲完。
回归主题。
项目都跑起来了，咱们此时网关中没有配置任何路由，但是会有默认的，咱们看一下。

新增两条路由规则

可以看到我们新增了，一个过滤器在zw路径下，止痒是访问zw路径下的接口都将走校验。

访问aa,正常拿到了数据。网关还做了轮询处理。


7. 关键点就是网关拉取配置信息加载到网关里边。可以好好研究一下，代码太多，记录一下，即使回忆起来也很快上手。
8. 补充，注入restTemplate之后报如下错误：
I/O error on GET request for “http://userservice/user/point/update”: userservice; nested exception
解决如下：

    /**
     * @LoadBalanced注解为RestTemplate Bean添加了一个LoadBalancerInterceptor拦截器。
     * 可以将请求的地址中的服务逻辑名转为具体的服务地址。也就是将localhost：8080转成了Eureka的application的名称。
     * 所以没有加该注解则会报xxxservice未找到。
     */
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }