spring cloud gateway集成hystrix实战篇

< dependency >

             < groupId >org.springframework.cloud</ groupId >

             < artifactId >spring-cloud-starter-netflix-hystrix</ artifactId >

         </ dependency >

hystrix测试数据mand.fallbackcmd.execution.isolation.thread.timeoutInMilliseconds: 5000

spring:

   cloud:

     gateway:

       discovery:

         locator:

           enabled: true

       routes:

       - id: employee-service

         uri: lb: //employee-service

         predicates:

         - Path=/employee/**

         filters:

         - RewritePath=/employee/(?<path>.*), /$\{path}

         - name: Hystrix

           args:

             name: fallbackcmd

             fallbackUri: forward:/fallback

@RestController

@RequestMapping ( "/fallback" )

public class FallbackController {

     @RequestMapping ( "" )

     public String fallback(){

         return "error" ;

     }

}

@Configuration

@ConditionalOnProperty (name = "spring.cloud.gateway.enabled" , matchIfMissing = true )

@EnableConfigurationProperties

@AutoConfigureBefore (HttpHandlerAutoConfiguration. class )

@AutoConfigureAfter ({GatewayLoadBalancerClientAutoConfiguration. class , GatewayClassPathWarningAutoConfiguration. class })

@ConditionalOnClass (DispatcherHandler. class )

public class GatewayAutoConfiguration {

     //......

     @Configuration

     @ConditionalOnClass ({HystrixObservableCommand. class , RxReactiveStreams. class })

     protected static class HystrixConfiguration {

         @Bean

         public HystrixGatewayFilterFactory hystrixGatewayFilterFactory(DispatcherHandler dispatcherHandler) {

             return new HystrixGatewayFilterFactory(dispatcherHandler);

         }

     } 

     //......

}

/**

  * Depends on `spring-cloud-starter-netflix-hystrix`, {@see http://cloud.spring.io/spring-cloud-netflix/}

  * @author Spencer Gibb

  */

public class HystrixGatewayFilterFactory extends AbstractGatewayFilterFactory<HystrixGatewayFilterFactory.Config> {

     public static final String FALLBACK_URI = "fallbackUri" ;

     private final DispatcherHandler dispatcherHandler;

     public HystrixGatewayFilterFactory(DispatcherHandler dispatcherHandler) {

         super (Config. class );

         this .dispatcherHandler = dispatcherHandler;

     }

     @Override

     public List<String> shortcutFieldOrder() {

         return Arrays.asList(NAME_KEY);

     }

     public GatewayFilter apply(String routeId, Consumer<Config> consumer) {

         Config config = newConfig();

         consumer.accept(config);

         if (StringUtils.isEmpty(config.getName()) && !StringUtils.isEmpty(routeId)) {

             config.setName(routeId);

         }

         return apply(config);

     }

     @Override

     public GatewayFilter apply(Config config) {

         //TODO: if no name is supplied, generate one from command id (useful for default filter)

         if (config.setter == null ) {

             Assert.notNull(config.name, "A name must be supplied for the Hystrix Command Key" );

             HystrixCommandGroupKey groupKey = HystrixCommandGroupKey.Factory.asKey(getClass().getSimpleName());

             HystrixCommandKey commandKey = HystrixCommandKey.Factory.asKey(config.name);

             config.setter = Setter.withGroupKey(groupKey)

                     .andCommandKey(commandKey);

         }

         return (exchange, chain) -> {

             RouteHystrixCommand command = new RouteHystrixCommand(config.setter, config.fallbackUri, exchange, chain);

             return Mono.create(s -> {

                 Subscription sub = command.toObservable().subscribe(s::success, s::error, s::success);

                 s.onCancel(sub::unsubscribe);

             }).onErrorResume((Function<Throwable, Mono<Void>>) throwable -> {

                 if (throwable instanceof HystrixRuntimeException) {

                     HystrixRuntimeException e = (HystrixRuntimeException) throwable;

                     if (e.getFailureType() == TIMEOUT) { //TODO: optionally set status

                         setResponseStatus(exchange, HttpStatus.GATEWAY_TIMEOUT);

                         return exchange.getResponse().setComplete();

                     }

                 }

                 return Mono.error(throwable);

             }).then();

         };

     }

     //......

}

//TODO: replace with HystrixMonoCommand that we write

     private class RouteHystrixCommand extends HystrixObservableCommand<Void> {

         private final URI fallbackUri;

         private final ServerWebExchange exchange;

         private final GatewayFilterChain chain;

         RouteHystrixCommand(Setter setter, URI fallbackUri, ServerWebExchange exchange, GatewayFilterChain chain) {

             super (setter);

             this .fallbackUri = fallbackUri;

             this .exchange = exchange;

             this .chain = chain;

         }

         @Override

         protected Observable<Void> construct() {

             return RxReactiveStreams.toObservable( this .chain.filter(exchange));

         }

         @Override

         protected Observable<Void> resumeWithFallback() {

             if ( this .fallbackUri == null ) {

                 return super .resumeWithFallback();

             }

             //TODO: copied from RouteToRequestUrlFilter

             URI uri = exchange.getRequest().getURI();

             //TODO: assume always?

             boolean encoded = containsEncodedParts(uri);

             URI requestUrl = UriComponentsBuilder.fromUri(uri)

                     .host( null )

                     .port( null )

                     .uri( this .fallbackUri)

                     .build(encoded)

                     .toUri();

             exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);

             ServerHttpRequest request = this .exchange.getRequest().mutate().uri(requestUrl).build();

             ServerWebExchange mutated = exchange.mutate().request(request).build();

             return RxReactiveStreams.toObservable(HystrixGatewayFilterFactory. this .dispatcherHandler.handle(mutated));

         }

     }

public static class Config {

         private String name;

         private Setter setter;

         private URI fallbackUri;

         public String getName() {

             return name;

         }

         public Config setName(String name) {

             this .name = name;

             return this ;

         }

         public Config setFallbackUri(String fallbackUri) {

             if (fallbackUri != null ) {

                 setFallbackUri(URI.create(fallbackUri));

             }

             return this ;

         }

         public URI getFallbackUri() {

             return fallbackUri;

         }

         public void setFallbackUri(URI fallbackUri) {

             if (fallbackUri != null && ! "forward" .equals(fallbackUri.getScheme())) {

                 throw new IllegalArgumentException( "Hystrix Filter currently only supports 'forward' URIs, found " + fallbackUri);

             }

             this .fallbackUri = fallbackUri;

         }

         public Config setSetter(Setter setter) {

             this .setter = setter;

             return this ;

         }

     }