<dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
</dependencies>
<dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring-boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
</dependencyManagement>

Mono<Void> mono = Mono.fromRunnable(() -> dao.update(user));

Mono<User> mono = Mono.fromCallable(() -> dao.findById(1000L);

mono.map(user -> user.getId());

mono.flatMap(user -> userDao.deleteById(user.getId());

mono.subscribe(
    value -> System.out.println(value),
    ex -> ex.printStackTrace(),
    () -> System.out.println("No data")
);

Flux<User> flux = Flux.create(sink -> {
    final User[] users = userDao.findByName(name);
    if (users != null) {
        for (User user : users) {
            sink.next(user);
        }
        sink.complete();
    } else {
        sink.error(
            new IllegalStateException(
                "Invalid name: " + name));
    }
});

Flux<String> flux = Flux.just("123", "456", "789");

flux.map(str -> Longs.tryParse(str));

flux.flatMap(user -> userDao.deleteById(user.getId()));

mono.subscribe(
    value -> System.out.println(value),
    ex -> ex.printStackTrace(),
    () -> System.out.println("No data")
);

@RequestMapping("/root")
@RestController
public class WebFluxTestController {
    @GetMapping("/user/{id}")
    public Mono<UserDto> getUser(final String id) {
        return Mono.just(new Foobar());
    }
}

@Configuration
@ConditionalOnClass({ DispatcherHandler.class, HttpHandler.class })
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.REACTIVE)
@ConditionalOnMissingBean(HttpHandler.class)
@AutoConfigureAfter({ WebFluxAutoConfiguration.class })
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
public class HttpHandlerAutoConfiguration {
    @Configuration
    public static class AnnotationConfig {
        private ApplicationContext applicationContext;

        public AnnotationConfig(ApplicationContext applicationContext) {
            this.applicationContext = applicationContext;
        }

        @Bean
        public HttpHandler httpHandler() {
            return WebHttpHandlerBuilder.applicationContext(this.applicationContext).build();
        }
    }
}

public static final String WEB_HANDLER_BEAN_NAME = "webHandler";

private WebHttpHandlerBuilder(WebHandler webHandler, @Nullable ApplicationContext applicationContext) {
    this.webHandler = webHandler; // HERE
    this.applicationContext = applicationContext;
}

public static WebHttpHandlerBuilder applicationContext(ApplicationContext context) {
    WebHttpHandlerBuilder builder = new WebHttpHandlerBuilder(
            context.getBean(WEB_HANDLER_BEAN_NAME, WebHandler.class), context); // HERE

    // ...

    return builder;
}

public HttpHandler build() {
    WebHandler decorated = new FilteringWebHandler(this.webHandler, this.filters); // HERE
    decorated = new ExceptionHandlingWebHandler(decorated,  this.exceptionHandlers); // HERE

    HttpWebHandlerAdapter adapted = new HttpWebHandlerAdapter(decorated); //HERE

    // ...

    return adapted;
}

public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
    // ...

    return getDelegate().handle(exchange) // HERE
            .doOnSuccess(aVoid -> logResponse(exchange))
            .onErrorResume(ex -> handleUnresolvedError(exchange, ex))
            .then(Mono.defer(response::setComplete));
}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {

    Mono<Void> completion;
    try {
        completion = super.handle(exchange); // HERE
    } catch (Throwable ex) {
        completion = Mono.error(ex);
    }

    return completion;
}

this.chain = new DefaultWebFilterChain(handler, filters); // HERE

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    return this.chain.filter(exchange);
}

@Override
public Mono<Void> filter(ServerWebExchange exchange) {
    return Mono.defer(() ->
        this.currentFilter != null && this.next != null ?
                this.currentFilter.filter(exchange, this.next) :
                this.handler.handle(exchange));
}

@Bean
public DispatcherHandler webHandler() {
    return new DispatcherHandler();
}

protected void initStrategies(ApplicationContext context) {
    Map<String, HandlerMapping> mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
            context, HandlerMapping.class, true, false);

    ArrayList<HandlerMapping> mappings = new ArrayList<>(mappingBeans.values());
    AnnotationAwareOrderComparator.sort(mappings);
    this.handlerMappings = Collections.unmodifiableList(mappings);
}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    if (this.handlerMappings == null) {
        return createNotFoundError();
    }
    return Flux.fromIterable(this.handlerMappings)
            .concatMap(mapping -> mapping.getHandler(exchange))
            .next()
            .switchIfEmpty(createNotFoundError())
            .flatMap(handler -> invokeHandler(exchange, handler))
            .flatMap(result -> handleResult(exchange, result));
}

@Configuration
@ConditionalOnProperty(name = "spring.cloud.gateway.enabled", matchIfMissing = true)
@EnableConfigurationProperties
@AutoConfigureBefore({ HttpHandlerAutoConfiguration.class,
        WebFluxAutoConfiguration.class })
@AutoConfigureAfter({ GatewayLoadBalancerClientAutoConfiguration.class,
        GatewayClassPathWarningAutoConfiguration.class })
@ConditionalOnClass(DispatcherHandler.class)
public class GatewayAutoConfiguration {
    @Bean
    public RoutePredicateHandlerMapping routePredicateHandlerMapping(
            FilteringWebHandler webHandler, RouteLocator routeLocator,
            GlobalCorsProperties globalCorsProperties, Environment environment) {
        return new RoutePredicateHandlerMapping(webHandler, routeLocator,
                globalCorsProperties, environment);
    }

