Gateway--服务网关

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <parent>
    <artifactId>springcloud-alibaba</artifactId>
    <groupId>cn.maruifu</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>api-gateway</artifactId>
    <dependencies>
    <!--gateway网关-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
</dependencies>
</project>

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

server:
 port: 7000
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>

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

server:
 port: 7000
spring:
 application:
  name: api-gateway
 cloud:
  nacos:
   discovery:
    server-addr: 127.0.0.1:8848
   gateway:
    discovery:
     locator:
      enabled: true # 让gateway可以发现nacos中的微服务
    routes:
      - id: product_route
      uri: lb://service-product # lb指的是从nacos中按照名称获取微服务,并遵循负载均 衡策略
      predicates:
       - Path=/product-serv/**
      filters:
       - StripPrefix=1

server:
 port: 7000
spring:
 application:
  name: gateway
 cloud:
  nacos:
   discovery:
    server-addr: 127.0.0.1:8848
   gateway:
    discovery:
     locator:
      enabled: true # 让gateway可以发现nacos中的微服务

server:
  port: 7000 
spring: 
  application: 
    name: api-gateway cloud:
  nacos:
    discovery:
      server-addr: 127.0.0.1:8848
  gateway:
    discovery:
      locator:
        enabled: true
    routes:
      - id: product_route
      uri: lb://service-product
      predicates:
        - Path=/product-serv/**
        - Before=2019-11-28T00:00:00.000+08:00 #限制请求时间在2019-11-28之前 \- Method=POST #限制请求方式为POST
      filters:
        - StripPrefix=1

spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
        - id: product-route
        uri: lb://service-product
        predicates:
          - Path=/product-serv/**
          - Age=18,60 # 限制年龄只有在18到60岁之间的人能访问 filters:
          - StripPrefix=1

package cn.maruifu.predicates;
//泛型 用于接收一个配置类,配置类用于接收中配置文件中的配置
@Component
public class AgeRoutePredicateFactoryextends AbstractRoutePredicateFactory<AgeRoutePredicateFactory.Config> { 
    
    public AgeRoutePredicateFactory() {
        super(AgeRoutePredicateFactory.Config.class);
    }
    //用于从配置文件中获取参数值赋值到配置类中的属性上 @Override
    public List<String> shortcutFieldOrder() { //这里的顺序要跟配置文件中的参数顺序一致
        return Arrays.asList("minAge", "maxAge"); }
    //断言
    @Override
    public Predicate<ServerWebExchange> apply(AgeRoutePredicateFactory.Config config) {
        return new Predicate<ServerWebExchange>() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) { 
                //从serverWebExchange获取传入的参数
                String ageStr = serverWebExchange.getRequest().getQueryParams().getFirst("age"); 
                if (StringUtils.isNotEmpty(ageStr)) {
                    int age = Integer.parseInt(ageStr);
                    return age > config.getMinAge() && age < config.getMaxAge(); }
                return true;
            }
        };
    }
}

//自定义一个配置类, 用于接收配置文件中的参数
@Data
class Config {
    private int minAge;
    private int maxAge;
}

测试发现当age在(20,60)可以访问,其它范围不能访问 
http://localhost:7000/product-serv/product/1?age=30 
http://localhost:7000/product-serv/product/1?age=10

server:
  port: 7000
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      gateway:
        discovery:
          locator:
            enabled: true # 让gateway可以发现nacos中的微服务
        routes:
          - id: product_route
          uri: lb://service-product # lb指的是从nacos中按照名称获取微服务,并遵循负载均 衡策略
          predicates:
            - Path=/product-serv/**
          filters:
            - StripPrefix=1
            - SetStatus=2000 # 修改返回状态

server:
  port: 7000
spring:
  application:
    name: api-gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      gateway:
        discovery:
          locator:
            enabled: true # 让gateway可以发现nacos中的微服务
        routes:
          - id: consumer
          uri: lb://consumer # lb指的是从nacos中按照名称获取微服务,并遵循负载均 衡策略
          predicates:
            - Path=/consumer-serv/**
          filters:
            - StripPrefix=1
            - Log=true,false # 控制日志是否开启

//自定义局部过滤器
@Component
public class LogGatewayFilterFactory extends AbstractGatewayFilterFactory<LogGatewayFilterFactory.Config> { //构造函数

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

    //读取配置文件中的参数 赋值到 配置类中
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("consoleLog", "cacheLog");
    }

    //过滤器逻辑
    @Override
    public GatewayFilter apply(LogGatewayFilterFactory.Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                if (config.isCacheLog()) {
                    System.out.println("cacheLog已经开启了....");
                }
                if (config.isConsoleLog()) {
                    System.out.println("consoleLog已经开启了....");
                }
                return chain.filter(exchange);
            }
        };
    }

    //配置类 接收配置参数
    @Data
    @NoArgsConstructor
    public static class Config {
        private boolean consoleLog;
        private boolean cacheLog;
    }
}

package cn.maruifu.filters; 
//自定义全局过滤器需要实现GlobalFilter和Ordered接口
@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered { 
    //完成判断逻辑
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getQueryParams().getFirst("token"); 
        if (StringUtils.isBlank(token)) {
            System.out.println("鉴权失败"); 
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        //调用chain.filter继续向下游执行
        return chain.filter(exchange);
    }
    //顺序,数值越小,优先级越高 @Override
    public int getOrder() { 
        return 0;
    } 
}

<dependency>
	<groupId>com.alibaba.csp</groupId> 
	<artifactId>sentinel-spring-cloud-gateway-adapter</artifactId> 
</dependency>

@Configuration
public class GatewayConfiguration {
    private final List<ViewResolver> viewResolvers;
    private final
    ServerCodecConfigurer serverCodecConfigurer;

    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }

    // 初始化一个限流的过滤器
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }

    // 配置初始化的限流参数
    @PostConstruct
    public void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("product_route") //资源名称,对应路由id .setCount(1) // 限流阈值
                        .setIntervalSec(1) // 统计时间窗口，单位是秒，默认是 1 秒
        );
        GatewayRuleManager.loadRules(rules);
    }

    // 配置限流的异常处理器
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

    // 自定义限流异常页面
    @PostConstruct
    public void initBlockHandlers() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
                Map map = new HashMap<>();
                map.put("code", 0);
                map.put("message", "接口被限流了");
                return ServerResponse.status(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON_UTF8).body(BodyInserters.fromObject(map));
            }
        };
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }
}

/**
 *  配置初始化的限流参数
 */
@PostConstruct
public void initGatewayRules(){
    Set<GatewayFlowRule> rules=new HashSet<>();
    rules.add(new GatewayFlowRule("product_api1").setCount(1).setIntervalSec(1));
    rules.add(new GatewayFlowRule("product_api2").setCount(1).setIntervalSec(1));
    GatewayRuleManager.loadRules(rules);
}
//自定义API分组
@PostConstruct
private void initCustomizedApis(){
        Set<ApiDefinition> definitions=new HashSet<>();
        ApiDefinition api1=new ApiDefinition("product_api1").setPredicateItems(new HashSet<ApiPredicateItem>(){{
// 以/product-serv/product/api1 开头的请求
        add(new ApiPathPredicateItem().setPattern("/product- serv/product/api1/**").setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));}});
        ApiDefinition api2=new ApiDefinition("product_api2")
                                .setPredicateItems(new HashSet<ApiPredicateItem>(){{
                                    // 以/product-serv/product/api2/demo1 完成的url路径匹配
                                    add(new ApiPathPredicateItem().setPattern("/product- serv/product/api2/demo1"));
                                }});
        definitions.add(api1);
        definitions.add(api2);
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
}