6. zuul和gateway（2刷）

水深无声 2022-09-07 14:50 13阅读 0赞

# zuul使用 #

## pom 和 开启 ##

<dependency>
    			<groupId>org.springframework.cloud</groupId>
    			<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
    		</dependency>

@EnableZuulProxy

## yaml 和 测试 ##

spring:
      application:
        name: service-zuul
    
    #######################################################################################
    # 以下配置重点介绍zuul路由的配置写法， 有两种方法，具体介绍见下面说明。 方法一和方法二不能同时使用，实际项目使用不推荐第二种方法。
    #######################################################################################
    # 第一种方法： 将URL转发到指定的serviceId服务，通过指定serviceId=服务名称即可。
    # path 与 servcieId 这两个配置就可以将以"/hiapi"开头的url路由到eureka-client服务。其中zuul.routes.hiapi中的hiapi是自己
    # 定义的，需要制定他的path和serviceId。
    # 同理，url以"/ribbonapi"的请求URL会被分发到eureka-ribbon-client服务。
    # url以"/feignapi"的请求URL会被分发到eureka-feign-client服务。
    # 默认zuul已经结合Ribbon做了负载均衡，会将请求均分的部分路由到不同的服务示例。
    # 其中hiapi, ribbonapi,feignapi 这三个名字可以自己随便定义，只要唯一就行。
    zuul:
      routes:
        hiapi:
          path: /hiapi/**
          serviceId: eureka-client
        ribbonapi:
          path: /ribbonapi/**
          serviceId: eureka-ribbon-client
        feignapi:
          path: /feignapi/**
          serviceId: eureka-feign-client
          
    #prefix: /v1 #如果想给每一个服务的API接口加个前缀，就需要配置zuul.prefix配置。 配置之后，访问路径变成/v1/hiapi/**
    
    # 第二种方式： 将URL转发到指定的集群地址，通过指定listOfServers=URL1,URL2即可。【此方式 实际项目中不推荐使用】
    # 以下配置演示指定URL，并且想做负载均衡。这个时候就需要自己维护负载均衡的服务注册列表
    # 首先将ribbon.eureka.enabled设置为false 这样ribbon就不会向客户端Eureka Client获取服务注册列表
    # 需要自己维护一份注册列表，listOfServers 来配置多个负载均衡的Url
    #zuul:
    # routes:
    # hiapi:
    # path: /hiapi/**
    
    #ribbon:
    # eureka:
    # enabled: false
    #hiapi-v1:
    # ribbon:
    # listOfServers: http://localhost:8762,http://localhost:8763

http://localhost:5000/hiapi/hi?name=aaaa&token=1 #即可访问到  eureka-client ，token是下面的不用管

## 1. 在 zuul上 配置熔断器 ##

> ByteArrayInputStream(“oooops!error, i’m the fallback.”.getBytes())

@Component
    class MyFallbackProvider  implements FallbackProvider { 
        /** * getRoute方法，用于指定熔断功能应用于哪些路由的服务 * 可以指定具体的服务名称，比如eureka-client * 也可以指定*，代表此熔断器应用到所有的服务上 * @return */
        @Override
        public String getRoute() { 
            return "eureka-client";
    // return "*";
        }
    
        /** * fallbackResponse()方法为进入熔断功能时执行的逻辑。 * @param var1 * @param var2 * @return */
        @Override
        public ClientHttpResponse fallbackResponse(String var1, Throwable var2) { 
            return new ClientHttpResponse() { 
                /** * 网关向api服务请求是失败了，但是消费者客户端向网关发起的请求是OK的， * 不应该把api的404,500等问题抛给客户端 * 网关和api服务集群对于客户端来说是黑盒子 */
                @Override
                public HttpStatus getStatusCode() throws IOException { 
                    return HttpStatus.OK;
                }
    
                @Override
                public int getRawStatusCode() throws IOException { 
                    return HttpStatus.OK.value();
                }
    
                @Override
                public String getStatusText() throws IOException { 
                    return HttpStatus.OK.getReasonPhrase();
                }
    
                @Override
                public void close() { 
    
                }
    
                /** * 微服务出现宕机后，客户端再请求时候就会返回 fallback 等字样的字符串提示； * 但对于复杂一点的微服务，我们这里就得好好琢磨该怎么友好提示给用户了； * 如果请求用户服务失败，返回什么信息给消费者客户端 * @return * @throws IOException */
                @Override
                public InputStream getBody() throws IOException { 
                    //返回前端的内容
                    return new ByteArrayInputStream("oooops!error, i'm the fallback.".getBytes());
                }
    
                @Override
                public HttpHeaders getHeaders() { 
                    HttpHeaders headers = new HttpHeaders();
                    //和body中的内容编码一致，否则容易乱码
                    headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
                    return headers;
                }
            };
        }
    }

