Spring Cloud微服务网关Gateway组件

<!‐‐ gateway网关 ‐‐>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring‐cloud‐starter‐gateway</artifactId>
</dependency>

server:
  port: 8888
spring:
  application:
  name: api‐gateway
  cloud:
  gateway:
    routes: # 路由数组[路由 就是指定当请求满足什么条件的时候转到哪个微服务]
    ‐ id: product_route # 当前路由的标识, 要求唯一
    uri: http://localhost:8081 # 请求要转发到的地址
    order: 1 # 路由的优先级,数字越小级别越高
    predicates: # 断言(就是路由转发要满足的条件)
    ‐ Path=/product‐serv/** # 当请求路径满足Path指定的规则时,才进行路由转发
    filters: # 过滤器,请求在传递过程中可以通过过滤器对其进行一定的修改
    ‐ StripPrefix=1 # 转发之前去掉1层路径.

<!‐‐ nacos服务注册与发现 ‐‐>
<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring‐cloud‐starter‐alibaba‐nacos‐discovery</artifactId>
</dependency>

server:
  port: 8888

spring:
  application:
  name: api‐gateway
  cloud:
  nacos:
  discovery:
     server‐addr: 127.0.0.1:8848
     gateway:
     routes:
     ‐ id: product_route
     uri: lb://service‐product # lb指的是从nacos中按照名称获取微服务,并遵循负载均衡策略
     predicates:
     ‐ Path=/product‐serve/**
     filters:
     ‐ StripPrefix=1

server:
  port: 8888

spring:
  application:
  name: api‐gateway
  cloud:
  nacos:
  discovery:
     server‐addr: 127.0.0.1:8848
     gateway:
     discovery:
     locator:
     enabled: true

‐ After=2019‐12‐31T23:59:59.789+08:00[Asia/Shanghai]

‐ RemoteAddr=192.168.1.1/24

‐Cookie=chocolate, ch.

‐Header=X‐Request‐Id, \d+

‐Host=**.testhost.org

‐Method=GET

‐Path=/foo/{segment}

‐Query=baz, ba.

routes:
  ‐id: weight_route1
  uri: host1
  predicates:
    ‐Path=/product/**
    ‐Weight=group3, 1
    ‐id: weight_route2
  uri: host2
  predicates:
   ‐Path=/product/**
   ‐Weight= group3, 9

 @Component
 @Slf4j
 public class CheckAuthRoutePredicateFactory extends AbstractRoutePredicateFactory<CheckAuthRoutePredicateFactory.Config> {

     public CheckAuthRoutePredicateFactory() {
       super(Config.class);
     }

     @Override
     public Predicate<ServerWebExchange> apply(Config config) {
        return new GatewayPredicate() {

         @Override
         public boolean test(ServerWebExchange serverWebExchange) {
             log.info("调用CheckAuthRoutePredicateFactory" + config.getName());
             if(config.getName().equals("xushu")){
               return true;
             }
             return false;
         }
        };
     }

     /**
     * 快捷配置
     * @return
     */
     @Override
     public List<String> shortcutFieldOrder() {
        return Collections.singletonList("name");
     }

     public static class Config {

         private String name;

         public String getName() {
            return name;
         }

         public void setName(String name) {
            this.name = name;
        }
    }
 }

 spring:
   cloud:
   gateway:
     #设置路由：路由id、路由到微服务的uri、断言
     routes:
     ‐ id: order_route #路由ID，全局唯一
     uri: http://localhost:8020 #目标微服务的请求地址和端口
     predicates:
     # 测试：http://localhost:8888/order/findOrderByUserId/1
     ‐ Path=/order/** #Path路径匹配
     #自定义CheckAuth断言工厂
     ‐ CheckAuth=xushu

spring:
 cloud:
 gateway:
 #设置路由：路由id、路由到微服务的uri、断言
 routes:
 ‐ id: order_route #路由ID，全局唯一
 uri: http://localhost:8020 #目标微服务的请求地址和端口
 #配置过滤器工厂
 filters:
    ‐ AddRequestHeader=X‐Request‐color, red #添加请求头

@GetMapping("/testgateway")
public String testGateway(HttpServletRequest request) throws Exception {
  log.info("gateWay获取请求头X‐Request‐color："+request.getHeader("X‐Request‐color"));
  return "success";
}

@GetMapping("/testgateway2")
public String testGateway(@RequestHeader("X‐Request‐color") String color) throws Exception {
 log.info("gateWay获取请求头X‐Request‐color："+color);
 return "success";
}

spring:
 cloud:
 gateway:
 #设置路由：路由id、路由到微服务的uri、断言
 routes:
 ‐ id: order_route #路由ID，全局唯一
 uri: http://localhost:8020 #目标微服务的请求地址和端口
 #配置过滤器工厂
 filters:
   ‐ AddRequestParameter=color, blue # 添加请求参数

 @GetMapping("/testgateway3")
 public String testGateway3(@RequestParam("color") String color) throws Exception {
     log.info("gateWay获取请求参数color:"+color);
     return "success";
 }

spring:
    cloud:
    gateway:
    #设置路由：路由id、路由到微服务的uri、断言
    routes:
    ‐ id: order_route #路由ID，全局唯一
    uri: http://localhost:8020 #目标微服务的请求地址和端口
    #配置过滤器工厂
    filters:
        ‐ PrefixPath=/mall‐order # 添加前缀 对应微服务需要配置context‐path

server:
  servlet:
  context‐path: /mall‐order

spring:
 cloud:
 gateway:
 #设置路由：路由id、路由到微服务的uri、断言
 routes:
 ‐ id: order_route #路由ID，全局唯一
 uri: http://localhost:8020 #目标微服务的请求地址和端口
 #配置过滤器工厂
 filters:
  ‐ RedirectTo=302, https://www.baidu.com/ #重定向到百度

@Component
@Slf4j
public class CheckAuthGatewayFilterFactory extends AbstractNameValueGatewayFilterFactory {

 @Override
 public GatewayFilter apply(NameValueConfig config) {
     return (exchange, chain) ‐> {
         log.info("调用CheckAuthGatewayFilterFactory==="+ config.getName() + ":" + config.getValue());
         return chain.filter(exchange);
     };
 }
}

spring:
  cloud:
  gateway:
  #设置路由：路由id、路由到微服务的uri、断言
  routes:
  ‐ id: order_route #路由ID，全局唯一
  uri: http://localhost:8020 #目标微服务的请求地址和端口
  #配置过滤器工厂
  filters:
   ‐ CheckAuth=fox,男

spring:
 cloud:
 gateway:
 routes:
 ‐ id: order_route
 uri: lb://mall‐order
 predicates:
 ‐ Path=/order/**

/***
* @Author 徐庶 QQ:1092002729
* @Slogan 致敬大师，致敬未来的你
*/
@Component
public class LogFilter implements GlobalFilter {
 Logger log= LoggerFactory.getLogger(this.getClass());

