SpringCloud网关Gateway功能实现

<!--nacos 注册中心 客户端依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<!--网关依赖 路由转发+请求限流+身份认证+负载均衡-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

spring:
  application:
    name: springgateway-use   #服务名
servlet:
    context-path: /
cloud:
    nacos:
      server-addr: localhost:8848 #nacos服务端地址，默认8848
      discovery:
        ephemeral: true   #默认是临时实例
    gateway:
      discovery:
        locator:
          enabled: true # 启用服务发现
          lower-case-service-id: true # 服务名小写
      # 路由配置
      routes:
        -id: feign-producer-route #确保路由 ID 唯一，路径匹配规则正确。
          uri: lb://feign-producer # 负载均衡到服务名 feign-producere
          predicates:
            - Path=/producer/** # 匹配路径 /producer/**
          filters:
            - StripPrefix=1      # 过滤器，去掉路径前缀 去除路径前缀 /producer

package org.coffeebeans.config;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class GatewayConfig {
    //配置自定义的路由规则
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("feign-producer", r -> r
                        .path("/producer/**") // 匹配 "/producer/**" 路径的请求
                        .uri("lb://feign-producer")) // 转发到名为 "feign-producer" 的微服务
                .build();
    }
}

package org.coffeebeans.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

//统一认证 自定义全局过滤器 应用于所有请求 权限校验
@Component
public class GlobalAuthFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 检查请求头中的 authorization
        String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (authHeader == null || !authHeader.equals("admin")) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -1; // 设置过滤器的优先级
    }
}

package org.coffeebeans.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

//日志过滤
@Slf4j
@Component
public class GlobalLogFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
       long startTime = System.currentTimeMillis(); // 记录请求开始时间
       String requestUri = exchange.getRequest().getURI().toString(); // 获取请求地址
       // 替换响应对象并继续过滤器链
       return chain.filter(exchange.mutate().build())
             .doOnSuccess(aVoid -> {
                long endTime = System.currentTimeMillis();
                long duration = endTime - startTime;
                log.info("请求地址: {}, 耗时: {}ms", requestUri, duration);
             });
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE;
    }
}

package org.coffeebeans.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;


//缓存请求正文 避免Stream closed 错误
@Component
public class GlobalCacheRequestFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return ServerWebExchangeUtils.cacheRequestBodyAndRequest(exchange, (request) ->
          chain.filter(exchange.mutate().request(request).build())
       );
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
}

package org.coffeebeans.filter;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpMethod;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.util.pattern.PathPatternParser;

//过滤器 统一cors跨域策略
@Configuration
public class GlobalCorsFilter {
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public CorsWebFilter filter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedMethod(HttpMethod.GET);  // 允许GET请求
        config.addAllowedMethod(HttpMethod.POST); // 允许POST请求
        config.addAllowedMethod(HttpMethod.OPTIONS); // 允许OPTIONS预检请求
        config.addAllowedHeader(CorsConfiguration.ALL); // 允许所有请求头
        config.addAllowedOriginPattern(CorsConfiguration.ALL); // 允许所有来源
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(newPathPatternParser());
        source.registerCorsConfiguration("/**", config); // 应用到所有路径
        return new CorsWebFilter(source);
    }
}