*  打断点调试，或者是关了 客户端，会出现

oooops!error, i'm the fallback.

## 2. 在 zuul中使用过滤器 ##

> 4 种类型，分别是“ pre ＇’“ post ” “ routing ”和“ error ”

*  `pre`：可以在请求被路由之前调用
 *  `routing`：在路由请求时候被调用
 *  `post`：在routing和error过滤器之后被调用
 *  `error`：处理请求时发生错误时被调用

import static org.springframework.cloud.netflix.zuul.filters.support.FilterConstants.PRE_TYPE;
    
    /** * 自定义过滤器实现很简单： * 只需要继承ZuulFilter ，井实现ZuulFilter 中的抽象方法，包括filterType() * 和filterOrder（），以及IZuulFilter 的shouldFilter（）和run（）的两个方法 */
    @Component
    public class MyFilter extends ZuulFilter { 
    
        private static Logger log = LoggerFactory.getLogger(MyFilter.class);
    
        /** * filterType()即过滤器的类型，有4 种类型，分别是“ pre ＇’“ post ”“ routing ”和“ error ” * @return */
        @Override
        public String filterType() { 
            return PRE_TYPE;
        }
    
        /** * filterOrder（）是过滤顺序，它为一个Int 类型的值，值越小，越早执行该过滤器 * @return */
        @Override
        public int filterOrder() { 
            return 0;
        }
    
        /** * shouldFilter（）表示该过滤器是否过滤逻辑，如果为true ，则执行run（）方法：如果为false ，则不执行run （）方法 * @return */
        @Override
        public boolean shouldFilter() { 
            return true;
        }
    
        /** * run （）方法写具体的过滤的逻辑 * 在本例中，检查请求的参数中是否传了token 这个参数，如果没有传，则请求不被路由到具体的服务实例，直接返回响应，状态码为401 * @return */
        @Override
        public Object run() { 
            //获得 requestContext
            RequestContext ctx = RequestContext.getCurrentContext();
            //得到 request
            HttpServletRequest request = ctx.getRequest();
            //打印日志
            log.info(String.format("%s >>> %s", request.getMethod(), request.getRequestURL().toString()));
            //获得 token 参数
            Object accessToken = request.getParameter("token");
            //如果为null
            if(accessToken == null) { 
                log.warn("token is empty");
                //不继续执行了
                ctx.setSendZuulResponse(false);
                //设置 返回码 为401
                ctx.setResponseStatusCode(401);
                try { 
                    //写到 浏览器的内容为 token is empty
                    ctx.getResponse().getWriter().write("token is empty");
                }catch (Exception e){ }
                return null;
            }
            //有 token校验 通过
            log.info("ok");
            return null;
        }
    }

*keepalive*，是在TCP中一个可以检测死连接的机制。

# gateway #

## pom引用 ##

<dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            </dependency>

## 实例1配置 ##

// tag::code[]
    @SpringBootApplication
    @RestController
    public class Application { 
    	//main方法省略
        
        // tag::route-locator[]
        @Bean
        public RouteLocator myRoutes(RouteLocatorBuilder builder) { 
            String httpUri = "http://httpbin.org:80";
            return builder.routes()
                .route(p -> p
                    .path("/get")
                    .filters(f -> f.addRequestHeader("Hello", "World"))
                    .uri(httpUri))
                .route(p -> p
                    .host("*.hystrix.com")
                    .filters(f -> f
                        .hystrix(config -> config
                            .setName("mycmd")
                            .setFallbackUri("forward:/fallback")))
                    .uri(httpUri))
                .build();
        }
        // end::route-locator[]
    
        // tag::fallback[]
        @RequestMapping("/fallback")
        public Mono<String> fallback() { 
            return Mono.just("fallback");
        }
        // end::fallback[]
    }

## 实例2 yaml ##

