Analysis of SpringCloud Gateway routing configuration and positioning principles

[[409660]]

Environment: springcloud Hoxton.SR11

This section mainly explains how the predicates in the system are initialized and associated with the configured routing information to generate routing objects, and how the Config object in each predicate factory is parsed and configured.

How the property values ​​in Config in all predicate factories are configured.

All predicate factories in SpringCloud Gateway are as follows:

Naming convention: XxxRoutePredicateFactory. All these predicate factories have the following inheritance relationship

 public class MethodRoutePredicateFactory extends AbstractRoutePredicateFactory<MethodRoutePredicateFactory.Config>
 //
 public class PathRoutePredicateFactory extends AbstractRoutePredicateFactory<PathRoutePredicateFactory.Config>
 // ...

All predicate factories inherit

The generic types in AbstractRoutePredicateFactory are all Config inner classes. How is this configured?

6.1 Gateway automatic configuration

All Predicates and Filters are configured in the following class.

 public class GatewayAutoConfiguration {
 @Bean
  @ConditionalOnEnabledPredicate
 public PathRoutePredicateFactory pathRoutePredicateFactory() {
 return new PathRoutePredicateFactory();
 }
 @Bean
  @ConditionalOnEnabledPredicate
 public QueryRoutePredicateFactory queryRoutePredicateFactory() {
 return new QueryRoutePredicateFactory();
 }
 @Bean
 public RouteLocator routeDefinitionRouteLocator(GatewayProperties properties, List<GatewayFilterFactory> gatewayFilters, List<RoutePredicateFactory> predicates, RouteDefinitionLocator routeDefinitionLocator, ConfigurationService configurationService) {
 return new RouteDefinitionRouteLocator(routeDefinitionLocator, predicates,
            gatewayFilters, properties, configurationService);
 }
 @Bean
 @Primary  
  @ConditionalOnMissingBean( name = "cachedCompositeRouteLocator" )
 public RouteLocator cachedCompositeRouteLocator(List<RouteLocator> routeLocators) {
 return new CachingRouteLocator(new CompositeRouteLocator(Flux.fromIterable(routeLocators)));
 }
 }

Here, the final lookup of the routing location will be handed over to

RouteDefinitionRouteLocator. CachingRouteLocator acts as a cache to save all configured routing information.

Note: The routing information here will be initialized after the container is started.

 public class CachingRouteLocator {
  private final RouteLocator delegate; 
 
  private final Flux<Route> routes; 
 
  private final Map<String, List> cache = new ConcurrentHashMap<>(); 
 
  private ApplicationEventPublisher applicationEventPublisher; 
 
 public CachingRouteLocator(RouteLocator delegate) {
 this.delegate = delegate;
    routes = CacheFlux.lookup(cache, CACHE_KEY, Route.class) .onCacheMissResume(this:: fetch );
 } 
 
  private Flux<Route> fetch () {
 return this.delegate.getRoutes().sort(AnnotationAwareOrderComparator.INSTANCE);
 }
 }

Instantiating CachingRouteLocator starts looking for all configured Route information. The final result will be delegated to

RouteDefinitionRouteLocator

The initFactories method in the RouteDefinitionRouteLocator constructor is used to map the XxxRoutePredicateFactory of the routing factory.

 private void initFactories(List<RoutePredicateFactory> predicates) {
  predicates.forEach(factory -> {
    String key = factory. name ();
    if (this.predicates.containsKey( key )) {
      this.logger.warn( "A RoutePredicateFactory named " + key + " already exists, class: " + this.predicates.get( key ) + ". It will be overwritten." );
 }
    this.predicates.put( key , factory);
 });
 }

The method resolves the name corresponding to each predicate factory and caches it in the predicates collection.

The factory.name() method resolves the predicate name.

 default String name () {
 return NameUtils.normalizeRoutePredicateName(getClass());
 }

CachingRouteLocator is a caching route locator, which is the preferred RouteLocator (@Primary).

RouteDefinitionRouteLocator was merged.

6.2 Generate route object Route and Config configuration

getRoutes---》convertToRoute---》combinePredicates---》lookup.

According to the automatic configuration above, we also know that all routing information is initialized when the service starts.