    @Bean
    @Primary
    // TODO: property to disable composite?
    public RouteLocator cachedCompositeRouteLocator(List<RouteLocator> routeLocators) {
        return new CachingRouteLocator(
                new CompositeRouteLocator(Flux.fromIterable(routeLocators)));
    }

    @Bean
    public FilteringWebHandler filteringWebHandler(List<GlobalFilter> globalFilters) {
        return new FilteringWebHandler(globalFilters);
    }
}

protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
return this.routeLocator.getRoutes()
        // individually filter routes so that filterWhen error delaying is not a
        // problem
        .concatMap(route -> Mono.just(route).filterWhen(r -> {
            // add the current route we are testing
            exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
            return r.getPredicate().apply(exchange);
        })
    // ...

public Mono<Void> handle(ServerWebExchange exchange) {
    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    List<GatewayFilter> gatewayFilters = route.getFilters();

    List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
    combined.addAll(gatewayFilters);

    AnnotationAwareOrderComparator.sort(combined);

    return new DefaultGatewayFilterChain(combined).filter(exchange);
}

public Mono<Void> filter(ServerWebExchange exchange) {
    return Mono.defer(() -> {
        if (this.index < filters.size()) {
            GatewayFilter filter = filters.get(this.index);
            DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this,
                    this.index + 1);
            return filter.filter(exchange, chain);
        }
        else {
            return Mono.empty(); // complete
        }
    });
}

public class CachingRouteLocator
        implements RouteLocator, ApplicationListener<RefreshRoutesEvent> {

    // ...
}

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;

    // ...
}

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

@Override
public Flux<Route> getRoutes() {
    return this.routeDefinitionLocator.getRouteDefinitions().map(this::convertToRoute)
            .map(route -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("RouteDefinition matched: " + route.getId());
                }
                return route;
            });
}

package org.springframework.cloud.gateway.route;
public interface RouteDefinitionLocator {
    Flux<RouteDefinition> getRouteDefinitions();
}

@Bean
@Primary
public RouteDefinitionLocator routeDefinitionLocator(
        List<RouteDefinitionLocator> routeDefinitionLocators) {
    return new CompositeRouteDefinitionLocator(
            Flux.fromIterable(routeDefinitionLocators));
}

public class RouteDefinition {
    @NotEmpty
    private String id = UUID.randomUUID().toString();

    @NotEmpty
    @Valid
    private List<PredicateDefinition> predicates = new ArrayList<>();

    @Valid
    private List<FilterDefinition> filters = new ArrayList<>();

    @NotNull
    private URI uri;

    private int order = 0;

    // ...
}

@Bean
RouteLocator constantRouteLocator(final RouteLocatorBuilder builder) {
    return builder.routes()
        .route("demo_lb", r -> r.header("XHOST")
            .filters(f -> f.prefixPath("/search"))
            .uri("lb://httpbin.org"))
        .build();
}

spring:
    cloud:
        gateway:
            routes:
                - id: r1
                  order: 2
                  uri: "https://a.com"
                  predicates:
                      - host=a.org
                  filters:
                      - AddRequestHeader=XHOST,my.a.org
                - id: r2
                  order: 1
                  uri: "https://b.com"
                  predicates:
                      - Host=b.org
                  filters:
                      - AddRequestHeader=XHOST,my.b.org

public class Route implements Ordered {

    private final String id;

    private final URI uri;

    private final int order;

    private final AsyncPredicate<ServerWebExchange> predicate; // HERE

    private final List<GatewayFilter> gatewayFilters;

    // ...
}

public class PredicateDefinition {
    @NotNull
    private String name;

    private Map<String, String> args = new LinkedHashMap<>();

    // ...
}

public interface RoutePredicateFactory<C> extends ShortcutConfigurable, Configurable<C> {
    AsyncPredicate<ServerWebExchange> applyAsync(Consumer<C> consumer);

    Class<C> getConfigClass();
}

public interface GatewayFilter extends ShortcutConfigurable {
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}

public class FilterDefinition {
    @NotNull
    private String name;

    private Map<String, String> args = new LinkedHashMap<>();

    // ...
}

public interface GatewayFilterFactory<C> extends ShortcutConfigurable, Configurable<C> {
    default GatewayFilter apply(Consumer<C> consumer) {
        C config = newConfig();
        consumer.accept(config);
        return apply(config);
    }

    default Class<C> getConfigClass() {
        throw new UnsupportedOperationException("getConfigClass() not implemented");
    }
}

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

public interface KeyResolver {
    Mono<String> resolve(ServerWebExchange exchange);
}

public interface RateLimiter<C> extends StatefulConfigurable<C> {
    Mono<Response> isAllowed(String routeId, String id);
}

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

ServiceInstance choose(String serviceId);

URI reconstructURI(ServiceInstance instance, URI original);

public interface ILoadBalancer {
    public void addServers(List<Server> newServers);

    public Server chooseServer(Object key);

    public void markServerDown(Server server);

    public List<Server> getReachableServers();

    public List<Server> getAllServers();
}

public ILoadBalancer getLoadBalancer(String name) {
    return getInstance(name, ILoadBalancer.class);
}