server:
      port: 8081
    spring:
      profiles:
        active: query_route2
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: after_route
            uri: http://httpbin.org:80
            predicates:
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]
      profiles: after_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: header_route
            uri: http://httpbin.org:80
            predicates:
            - Header=X-Request-Id, \d+
      profiles: header_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: cookie_route
            uri: http://httpbin.org:80
            predicates:
            - Cookie=name, forezp
      profiles: cookie_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: host_route
            uri: http://httpbin.org:80
            predicates:
            - Host=**.fangzhipeng.com
      profiles: host_route
    
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: method_route
            uri: http://httpbin.org:80/get
            predicates:
            - Method=GET
      profiles: method_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: path_route
            uri: https://blog.csdn.net
            predicates:
            - Path=/forezp/article/details/{ segment}
      profiles: path_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: query_route
            uri: http://httpbin.org:80
            predicates:
            - Query=foo, ba.
      profiles: query_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
            - id: query_route
              uri: http://httpbin.org:80/get
              predicates:
                - Query=foo
      profiles: query_route2

## 实例3 ##

### yaml ###

server:
      port: 8081
    #spring:
    # profiles:
    # active: rewritepath_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: add_request_header_route
            uri: http://httpbin.org:80
            filters:
            - AddRequestHeader=X-Request-Foo, Bar
            predicates:
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]
      profiles: add_request_header_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: add_response_header_route
            uri: http://httpbin.org:80/get
            filters:
            - AddResponseHeader=X-Response-Foo, Bar
            predicates:
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]
      profiles: add_response_header_route
    
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: rewritepath_route
            uri: https://blog.csdn.net
            predicates:
            - Path=/foo/**
            filters:
            - RewritePath=/foo/(?<segment>.*), /$\{ segment}
      profiles: rewritepath_route
    
    ---
    spring:
      cloud:
        gateway:
          routes:
          - id: request_time_route
            uri: http://httpbin.org:80/get
            filters:
            - RequestTime=false
            predicates:
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]
      profiles: request_time_route

### 主类 ###

@SpringBootApplication
    @RestController
    public class Application { 
    
        @Bean
        public RouteLocator customerRouteLocator(RouteLocatorBuilder builder) { 
    
            return builder.routes()
                    .route(r -> r.path("/get")
                            .filters(f -> f.filter(new RequestTimeFilter())
                                    .addResponseHeader("X-Response-Default-Foo", "Default-Bar"))
                            .uri("http://httpbin.org:80")
                            .order(0)
                            .id("customer_filter_router")
                    )
                    .build();
    
        }
    
    // @Bean
    // public TokenFilter tokenFilter(){ 
    // return new TokenFilter();
    // }
    
    
        @Bean
        public RequestTimeGatewayFilterFactory elapsedGatewayFilterFactory() { 
            return new RequestTimeGatewayFilterFactory();
        }
    }

### 过滤器 ###

public class RequestTimeFilter implements GatewayFilter, Ordered { 
    
        private static final Log log = LogFactory.getLog(GatewayFilter.class);
        private static final String REQUEST_TIME_BEGIN = "requestTimeBegin";
    
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
    
            exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
            return chain.filter(exchange).then(
                    Mono.fromRunnable(() -> { 
                        Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
                        if (startTime != null) { 
                            log.info(exchange.getRequest().getURI().getRawPath() + ": " + (System.currentTimeMillis() - startTime) + "ms");
                        }
                    })
            );
    
        }
    
        @Override
        public int getOrder() { 
            return 0;
        }
    }

### 配置gateway ###

public class RequestTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestTimeGatewayFilterFactory.Config> { 
    
    
        private static final Log log = LogFactory.getLog(GatewayFilter.class);
        private static final String REQUEST_TIME_BEGIN = "requestTimeBegin";
        private static final String KEY = "withParams";
    
        @Override
        public List<String> shortcutFieldOrder() { 
            return Arrays.asList(KEY);
        }
    
        public RequestTimeGatewayFilterFactory() { 
            super(Config.class);
        }
    
        @Override
        public GatewayFilter apply(Config config) { 
            return (exchange, chain) -> { 
                exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
                return chain.filter(exchange).then(
                        Mono.fromRunnable(() -> { 
                            Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
                            if (startTime != null) { 
                                StringBuilder sb = new StringBuilder(exchange.getRequest().getURI().getRawPath())
                                        .append(": ")
                                        .append(System.currentTimeMillis() - startTime)
                                        .append("ms");
                                if (config.isWithParams()) { 
                                    sb.append(" params:").append(exchange.getRequest().getQueryParams());
                                }
                                log.info(sb.toString());
                            }
                        })
                );
            };
        }
    
    
    
    
    
    
        public static class Config { 
    
            private boolean withParams;
    
            public boolean isWithParams() { 
                return withParams;
            }
    
            public void setWithParams(boolean withParams) { 
                this.withParams = withParams;
            }
    
        }
    }

### tokenFilter ###

public class TokenFilter implements GlobalFilter, Ordered { 
    
        Logger logger=LoggerFactory.getLogger( TokenFilter.class );
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            String token = exchange.getRequest().getQueryParams().getFirst("token");
            if (token == null || token.isEmpty()) { 
                logger.info( "token is empty..." );
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
            return chain.filter(exchange);
        }
    
        @Override
        public int getOrder() { 
            return -100;
        }
    }

## 实例4 使用redis ##

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.5.RELEASE</version>
        </parent>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>Finchley.RELEASE</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
            </dependency>
     	</dependencies>

### yaml ###

server:
      port: 8081
    spring:
      cloud:
        gateway:
          routes:
          - id: limit_route
            uri: http://httpbin.org:80
            predicates:
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]
            filters:
            - name: RequestRateLimiter
              args:
                key-resolver: '#{@hostAddrKeyResolver}'
                redis-rate-limiter.replenishRate: 1
                redis-rate-limiter.burstCapacity: 1
      application:
        name: gateway-limiter
      redis:
        host: localhost
        port: 6379
        database: 0

### 主类 ###

@SpringBootApplication
    @RestController
    public class Application { 
    
        public static void main(String[] args) { 
            SpringApplication.run( Application.class, args );
        }
    
        @Bean
        public HostAddrKeyResolver hostAddrKeyResolver() { 
            return new HostAddrKeyResolver();
        }
    
        @Bean
        public UriKeyResolver uriKeyResolver() { 
            return new UriKeyResolver();
        }
    
        @Bean
        KeyResolver userKeyResolver() { 
            return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst("user"));
        }
    }

### Resolver ###

public class HostAddrKeyResolver implements KeyResolver { 
    
        @Override
        public Mono<String> resolve(ServerWebExchange exchange) { 
            return Mono.just(exchange.getRequest().getRemoteAddress().getAddress().getHostAddress());
        }
    
    }
    
    public class UriKeyResolver  implements KeyResolver { 
    
        @Override
        public Mono<String> resolve(ServerWebExchange exchange) { 
            return Mono.just(exchange.getRequest().getURI().getPath());
        }
    
    }

## 实例5，真实应用的例子 ##

### yaml配置 ###

server:
      port: 8081
    
    spring:
      application:
        name: sc-gateway-server
        
      cloud:
        gateway:
          discovery:
            locator:
              enabled: false
              lowerCaseServiceId: true
          routes:
          - id: service-hi
            uri: lb://SERVICE-HI
            predicates:
              - Path=/demo/**
            filters:
              - StripPrefix=1
              - RequestTime=true
    
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:8761/eureka/
    
    logging:
      level:
        org.springframework.cloud.gateway: debug

### main 方法 ###

@SpringBootApplication
    @EnableEurekaClient
    public class ServiceGatewayApplication { 
    
        @Bean
        public RequestTimeGatewayFilterFactory requestTimeGatewayFilterFactory() { 
            return new RequestTimeGatewayFilterFactory();
        }
    }

### 配置gateway ###

public class RequestTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestTimeGatewayFilterFactory.Config> { 
    
    
        private static final Log log = LogFactory.getLog(GatewayFilter.class);
        private static final String REQUEST_TIME_BEGIN = "requestTimeBegin";
        private static final String KEY = "withParams";
    
        @Override
        public List<String> shortcutFieldOrder() { 
            return Arrays.asList(KEY);
        }
    
        public RequestTimeGatewayFilterFactory() { 
            super(Config.class);
        }
    
        @Override
        public GatewayFilter apply(Config config) { 
            return (exchange, chain) -> { 
                exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
                return chain.filter(exchange).then(
                        Mono.fromRunnable(() -> { 
                            Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
                            if (startTime != null) { 
                                StringBuilder sb = new StringBuilder(exchange.getRequest().getURI().getRawPath())
                                        .append(": ")
                                        .append(System.currentTimeMillis() - startTime)
                                        .append("ms");
                                if (config.isWithParams()) { 
                                    sb.append(" params:").append(exchange.getRequest().getQueryParams());
                                }
                                log.info(sb.toString());
                            }
                        })
                );
            };
        }
    
    
        public static class Config { 
    
            private boolean withParams;
    
            public boolean isWithParams() { 
                return withParams;
            }
    
            public void setWithParams(boolean withParams) { 
                this.withParams = withParams;
            }
    
        }
    }

### 测试 ###

http://localhost:8081/demo/hi
    
          - id: service-hi
            uri: lb://SERVICE-HI
            predicates:
              - Path=/demo/**
              
     # 即可按照规则，访问 /service-hi