Get routing information

 public Flux<Route> getRoutes() {
  Flux<Route> routes = this.routeDefinitionLocator.getRouteDefinitions() .map(this::convertToRoute);
  routes = routes.onErrorContinue((error, obj) -> {
 return routes.map(route -> {
 return route;
 });
 }

Merge predicates

 private AsyncPredicate<ServerWebExchange> combinePredicates(
            RouteDefinition routeDefinition) {
 // other code
 for (PredicateDefinition andPredicate : predicates.subList(1, predicates. size ())) {
    AsyncPredicate<ServerWebExchange> found = lookup(routeDefinition, andPredicate);
    predicate = predicate. and (found);
 }
 return predicate;
 }

Enter the lookup

 private AsyncPredicate<ServerWebExchange> lookup(RouteDefinition route, PredicateDefinition predicate) {
  RoutePredicateFactory<Object> factory = this.predicates.get(predicate.getName());
 if (factory == null ) {
    throw new IllegalArgumentException( "Unable to find RoutePredicateFactory with name " + predicate.getName());
 }
 // Here, the name and args configured in the configuration (yml file) are associated with the Config in the predicate factory to set the value
  Object config = this.configurationService.with (factory )
    .name (predicate.getName())
    .properties(predicate.getArgs())
    .eventFunction((bound, properties) -> new PredicateArgsEvent(
        RouteDefinitionRouteLocator.this, route.getId(), properties))
 .bind();
 //Finally call the predicate factory (the apply method of XxxRoutePredicateFactory returns the RoutePredicate object that inherits Predicate)
 return factory.applyAsync(config);
 }

Lookup method, that is, here the corresponding predicate Config is associated with the corresponding attribute defined in RouteDefinition(Predicate).

Enter the factory.applyAsync method

 @FunctionalInterface
 public interface RoutePredicateFactory<C> extends ShortcutConfigurable, Configurable<C> {
 default AsyncPredicate<ServerWebExchange> applyAsync(C config) {
 return toAsyncPredicate(apply(config)); // See the following 6.2-1 figure. All the implementations of the current apply are the XxxRoutePredicateFactory defined in the system.
 }
 }
 // apply(config), if the Path predicate is configured here, then it will enter the apply method in PathRoutePredicateFactory
 public Predicate<ServerWebExchange> apply(Config config) {
 // other code
 return new GatewayPredicate() {
 public boolean test() {
 // todo
 }
 }
 }
 //Finally returns an asynchronous predicate
 public   static AsyncPredicate<ServerWebExchange> toAsyncPredicate(Predicate<? super ServerWebExchange> predicate) {
  Assert.notNull(predicate, "predicate must not be null" );
 // Here from returns a DefaultAsyncPredicate default asynchronous predicate
 return AsyncPredicate. from (predicate);
 }
 static AsyncPredicate<ServerWebExchange> from ( Predicate<? super ServerWebExchange> predicate) {
 return new DefaultAsyncPredicate<>(GatewayPredicate.wrapIfNeeded(predicate));
 }

Finally, in the combinePredicates method, all predicates configured in the current route are returned by AND operation. Finally, in the convertToRoute method, the predicates and filters configured in the current route are integrated and packaged to return Route (a route object)

 public class Route implements Ordered {
 private final String id; 
    
 private final URI uri; 
    
 private final int   order ; 
    
  private final AsyncPredicate<ServerWebExchange> predicate; 
    
  private final List<GatewayFilter> gatewayFilters; 
    
  private final Map<String, Object> metadata;
 }

These Route objects will be saved in the above

CachingRouteLocator.routes.

6.3 Positioning Routes

According to the above configuration, the RouteLocator class is used to locate the route (find which specific route to use); when a request comes in, it will find which route it is.

RouteLocator defines a method

 public interface RouteLocator { 
 
 Flux<Route> getRoutes(); 
 
 }

Check who called the getRoutes method

See this

Does RoutePredicateHandlerMapping remind you of HandlerMapping in Spring MVC (all our Controllers will be matched by RequestMappingHandlerMapping). By the name, you can know who this HandlerMapping is used to match our route predicate to handle the route.

Let’s go back to what I said before.

RequestMappingHanlderMapping object. When we request a routing address, the lookup method in this class will be executed to find the routing.

 protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
 // this.routeLocator here is the CachingRouteLocator object
 return this.routeLocator.getRoutes()
      .concatMap(route -> Mono.just(route).filterWhen(r -> {
        exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
 // Filter and find matching routes
 return r.getPredicate().apply(exchange);
     }).doOnError(e -> logger.error(
 "Error applying predicate for route: " + route.getId(),
     e)).onErrorResume(e -> Mono.empty()))
 .next ()
 .map(route -> {
          if (logger.isDebugEnabled()) {
            logger.debug( "Route matched: " + route.getId());
 }
          validateRoute(route, exchange);
 return route;
 });
 }

Enter r.getPredicate().apply(exchange)

 public interface AsyncPredicate<T> extends Function <T, Publisher<Boolean>> {
 static AsyncPredicate<ServerWebExchange> from (Predicate<? super ServerWebExchange> predicate) {
 return new DefaultAsyncPredicate<>(GatewayPredicate.wrapIfNeeded(predicate));
 } 
 
  class DefaultAsyncPredicate<T> implements AsyncPredicate<T> { 
 
    private final Predicate<T> delegate; 
 
 public DefaultAsyncPredicate(Predicate<T> delegate) {
      this.delegate = delegate;
 } 
 
 @Override
 public Publisher<Boolean> apply(T t) {
 return Mono.just(delegate.test(t));
 } 
 
 @Override
 public String toString() {
 return this.delegate.toString();
 } 
 
 } 
 
 }

The Predicate.test method (the GatewayPredicate returned by the apply method in XxxRoutePredicateFactory) will be called here.

Call GatewayPredicate.test to return whether the route of the current request matches.

The overall process:

1. The system first initializes all Predicates and Filters

2. Package and return Route object according to the configured routing information (filter, predicate)

3. Find matching routes based on request routing path