 @Override
 public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

     log.info(exchange.getRequest().getPath().value());
     return chain.filter(exchange);
 }
}

 <appender name="accessLog" class="ch.qos.logback.core.FileAppender">
 <file>access_log.log</file>
 <encoder>
 <pattern>%msg%n</pattern>
 </encoder>
 </appender>
 <appender name="async" class="ch.qos.logback.classic.AsyncAppender">
 <appender‐ref ref="accessLog" />
 </appender>

 <logger name="reactor.netty.http.server.AccessLog" level="INFO" additivity="false">
 <appender‐ref ref="async"/>
 </logger>

 spring:
    cloud:
    gateway:
    globalcors:
    cors‐configurations:
    '[/**]':
    allowedOrigins: "*"
    allowedMethods:
     ‐ GET
     ‐ POST
     ‐ DELETE
     ‐ PUT
     ‐ OPTION

@Configuration
public class CorsConfig {
 @Bean
 public CorsWebFilter corsFilter() {
   CorsConfiguration config = new CorsConfiguration();
   config.addAllowedMethod("*");
   config.addAllowedOrigin("*");
   config.addAllowedHeader("*");

   UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
   source.registerCorsConfiguration("/**", config);

   return new CorsWebFilter(source);
 }
}

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring‐cloud‐alibaba‐sentinel‐gateway</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring‐cloud‐starter‐alibaba‐sentinel</artifactId>
</dependency>

sentinel:
transport:
# 添加sentinel的控制台地址
dashboard: 127.0.0.1:8080

spring:cloud.sentinel.scg.fallback.mode = response
spring.cloud.sentinel.scg.fallback.response‐body = '{"code":403,"mes":"限流了"}'

@Configuration
public class GatewayConfig {

    @PostConstruct
    public void init(){
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange exchange, Throwable throwable) {
                return ServerResponse.status(HttpStatus.OK)
                .contentType(MediaType.APPLICATION_JSON)
                .body(BodyInserters.fromValue("降级了!"));
            }
        };

        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}

 @PostConstruct
 public void doInit() {
     //初始化网关限流规则
     initGatewayRules();
     //自定义限流异常处理器
     initBlockRequestHandler();
 }

 private void initGatewayRules() {
     Set<GatewayFlowRule> rules = new HashSet<>();
     //resource：资源名称，可以是网关中的 route 名称或者用户自定义的 API 分组名称。
     //count：限流阈值
     //intervalSec：统计时间窗口，单位是秒，默认是 1 秒。
     rules.add(new GatewayFlowRule("order_route")
     .setCount(2)
     .setIntervalSec(1)
     );
     rules.add(new GatewayFlowRule("user_service_api")
     .setCount(2)
     .setIntervalSec(1)
     );

     // 加载网关规则
     GatewayRuleManager.loadRules(rules);
}

private void initBlockRequestHandler() {
     BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
         @Override
         public Mono<ServerResponse> handleRequest(ServerWebExchange exchange, Throwable t) {
             HashMap<String, String> result = new HashMap<>();
             result.put("code",String.valueOf(HttpStatus.TOO_MANY_REQUESTS.value()));
             result.put("msg", HttpStatus.TOO_MANY_REQUESTS.getReasonPhrase());

             return ServerResponse.status(HttpStatus.TOO_MANY_REQUESTS)
             .contentType(MediaType.APPLICATION_JSON)
             .body(BodyInserters.fromValue(result));
        }
    };
     //设置自定义异常处理器
     GatewayCallbackManager.setBlockHandler(blockRequestHandler);
 }