springboot webflux 简介
**********************
简介
基于reactor实现的异步非阻塞框架，较同步阻塞的MVC框架，可提升系统性能；
可使用MVC的注解操作，也可使用函数式编程；
支持传统的servlet容器，还可运行在支持nio的netty、undertow容器中
**********************
相关类与接口
ServerWebExchange：获取request、response、session
public interface ServerWebExchange {
String LOG_ID_ATTRIBUTE = ServerWebExchange.class.getName() + ".LOG_ID";
ServerHttpRequest getRequest(); //获取request
ServerHttpResponse getResponse(); //获取response
Map<String, Object> getAttributes(); //获取请求中的属性
@Nullable
default <T> T getAttribute(String name) {
return this.getAttributes().get(name);
}
default <T> T getRequiredAttribute(String name) {
T value = this.getAttribute(name);
Assert.notNull(value, () -> {
return "Required attribute '" + name + "' is missing";
});
return value;
}
default <T> T getAttributeOrDefault(String name, T defaultValue) {
return this.getAttributes().getOrDefault(name, defaultValue);
}
Mono<WebSession> getSession(); //获取webSession
<T extends Principal> Mono<T> getPrincipal(); //获取认证用户
Mono<MultiValueMap<String, String>> getFormData(); //获取表单参数
Mono<MultiValueMap<String, Part>> getMultipartData(); //获取表单multipart数据
LocaleContext getLocaleContext(); //获取国际化设置（Locale）
@Nullable
ApplicationContext getApplicationContext(); //获取应用上下文
boolean isNotModified();
boolean checkNotModified(Instant var1);
boolean checkNotModified(String var1);
boolean checkNotModified(@Nullable String var1, Instant var2);
String transformUrl(String var1);
void addUrlTransformer(Function<String, String> var1);
String getLogPrefix();
default ServerWebExchange.Builder mutate() {
return new DefaultServerWebExchangeBuilder(this);
}
public interface Builder { //构造ServeraWebExchange
ServerWebExchange.Builder request(Consumer<org.springframework.http.server.reactive.ServerHttpRequest.Builder> var1);
ServerWebExchange.Builder request(ServerHttpRequest var1); //设置请求
ServerWebExchange.Builder response(ServerHttpResponse var1); //设置响应
ServerWebExchange.Builder principal(Mono<Principal> var1); //设置认证用户
ServerWebExchange build(); //返回ServerWebExchange
}
}
**********************
ServerHttpRequest
ServerHttpRequest
public interface ServerHttpRequest extends HttpRequest, ReactiveHttpInputMessage {
String getId();
RequestPath getPath();
MultiValueMap<String, String> getQueryParams();
MultiValueMap<String, HttpCookie> getCookies();
@Nullable
default InetSocketAddress getLocalAddress() {
return null;
}
@Nullable
default InetSocketAddress getRemoteAddress() {
return null;
}
@Nullable
default SslInfo getSslInfo() {
return null;
}
default ServerHttpRequest.Builder mutate() {
return new DefaultServerHttpRequestBuilder(this);
}
public interface Builder {
ServerHttpRequest.Builder method(HttpMethod var1);
ServerHttpRequest.Builder uri(URI var1);
ServerHttpRequest.Builder path(String var1);
ServerHttpRequest.Builder contextPath(String var1);
ServerHttpRequest.Builder header(String var1, String... var2);
ServerHttpRequest.Builder headers(Consumer<HttpHeaders> var1);
ServerHttpRequest.Builder sslInfo(SslInfo var1);
ServerHttpRequest build();
}
}
HttpRequest
public interface HttpRequest extends HttpMessage {
@Nullable
default HttpMethod getMethod() {
return HttpMethod.resolve(this.getMethodValue()); //将请求方法转换为HttpMethod
}
String getMethodValue(); //获取请求方法
URI getURI(); //获取请求uri
}
HttpMessage
public interface HttpMessage {
HttpHeaders getHeaders(); //获取请求头
}
ReactiveHttpInputMessage
public interface ReactiveHttpInputMessage extends HttpMessage {
Flux<DataBuffer> getBody();
}
**********************
ServerHttpResponse
ServerHttpResponse
public interface ServerHttpResponse extends ReactiveHttpOutputMessage {
boolean setStatusCode(@Nullable HttpStatus var1);
@Nullable
HttpStatus getStatusCode();
default boolean setRawStatusCode(@Nullable Integer value) {
if (value == null) {
return this.setStatusCode((HttpStatus)null);
} else {
HttpStatus httpStatus = HttpStatus.resolve(value);
if (httpStatus == null) {
throw new IllegalStateException("Unresolvable HttpStatus for general ServerHttpResponse: " + value);
} else {
return this.setStatusCode(httpStatus);
}
}
}
@Nullable
default Integer getRawStatusCode() {
HttpStatus httpStatus = this.getStatusCode();
return httpStatus != null ? httpStatus.value() : null;
}
MultiValueMap<String, ResponseCookie> getCookies();
void addCookie(ResponseCookie var1);
}
ReactiveHttpOutputMessage
public interface ReactiveHttpOutputMessage extends HttpMessage {
DataBufferFactory bufferFactory();
void beforeCommit(Supplier<? extends Mono<Void>> var1);
boolean isCommitted();
Mono<Void> writeWith(Publisher<? extends DataBuffer> var1);
Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> var1);
Mono<Void> setComplete();
}
**********************
WebSession
webSession：存储应用session数据
public interface WebSession {
String getId();
Map<String, Object> getAttributes();
@Nullable
default <T> T getAttribute(String name) {
return this.getAttributes().get(name);
}
default <T> T getRequiredAttribute(String name) {
T value = this.getAttribute(name);
Assert.notNull(value, () -> {
return "Required attribute '" + name + "' is missing.";
});
return value;
}
default <T> T getAttributeOrDefault(String name, T defaultValue) {
return this.getAttributes().getOrDefault(name, defaultValue);
}
void start();
boolean isStarted();
Mono<Void> changeSessionId();
Mono<Void> invalidate();
Mono<Void> save();
boolean isExpired();
Instant getCreationTime();
Instant getLastAccessTime();
void setMaxIdleTime(Duration var1);
Duration getMaxIdleTime();
}
**********************
context信息
LocaleContext：国际化上下文
public interface LocaleContext {
@Nullable
Locale getLocale();
}
ApplicationContext：应用上下文
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
@Nullable
String getId();
String getApplicationName();
String getDisplayName();
long getStartupDate();
@Nullable
ApplicationContext getParent();
AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}
**********************
函数式类与接口
**********************
RouterFunction
RouterFunction
@FunctionalInterface
public interface RouterFunction<T extends ServerResponse> {
Mono<HandlerFunction<T>> route(ServerRequest var1);
default RouterFunction<T> and(RouterFunction<T> other) {
return new SameComposedRouterFunction(this, other);
}
default RouterFunction<?> andOther(RouterFunction<?> other) {
return new DifferentComposedRouterFunction(this, other);
}
default RouterFunction<T> andRoute(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
return this.and(RouterFunctions.route(predicate, handlerFunction));
}
default RouterFunction<T> andNest(RequestPredicate predicate, RouterFunction<T> routerFunction) {
return this.and(RouterFunctions.nest(predicate, routerFunction));
}
default <S extends ServerResponse> RouterFunction<S> filter(HandlerFilterFunction<T, S> filterFunction) {
return new FilteredRouterFunction(this, filterFunction);
}
default void accept(Visitor visitor) {
visitor.unknown(this);
}
}
RouterFunctionBuilder：构造RouterFunction
class RouterFunctionBuilder implements Builder {
private List<RouterFunction<ServerResponse>> routerFunctions = new ArrayList();
private List<HandlerFilterFunction<ServerResponse, ServerResponse>> filterFunctions = new ArrayList();
RouterFunctionBuilder() {
}
public Builder add(RouterFunction<ServerResponse> routerFunction) {
Assert.notNull(routerFunction, "RouterFunction must not be null");
this.routerFunctions.add(routerFunction);
return this;
}
private Builder add(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
this.routerFunctions.add(RouterFunctions.route(predicate, handlerFunction));
return this;
}
public Builder GET(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.GET(pattern), handlerFunction);
}
public Builder GET(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.GET(pattern).and(predicate), handlerFunction);
}
public Builder HEAD(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.HEAD(pattern), handlerFunction);
}
public Builder HEAD(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.HEAD(pattern).and(predicate), handlerFunction);
}
public Builder POST(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.POST(pattern), handlerFunction);
}
public Builder POST(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.POST(pattern).and(predicate), handlerFunction);
}
public Builder PUT(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.PUT(pattern), handlerFunction);
}
public Builder PUT(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.PUT(pattern).and(predicate), handlerFunction);
}
public Builder PATCH(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.PATCH(pattern), handlerFunction);
}
public Builder PATCH(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.PATCH(pattern).and(predicate), handlerFunction);
}
public Builder DELETE(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.DELETE(pattern), handlerFunction);
}
public Builder DELETE(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.DELETE(pattern).and(predicate), handlerFunction);
}
public Builder OPTIONS(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.OPTIONS(pattern), handlerFunction);
}
public Builder OPTIONS(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RequestPredicates.OPTIONS(pattern).and(predicate), handlerFunction);
}
public Builder route(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
return this.add(RouterFunctions.route(predicate, handlerFunction));
}
public Builder resources(String pattern, Resource location) {
return this.add(RouterFunctions.resources(pattern, location));
}
public Builder resources(Function<ServerRequest, Mono<Resource>> lookupFunction) {
return this.add(RouterFunctions.resources(lookupFunction));
}
public Builder nest(RequestPredicate predicate, Consumer<Builder> builderConsumer) {
Assert.notNull(builderConsumer, "Consumer must not be null");
RouterFunctionBuilder nestedBuilder = new RouterFunctionBuilder();
builderConsumer.accept(nestedBuilder);
RouterFunction<ServerResponse> nestedRoute = nestedBuilder.build();
this.routerFunctions.add(RouterFunctions.nest(predicate, nestedRoute));
return this;
}
public Builder nest(RequestPredicate predicate, Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) {
Assert.notNull(routerFunctionSupplier, "RouterFunction Supplier must not be null");
RouterFunction<ServerResponse> nestedRoute = (RouterFunction)routerFunctionSupplier.get();
this.routerFunctions.add(RouterFunctions.nest(predicate, nestedRoute));
return this;
}
public Builder path(String pattern, Consumer<Builder> builderConsumer) {
return this.nest(RequestPredicates.path(pattern), builderConsumer);
}
public Builder path(String pattern, Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) {
return this.nest(RequestPredicates.path(pattern), routerFunctionSupplier);
}
public Builder filter(HandlerFilterFunction<ServerResponse, ServerResponse> filterFunction) {
Assert.notNull(filterFunction, "HandlerFilterFunction must not be null");
this.filterFunctions.add(filterFunction);
return this;
}
public Builder before(Function<ServerRequest, ServerRequest> requestProcessor) {
Assert.notNull(requestProcessor, "RequestProcessor must not be null");
return this.filter((request, next) -> {
return next.handle((ServerRequest)requestProcessor.apply(request));
});
}
public Builder after(BiFunction<ServerRequest, ServerResponse, ServerResponse> responseProcessor) {
Assert.notNull(responseProcessor, "ResponseProcessor must not be null");
return this.filter((request, next) -> {
return next.handle(request).map((serverResponse) -> {
return (ServerResponse)responseProcessor.apply(request, serverResponse);
});
});
}
public Builder onError(Predicate<? super Throwable> predicate, BiFunction<? super Throwable, ServerRequest, Mono<ServerResponse>> responseProvider) {
Assert.notNull(predicate, "Predicate must not be null");
Assert.notNull(responseProvider, "ResponseProvider must not be null");
return this.filter((request, next) -> {
return next.handle(request).onErrorResume(predicate, (t) -> {
return (Mono)responseProvider.apply(t, request);
});
});
}
public <T extends Throwable> Builder onError(Class<T> exceptionType, BiFunction<? super T, ServerRequest, Mono<ServerResponse>> responseProvider) {
Assert.notNull(exceptionType, "ExceptionType must not be null");
Assert.notNull(responseProvider, "ResponseProvider must not be null");
return this.filter((request, next) -> {
return next.handle(request).onErrorResume(exceptionType, (t) -> {
return (Mono)responseProvider.apply(t, request);
});
});
}
public RouterFunction<ServerResponse> build() {
if (this.routerFunctions.isEmpty()) {
throw new IllegalStateException("No routes registered. Register a route with GET(), POST(), etc.");
} else {
RouterFunction<ServerResponse> result = new RouterFunctionBuilder.BuiltRouterFunction(this.routerFunctions);
if (this.filterFunctions.isEmpty()) {
return result;
} else {
HandlerFilterFunction<ServerResponse, ServerResponse> filter = (HandlerFilterFunction)this.filterFunctions.stream().reduce(HandlerFilterFunction::andThen).orElseThrow(IllegalStateException::new);
return result.filter(filter);
}
}
}
private static class BuiltRouterFunction extends AbstractRouterFunction<ServerResponse> {
private List<RouterFunction<ServerResponse>> routerFunctions;
public BuiltRouterFunction(List<RouterFunction<ServerResponse>> routerFunctions) {
Assert.notEmpty(routerFunctions, "RouterFunctions must not be empty");
this.routerFunctions = routerFunctions;
}
public Mono<HandlerFunction<ServerResponse>> route(ServerRequest request) {
return Flux.fromIterable(this.routerFunctions).concatMap((routerFunction) -> {
return routerFunction.route(request);
}).next();
}
public void accept(Visitor visitor) {
this.routerFunctions.forEach((routerFunction) -> {
routerFunction.accept(visitor);
});
}
}
}
RouterFunctions：构造RouterFunction
public abstract class RouterFunctions {
private static final Log logger = LogFactory.getLog(RouterFunctions.class);
public static final String REQUEST_ATTRIBUTE = RouterFunctions.class.getName() + ".request";
public static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE = RouterFunctions.class.getName() + ".uriTemplateVariables";
public static final String MATCHING_PATTERN_ATTRIBUTE = RouterFunctions.class.getName() + ".matchingPattern";
public RouterFunctions() {
}
public static RouterFunctions.Builder route() {
return new RouterFunctionBuilder();
}
public static <T extends ServerResponse> RouterFunction<T> route(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
return new RouterFunctions.DefaultRouterFunction(predicate, handlerFunction);
}
public static <T extends ServerResponse> RouterFunction<T> nest(RequestPredicate predicate, RouterFunction<T> routerFunction) {
return new RouterFunctions.DefaultNestedRouterFunction(predicate, routerFunction);
}
public static RouterFunction<ServerResponse> resources(String pattern, Resource location) {
return resources(resourceLookupFunction(pattern, location));
}
public static Function<ServerRequest, Mono<Resource>> resourceLookupFunction(String pattern, Resource location) {
return new PathResourceLookupFunction(pattern, location);
}
public static RouterFunction<ServerResponse> resources(Function<ServerRequest, Mono<Resource>> lookupFunction) {
return new RouterFunctions.ResourcesRouterFunction(lookupFunction);
}
public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction) {
return toHttpHandler(routerFunction, HandlerStrategies.withDefaults());
}
public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies) {
WebHandler webHandler = toWebHandler(routerFunction, strategies);
return WebHttpHandlerBuilder.webHandler(webHandler).filters((filters) -> {
filters.addAll(strategies.webFilters());
}).exceptionHandlers((handlers) -> {
handlers.addAll(strategies.exceptionHandlers());
}).localeContextResolver(strategies.localeContextResolver()).build();
}
public static WebHandler toWebHandler(RouterFunction<?> routerFunction) {
return toWebHandler(routerFunction, HandlerStrategies.withDefaults());
}
public static WebHandler toWebHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies) {
Assert.notNull(routerFunction, "RouterFunction must not be null");
Assert.notNull(strategies, "HandlerStrategies must not be null");
return new RouterFunctions.RouterFunctionWebHandler(strategies, routerFunction);
}
private static class RouterFunctionWebHandler implements WebHandler {
private static final HandlerFunction<ServerResponse> NOT_FOUND_HANDLER = (request) -> {
return ServerResponse.notFound().build();
};
private final HandlerStrategies strategies;
private final RouterFunction<?> routerFunction;
public RouterFunctionWebHandler(HandlerStrategies strategies, RouterFunction<?> routerFunction) {
this.strategies = strategies;
this.routerFunction = routerFunction;
}
public Mono<Void> handle(ServerWebExchange exchange) {
return Mono.defer(() -> {
ServerRequest request = new DefaultServerRequest(exchange, this.strategies.messageReaders());
this.addAttributes(exchange, request);
return this.routerFunction.route(request).defaultIfEmpty(notFound()).flatMap((handlerFunction) -> {
return wrapException(() -> {
return handlerFunction.handle(request);
});
}).flatMap((response) -> {
return wrapException(() -> {
return response.writeTo(exchange, new RouterFunctions.HandlerStrategiesResponseContext(this.strategies));
});
});
});
}
private void addAttributes(ServerWebExchange exchange, ServerRequest request) {
Map<String, Object> attributes = exchange.getAttributes();
attributes.put(RouterFunctions.REQUEST_ATTRIBUTE, request);
}
private static <T extends ServerResponse> HandlerFunction<T> notFound() {
return NOT_FOUND_HANDLER;
}
private static <T> Mono<T> wrapException(Supplier<Mono<T>> supplier) {
try {
return (Mono)supplier.get();
} catch (Throwable var2) {
return Mono.error(var2);
}
}
}
private static class HandlerStrategiesResponseContext implements Context {
private final HandlerStrategies strategies;
public HandlerStrategiesResponseContext(HandlerStrategies strategies) {
this.strategies = strategies;
}
public List<HttpMessageWriter<?>> messageWriters() {
return this.strategies.messageWriters();
}
public List<ViewResolver> viewResolvers() {
return this.strategies.viewResolvers();
}
}
private static class ResourcesRouterFunction extends RouterFunctions.AbstractRouterFunction<ServerResponse> {
private final Function<ServerRequest, Mono<Resource>> lookupFunction;
public ResourcesRouterFunction(Function<ServerRequest, Mono<Resource>> lookupFunction) {
Assert.notNull(lookupFunction, "Function must not be null");
this.lookupFunction = lookupFunction;
}
public Mono<HandlerFunction<ServerResponse>> route(ServerRequest request) {
return ((Mono)this.lookupFunction.apply(request)).map(ResourceHandlerFunction::new);
}
public void accept(RouterFunctions.Visitor visitor) {
visitor.resources(this.lookupFunction);
}
}
private static final class DefaultNestedRouterFunction<T extends ServerResponse> extends RouterFunctions.AbstractRouterFunction<T> {
private final RequestPredicate predicate;
private final RouterFunction<T> routerFunction;
public DefaultNestedRouterFunction(RequestPredicate predicate, RouterFunction<T> routerFunction) {
Assert.notNull(predicate, "Predicate must not be null");
Assert.notNull(routerFunction, "RouterFunction must not be null");
this.predicate = predicate;
this.routerFunction = routerFunction;
}
public Mono<HandlerFunction<T>> route(ServerRequest serverRequest) {
return (Mono)this.predicate.nest(serverRequest).map((nestedRequest) -> {
if (RouterFunctions.logger.isTraceEnabled()) {
String logPrefix = serverRequest.exchange().getLogPrefix();
RouterFunctions.logger.trace(logPrefix + String.format("Matched nested %s", this.predicate));
}
return this.routerFunction.route(nestedRequest).doOnNext((match) -> {
if (nestedRequest != serverRequest) {
serverRequest.attributes().clear();
serverRequest.attributes().putAll(nestedRequest.attributes());
}
});
}).orElseGet(Mono::empty);
}
public void accept(RouterFunctions.Visitor visitor) {
visitor.startNested(this.predicate);
this.routerFunction.accept(visitor);
visitor.endNested(this.predicate);
}
}
private static final class DefaultRouterFunction<T extends ServerResponse> extends RouterFunctions.AbstractRouterFunction<T> {
private final RequestPredicate predicate;
private final HandlerFunction<T> handlerFunction;
public DefaultRouterFunction(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
Assert.notNull(predicate, "Predicate must not be null");
Assert.notNull(handlerFunction, "HandlerFunction must not be null");
this.predicate = predicate;
this.handlerFunction = handlerFunction;
}
public Mono<HandlerFunction<T>> route(ServerRequest request) {
if (this.predicate.test(request)) {
if (RouterFunctions.logger.isTraceEnabled()) {
String logPrefix = request.exchange().getLogPrefix();
RouterFunctions.logger.trace(logPrefix + String.format("Matched %s", this.predicate));
}
return Mono.just(this.handlerFunction);
} else {
return Mono.empty();
}
}
public void accept(RouterFunctions.Visitor visitor) {
visitor.route(this.predicate, this.handlerFunction);
}
}
static final class FilteredRouterFunction<T extends ServerResponse, S extends ServerResponse> implements RouterFunction<S> {
private final RouterFunction<T> routerFunction;
private final HandlerFilterFunction<T, S> filterFunction;
public FilteredRouterFunction(RouterFunction<T> routerFunction, HandlerFilterFunction<T, S> filterFunction) {
this.routerFunction = routerFunction;
this.filterFunction = filterFunction;
}
public Mono<HandlerFunction<S>> route(ServerRequest request) {
Mono var10000 = this.routerFunction.route(request);
HandlerFilterFunction var10001 = this.filterFunction;
var10001.getClass();
return var10000.map(var10001::apply);
}
public void accept(RouterFunctions.Visitor visitor) {
this.routerFunction.accept(visitor);
}
public String toString() {
return this.routerFunction.toString();
}
}
static final class DifferentComposedRouterFunction extends RouterFunctions.AbstractRouterFunction<ServerResponse> {
private final RouterFunction<?> first;
private final RouterFunction<?> second;
public DifferentComposedRouterFunction(RouterFunction<?> first, RouterFunction<?> second) {
this.first = first;
this.second = second;
}
public Mono<HandlerFunction<ServerResponse>> route(ServerRequest request) {
return Flux.concat(new Publisher[]{this.first.route(request), Mono.defer(() -> {
return this.second.route(request);
})}).next().map(this::cast);
}
private <T extends ServerResponse> HandlerFunction<T> cast(HandlerFunction<?> handlerFunction) {
return handlerFunction;
}
public void accept(RouterFunctions.Visitor visitor) {
this.first.accept(visitor);
this.second.accept(visitor);
}
}
static final class SameComposedRouterFunction<T extends ServerResponse> extends RouterFunctions.AbstractRouterFunction<T> {
private final RouterFunction<T> first;
private final RouterFunction<T> second;
public SameComposedRouterFunction(RouterFunction<T> first, RouterFunction<T> second) {
this.first = first;
this.second = second;
}
public Mono<HandlerFunction<T>> route(ServerRequest request) {
return Flux.concat(new Publisher[]{this.first.route(request), Mono.defer(() -> {
return this.second.route(request);
})}).next();
}
public void accept(RouterFunctions.Visitor visitor) {
this.first.accept(visitor);
this.second.accept(visitor);
}
}
abstract static class AbstractRouterFunction<T extends ServerResponse> implements RouterFunction<T> {
AbstractRouterFunction() {
}
public String toString() {
ToStringVisitor visitor = new ToStringVisitor();
this.accept(visitor);
return visitor.toString();
}
}
public interface Visitor {
void startNested(RequestPredicate var1);
void endNested(RequestPredicate var1);
void route(RequestPredicate var1, HandlerFunction<?> var2);
void resources(Function<ServerRequest, Mono<Resource>> var1);
void unknown(RouterFunction<?> var1);
}
public interface Builder { //构造routerFunction
RouterFunctions.Builder GET(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder GET(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder HEAD(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder HEAD(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder POST(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder POST(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder PUT(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder PUT(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder PATCH(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder PATCH(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder DELETE(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder DELETE(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder OPTIONS(String var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder OPTIONS(String var1, RequestPredicate var2, HandlerFunction<ServerResponse> var3);
RouterFunctions.Builder route(RequestPredicate var1, HandlerFunction<ServerResponse> var2);
RouterFunctions.Builder add(RouterFunction<ServerResponse> var1);
RouterFunctions.Builder resources(String var1, Resource var2);
RouterFunctions.Builder resources(Function<ServerRequest, Mono<Resource>> var1);
RouterFunctions.Builder nest(RequestPredicate var1, Supplier<RouterFunction<ServerResponse>> var2);
RouterFunctions.Builder nest(RequestPredicate var1, Consumer<RouterFunctions.Builder> var2);
RouterFunctions.Builder path(String var1, Supplier<RouterFunction<ServerResponse>> var2);
RouterFunctions.Builder path(String var1, Consumer<RouterFunctions.Builder> var2);
RouterFunctions.Builder filter(HandlerFilterFunction<ServerResponse, ServerResponse> var1);
RouterFunctions.Builder before(Function<ServerRequest, ServerRequest> var1);
RouterFunctions.Builder after(BiFunction<ServerRequest, ServerResponse, ServerResponse> var1);
RouterFunctions.Builder onError(Predicate<? super Throwable> var1, BiFunction<? super Throwable, ServerRequest, Mono<ServerResponse>> var2);
<T extends Throwable> RouterFunctions.Builder onError(Class<T> var1, BiFunction<? super T, ServerRequest, Mono<ServerResponse>> var2);
RouterFunction<ServerResponse> build();
}
}
**********************
RequestPredicate
RequestPredicate
@FunctionalInterface
public interface RequestPredicate {
boolean test(ServerRequest var1);
default RequestPredicate and(RequestPredicate other) {
return new AndRequestPredicate(this, other);
}
default RequestPredicate negate() {
return new NegateRequestPredicate(this);
}
default RequestPredicate or(RequestPredicate other) {
return new OrRequestPredicate(this, other);
}
default Optional<ServerRequest> nest(ServerRequest request) {
return this.test(request) ? Optional.of(request) : Optional.empty();
}
default void accept(Visitor visitor) {
visitor.unknown(this);
}
}
RequestPredicates：构造RequestPredicate
public abstract class RequestPredicates {
private static final Log logger = LogFactory.getLog(RequestPredicates.class);
public RequestPredicates() {
}
public static RequestPredicate all() {
return (request) -> {
return true;
};
}
public static RequestPredicate method(HttpMethod httpMethod) {
return new RequestPredicates.HttpMethodPredicate(httpMethod);
}
public static RequestPredicate methods(HttpMethod... httpMethods) {
return new RequestPredicates.HttpMethodPredicate(httpMethods);
}
public static RequestPredicate path(String pattern) {
Assert.notNull(pattern, "'pattern' must not be null");
if (!pattern.isEmpty() && !pattern.startsWith("/")) {
pattern = "/" + pattern;
}
return (RequestPredicate)pathPredicates(PathPatternParser.defaultInstance).apply(pattern);
}
public static Function<String, RequestPredicate> pathPredicates(PathPatternParser patternParser) {
Assert.notNull(patternParser, "PathPatternParser must not be null");
return (pattern) -> {
return new RequestPredicates.PathPatternPredicate(patternParser.parse(pattern));
};
}
public static RequestPredicate headers(Predicate<Headers> headersPredicate) {
return new RequestPredicates.HeadersPredicate(headersPredicate);
}
public static RequestPredicate contentType(MediaType... mediaTypes) {
Assert.notEmpty(mediaTypes, "'mediaTypes' must not be empty");
return new RequestPredicates.ContentTypePredicate(mediaTypes);
}
public static RequestPredicate accept(MediaType... mediaTypes) {
Assert.notEmpty(mediaTypes, "'mediaTypes' must not be empty");
return new RequestPredicates.AcceptPredicate(mediaTypes);
}
public static RequestPredicate GET(String pattern) {
return method(HttpMethod.GET).and(path(pattern));
}
public static RequestPredicate HEAD(String pattern) {
return method(HttpMethod.HEAD).and(path(pattern));
}
public static RequestPredicate POST(String pattern) {
return method(HttpMethod.POST).and(path(pattern));
}
public static RequestPredicate PUT(String pattern) {
return method(HttpMethod.PUT).and(path(pattern));
}
public static RequestPredicate PATCH(String pattern) {
return method(HttpMethod.PATCH).and(path(pattern));
}
public static RequestPredicate DELETE(String pattern) {
return method(HttpMethod.DELETE).and(path(pattern));
}
public static RequestPredicate OPTIONS(String pattern) {
return method(HttpMethod.OPTIONS).and(path(pattern));
}
public static RequestPredicate pathExtension(String extension) {
Assert.notNull(extension, "'extension' must not be null");
return new RequestPredicates.PathExtensionPredicate(extension);
}
public static RequestPredicate pathExtension(Predicate<String> extensionPredicate) {
return new RequestPredicates.PathExtensionPredicate(extensionPredicate);
}
public static RequestPredicate queryParam(String name, String value) {
return new RequestPredicates.QueryParamPredicate(name, value);
}
public static RequestPredicate queryParam(String name, Predicate<String> predicate) {
return new RequestPredicates.QueryParamPredicate(name, predicate);
}
private static void traceMatch(String prefix, Object desired, @Nullable Object actual, boolean match) {
if (logger.isTraceEnabled()) {
logger.trace(String.format("%s \"%s\" %s against value \"%s\"", prefix, desired, match ? "matches" : "does not match", actual));
}
}
private static void restoreAttributes(ServerRequest request, Map<String, Object> attributes) {
request.attributes().clear();
request.attributes().putAll(attributes);
}
private static Map<String, String> mergePathVariables(Map<String, String> oldVariables, Map<String, String> newVariables) {
if (!newVariables.isEmpty()) {
Map<String, String> mergedVariables = new LinkedHashMap(oldVariables);
mergedVariables.putAll(newVariables);
return mergedVariables;
} else {
return oldVariables;
}
}
private static PathPattern mergePatterns(@Nullable PathPattern oldPattern, PathPattern newPattern) {
return oldPattern != null ? oldPattern.combine(newPattern) : newPattern;
}
private static class SubPathServerRequestWrapper implements ServerRequest {
private final ServerRequest request;
private final PathContainer pathContainer;
private final Map<String, Object> attributes;
public SubPathServerRequestWrapper(ServerRequest request, PathRemainingMatchInfo info, PathPattern pattern) {
this.request = request;
this.pathContainer = new RequestPredicates.SubPathServerRequestWrapper.SubPathContainer(info.getPathRemaining());
this.attributes = mergeAttributes(request, info.getUriVariables(), pattern);
}
private static Map<String, Object> mergeAttributes(ServerRequest request, Map<String, String> pathVariables, PathPattern pattern) {
Map<String, Object> result = new ConcurrentHashMap(request.attributes());
result.put(RouterFunctions.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestPredicates.mergePathVariables(request.pathVariables(), pathVariables));
pattern = RequestPredicates.mergePatterns((PathPattern)request.attributes().get(RouterFunctions.MATCHING_PATTERN_ATTRIBUTE), pattern);
result.put(RouterFunctions.MATCHING_PATTERN_ATTRIBUTE, pattern);
return result;
}
public HttpMethod method() {
return this.request.method();
}
public String methodName() {
return this.request.methodName();
}
public URI uri() {
return this.request.uri();
}
public UriBuilder uriBuilder() {
return this.request.uriBuilder();
}
public String path() {
return this.pathContainer.value();
}
public PathContainer pathContainer() {
return this.pathContainer;
}
public Headers headers() {
return this.request.headers();
}
public MultiValueMap<String, HttpCookie> cookies() {
return this.request.cookies();
}
public Optional<InetSocketAddress> remoteAddress() {
return this.request.remoteAddress();
}
public Optional<InetSocketAddress> localAddress() {
return this.request.localAddress();
}
public List<HttpMessageReader<?>> messageReaders() {
return this.request.messageReaders();
}
public <T> T body(BodyExtractor<T, ? super ServerHttpRequest> extractor) {
return this.request.body(extractor);
}
public <T> T body(BodyExtractor<T, ? super ServerHttpRequest> extractor, Map<String, Object> hints) {
return this.request.body(extractor, hints);
}
public <T> Mono<T> bodyToMono(Class<? extends T> elementClass) {
return this.request.bodyToMono(elementClass);
}
public <T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference) {
return this.request.bodyToMono(typeReference);
}
public <T> Flux<T> bodyToFlux(Class<? extends T> elementClass) {
return this.request.bodyToFlux(elementClass);
}
public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference) {
return this.request.bodyToFlux(typeReference);
}
public Map<String, Object> attributes() {
return this.attributes;
}
public Optional<String> queryParam(String name) {
return this.request.queryParam(name);
}
public MultiValueMap<String, String> queryParams() {
return this.request.queryParams();
}
public Map<String, String> pathVariables() {
return (Map)this.attributes.getOrDefault(RouterFunctions.URI_TEMPLATE_VARIABLES_ATTRIBUTE, Collections.emptyMap());
}
public Mono<WebSession> session() {
return this.request.session();
}
public Mono<? extends Principal> principal() {
return this.request.principal();
}
public Mono<MultiValueMap<String, String>> formData() {
return this.request.formData();
}
public Mono<MultiValueMap<String, Part>> multipartData() {
return this.request.multipartData();
}
public ServerWebExchange exchange() {
return this.request.exchange();
}
public String toString() {
return this.method() + " " + this.path();
}
private static class SubPathContainer implements PathContainer {
private static final Separator SEPARATOR = () -> {
return "/";
};
private final String value;
private final List<Element> elements;
public SubPathContainer(PathContainer original) {
this.value = prefixWithSlash(original.value());
this.elements = prependWithSeparator(original.elements());
}
private static String prefixWithSlash(String path) {
if (!path.startsWith("/")) {
path = "/" + path;
}
return path;
}
private static List<Element> prependWithSeparator(List<Element> elements) {
List<Element> result = new ArrayList(elements);
if (result.isEmpty() || !(result.get(0) instanceof Separator)) {
result.add(0, SEPARATOR);
}
return Collections.unmodifiableList(result);
}
public String value() {
return this.value;
}
public List<Element> elements() {
return this.elements;
}
}
}
static class OrRequestPredicate implements RequestPredicate {
private final RequestPredicate left;
private final RequestPredicate right;
public OrRequestPredicate(RequestPredicate left, RequestPredicate right) {
Assert.notNull(left, "Left RequestPredicate must not be null");
Assert.notNull(right, "Right RequestPredicate must not be null");
this.left = left;
this.right = right;
}
public boolean test(ServerRequest request) {
Map<String, Object> oldAttributes = new HashMap(request.attributes());
if (this.left.test(request)) {
return true;
} else {
RequestPredicates.restoreAttributes(request, oldAttributes);
if (this.right.test(request)) {
return true;
} else {
RequestPredicates.restoreAttributes(request, oldAttributes);
return false;
}
}
}
public Optional<ServerRequest> nest(ServerRequest request) {
Optional<ServerRequest> leftResult = this.left.nest(request);
return leftResult.isPresent() ? leftResult : this.right.nest(request);
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.startOr();
this.left.accept(visitor);
visitor.or();
this.right.accept(visitor);
visitor.endOr();
}
public String toString() {
return String.format("(%s || %s)", this.left, this.right);
}
}
static class NegateRequestPredicate implements RequestPredicate {
private final RequestPredicate delegate;
public NegateRequestPredicate(RequestPredicate delegate) {
Assert.notNull(delegate, "Delegate must not be null");
this.delegate = delegate;
}
public boolean test(ServerRequest request) {
Map<String, Object> oldAttributes = new HashMap(request.attributes());
boolean result = !this.delegate.test(request);
if (!result) {
RequestPredicates.restoreAttributes(request, oldAttributes);
}
return result;
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.startNegate();
this.delegate.accept(visitor);
visitor.endNegate();
}
public String toString() {
return "!" + this.delegate.toString();
}
}
static class AndRequestPredicate implements RequestPredicate {
private final RequestPredicate left;
private final RequestPredicate right;
public AndRequestPredicate(RequestPredicate left, RequestPredicate right) {
Assert.notNull(left, "Left RequestPredicate must not be null");
Assert.notNull(right, "Right RequestPredicate must not be null");
this.left = left;
this.right = right;
}
public boolean test(ServerRequest request) {
Map<String, Object> oldAttributes = new HashMap(request.attributes());
if (this.left.test(request) && this.right.test(request)) {
return true;
} else {
RequestPredicates.restoreAttributes(request, oldAttributes);
return false;
}
}
public Optional<ServerRequest> nest(ServerRequest request) {
Optional var10000 = this.left.nest(request);
RequestPredicate var10001 = this.right;
var10001.getClass();
return var10000.flatMap(var10001::nest);
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.startAnd();
this.left.accept(visitor);
visitor.and();
this.right.accept(visitor);
visitor.endAnd();
}
public String toString() {
return String.format("(%s && %s)", this.left, this.right);
}
}
private static class QueryParamPredicate implements RequestPredicate {
private final String name;
private final Predicate<String> valuePredicate;
@Nullable
private final String value;
public QueryParamPredicate(String name, Predicate<String> valuePredicate) {
Assert.notNull(name, "Name must not be null");
Assert.notNull(valuePredicate, "Predicate must not be null");
this.name = name;
this.valuePredicate = valuePredicate;
this.value = null;
}
public QueryParamPredicate(String name, String value) {
Assert.notNull(name, "Name must not be null");
Assert.notNull(value, "Value must not be null");
this.name = name;
this.valuePredicate = value::equals;
this.value = value;
}
public boolean test(ServerRequest request) {
Optional<String> s = request.queryParam(this.name);
return s.filter(this.valuePredicate).isPresent();
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.queryParam(this.name, this.value != null ? this.value : this.valuePredicate.toString());
}
public String toString() {
return String.format("?%s %s", this.name, this.value != null ? this.value : this.valuePredicate);
}
}
private static class PathExtensionPredicate implements RequestPredicate {
private final Predicate<String> extensionPredicate;
@Nullable
private final String extension;
public PathExtensionPredicate(Predicate<String> extensionPredicate) {
Assert.notNull(extensionPredicate, "Predicate must not be null");
this.extensionPredicate = extensionPredicate;
this.extension = null;
}
public PathExtensionPredicate(String extension) {
Assert.notNull(extension, "Extension must not be null");
this.extensionPredicate = (s) -> {
boolean match = extension.equalsIgnoreCase(s);
RequestPredicates.traceMatch("Extension", extension, s, match);
return match;
};
this.extension = extension;
}
public boolean test(ServerRequest request) {
String pathExtension = UriUtils.extractFileExtension(request.path());
return this.extensionPredicate.test(pathExtension);
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.pathExtension(this.extension != null ? this.extension : this.extensionPredicate.toString());
}
public String toString() {
return String.format("*.%s", this.extension != null ? this.extension : this.extensionPredicate);
}
}
private static class AcceptPredicate extends RequestPredicates.HeadersPredicate {
private final Set<MediaType> mediaTypes;
public AcceptPredicate(MediaType... mediaTypes) {
this((Set)(new HashSet(Arrays.asList(mediaTypes))));
}
private AcceptPredicate(Set<MediaType> mediaTypes) {
super((headers) -> {
List<MediaType> acceptedMediaTypes = acceptedMediaTypes(headers);
boolean match = acceptedMediaTypes.stream().anyMatch((acceptedMediaType) -> {
Stream var10000 = mediaTypes.stream();
acceptedMediaType.getClass();
return var10000.anyMatch(acceptedMediaType::isCompatibleWith);
});
RequestPredicates.traceMatch("Accept", mediaTypes, acceptedMediaTypes, match);
return match;
});
this.mediaTypes = mediaTypes;
}
@NonNull
private static List<MediaType> acceptedMediaTypes(Headers headers) {
List<MediaType> acceptedMediaTypes = headers.accept();
if (acceptedMediaTypes.isEmpty()) {
acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
} else {
MediaType.sortBySpecificityAndQuality(acceptedMediaTypes);
}
return acceptedMediaTypes;
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.header("Accept", this.mediaTypes.size() == 1 ? ((MediaType)this.mediaTypes.iterator().next()).toString() : this.mediaTypes.toString());
}
public String toString() {
return String.format("Accept: %s", this.mediaTypes.size() == 1 ? ((MediaType)this.mediaTypes.iterator().next()).toString() : this.mediaTypes.toString());
}
}
private static class ContentTypePredicate extends RequestPredicates.HeadersPredicate {
private final Set<MediaType> mediaTypes;
public ContentTypePredicate(MediaType... mediaTypes) {
this((Set)(new HashSet(Arrays.asList(mediaTypes))));
}
private ContentTypePredicate(Set<MediaType> mediaTypes) {
super((headers) -> {
MediaType contentType = (MediaType)headers.contentType().orElse(MediaType.APPLICATION_OCTET_STREAM);
boolean match = mediaTypes.stream().anyMatch((mediaType) -> {
return mediaType.includes(contentType);
});
RequestPredicates.traceMatch("Content-Type", mediaTypes, contentType, match);
return match;
});
this.mediaTypes = mediaTypes;
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.header("Content-Type", this.mediaTypes.size() == 1 ? ((MediaType)this.mediaTypes.iterator().next()).toString() : this.mediaTypes.toString());
}
public String toString() {
return String.format("Content-Type: %s", this.mediaTypes.size() == 1 ? ((MediaType)this.mediaTypes.iterator().next()).toString() : this.mediaTypes.toString());
}
}
private static class HeadersPredicate implements RequestPredicate {
private final Predicate<Headers> headersPredicate;
public HeadersPredicate(Predicate<Headers> headersPredicate) {
Assert.notNull(headersPredicate, "Predicate must not be null");
this.headersPredicate = headersPredicate;
}
public boolean test(ServerRequest request) {
return CorsUtils.isPreFlightRequest(request.exchange().getRequest()) ? true : this.headersPredicate.test(request.headers());
}
public String toString() {
return this.headersPredicate.toString();
}
}
private static class PathPatternPredicate implements RequestPredicate {
private final PathPattern pattern;
public PathPatternPredicate(PathPattern pattern) {
Assert.notNull(pattern, "'pattern' must not be null");
this.pattern = pattern;
}
public boolean test(ServerRequest request) {
PathContainer pathContainer = request.pathContainer();
PathMatchInfo info = this.pattern.matchAndExtract(pathContainer);
RequestPredicates.traceMatch("Pattern", this.pattern.getPatternString(), request.path(), info != null);
if (info != null) {
mergeAttributes(request, info.getUriVariables(), this.pattern);
return true;
} else {
return false;
}
}
private static void mergeAttributes(ServerRequest request, Map<String, String> variables, PathPattern pattern) {
Map<String, String> pathVariables = RequestPredicates.mergePathVariables(request.pathVariables(), variables);
request.attributes().put(RouterFunctions.URI_TEMPLATE_VARIABLES_ATTRIBUTE, Collections.unmodifiableMap(pathVariables));
pattern = RequestPredicates.mergePatterns((PathPattern)request.attributes().get(RouterFunctions.MATCHING_PATTERN_ATTRIBUTE), pattern);
request.attributes().put(RouterFunctions.MATCHING_PATTERN_ATTRIBUTE, pattern);
}
public Optional<ServerRequest> nest(ServerRequest request) {
return Optional.ofNullable(this.pattern.matchStartOfPath(request.pathContainer())).map((info) -> {
return new RequestPredicates.SubPathServerRequestWrapper(request, info, this.pattern);
});
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.path(this.pattern.getPatternString());
}
public String toString() {
return this.pattern.getPatternString();
}
}
private static class HttpMethodPredicate implements RequestPredicate {
private final Set<HttpMethod> httpMethods;
public HttpMethodPredicate(HttpMethod httpMethod) {
Assert.notNull(httpMethod, "HttpMethod must not be null");
this.httpMethods = EnumSet.of(httpMethod);
}
public HttpMethodPredicate(HttpMethod... httpMethods) {
Assert.notEmpty(httpMethods, "HttpMethods must not be empty");
this.httpMethods = EnumSet.copyOf(Arrays.asList(httpMethods));
}
public boolean test(ServerRequest request) {
HttpMethod method = method(request);
boolean match = this.httpMethods.contains(method);
RequestPredicates.traceMatch("Method", this.httpMethods, method, match);
return match;
}
@Nullable
private static HttpMethod method(ServerRequest request) {
if (CorsUtils.isPreFlightRequest(request.exchange().getRequest())) {
String accessControlRequestMethod = request.headers().firstHeader("Access-Control-Request-Method");
return HttpMethod.resolve(accessControlRequestMethod);
} else {
return request.method();
}
}
public void accept(RequestPredicates.Visitor visitor) {
visitor.method(Collections.unmodifiableSet(this.httpMethods));
}
public String toString() {
return this.httpMethods.size() == 1 ? ((HttpMethod)this.httpMethods.iterator().next()).toString() : this.httpMethods.toString();
}
}
public interface Visitor {
void method(Set<HttpMethod> var1);
void path(String var1);
void pathExtension(String var1);
void header(String var1, String var2);
void queryParam(String var1, String var2);
void startAnd();
void and();
void endAnd();
void startOr();
void or();
void endOr();
void startNegate();
void endNegate();
void unknown(RequestPredicate var1);
}
}
**********************
HandlerFunction
HandlerFunction
@FunctionalInterface
public interface HandlerFunction<T extends ServerResponse> {
Mono<T> handle(ServerRequest var1);
}
ServerRequest
public interface ServerRequest {
@Nullable
default HttpMethod method() {
return HttpMethod.resolve(this.methodName());
}
String methodName();
URI uri();
UriBuilder uriBuilder();
default String path() {
return this.uri().getRawPath();
}
default PathContainer pathContainer() {
return PathContainer.parsePath(this.path());
}
ServerRequest.Headers headers();
MultiValueMap<String, HttpCookie> cookies();
Optional<InetSocketAddress> remoteAddress();
Optional<InetSocketAddress> localAddress();
List<HttpMessageReader<?>> messageReaders();
<T> T body(BodyExtractor<T, ? super ServerHttpRequest> var1);
<T> T body(BodyExtractor<T, ? super ServerHttpRequest> var1, Map<String, Object> var2);
<T> Mono<T> bodyToMono(Class<? extends T> var1);
<T> Mono<T> bodyToMono(ParameterizedTypeReference<T> var1);
<T> Flux<T> bodyToFlux(Class<? extends T> var1);
<T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> var1);
default Optional<Object> attribute(String name) {
return Optional.ofNullable(this.attributes().get(name));
}
Map<String, Object> attributes();
default Optional<String> queryParam(String name) {
List<String> queryParamValues = (List)this.queryParams().get(name);
if (CollectionUtils.isEmpty(queryParamValues)) {
return Optional.empty();
} else {
String value = (String)queryParamValues.get(0);
if (value == null) {
value = "";
}
return Optional.of(value);
}
}
MultiValueMap<String, String> queryParams();
default String pathVariable(String name) {
Map<String, String> pathVariables = this.pathVariables();
if (pathVariables.containsKey(name)) {
return (String)this.pathVariables().get(name);
} else {
throw new IllegalArgumentException("No path variable with name \"" + name + "\" available");
}
}
Map<String, String> pathVariables();
Mono<WebSession> session();
Mono<? extends Principal> principal();
Mono<MultiValueMap<String, String>> formData();
Mono<MultiValueMap<String, Part>> multipartData();
ServerWebExchange exchange();
default Mono<ServerResponse> checkNotModified(Instant lastModified) {
Assert.notNull(lastModified, "LastModified must not be null");
return DefaultServerRequest.checkNotModified(this.exchange(), lastModified, (String)null);
}
default Mono<ServerResponse> checkNotModified(String etag) {
Assert.notNull(etag, "Etag must not be null");
return DefaultServerRequest.checkNotModified(this.exchange(), (Instant)null, etag);
}
default Mono<ServerResponse> checkNotModified(Instant lastModified, String etag) {
Assert.notNull(lastModified, "LastModified must not be null");
Assert.notNull(etag, "Etag must not be null");
return DefaultServerRequest.checkNotModified(this.exchange(), lastModified, etag);
}
static ServerRequest create(ServerWebExchange exchange, List<HttpMessageReader<?>> messageReaders) {
return new DefaultServerRequest(exchange, messageReaders);
}
static ServerRequest.Builder from(ServerRequest other) {
return new DefaultServerRequestBuilder(other);
}
public interface Builder {
ServerRequest.Builder method(HttpMethod var1);
ServerRequest.Builder uri(URI var1);
ServerRequest.Builder header(String var1, String... var2);
ServerRequest.Builder headers(Consumer<HttpHeaders> var1);
ServerRequest.Builder cookie(String var1, String... var2);
ServerRequest.Builder cookies(Consumer<MultiValueMap<String, HttpCookie>> var1);
ServerRequest.Builder body(Flux<DataBuffer> var1);
ServerRequest.Builder body(String var1);
ServerRequest.Builder attribute(String var1, Object var2);
ServerRequest.Builder attributes(Consumer<Map<String, Object>> var1);
ServerRequest build();
}
public interface Headers {
List<MediaType> accept();
List<Charset> acceptCharset();
List<LanguageRange> acceptLanguage();
OptionalLong contentLength();
Optional<MediaType> contentType();
@Nullable
InetSocketAddress host();
List<HttpRange> range();
List<String> header(String var1);
@Nullable
default String firstHeader(String headerName) {
List<String> list = this.header(headerName);
return list.isEmpty() ? null : (String)list.get(0);
}
HttpHeaders asHttpHeaders();
}
}
ServerResponse
public interface ServerResponse {
HttpStatus statusCode();
int rawStatusCode();
HttpHeaders headers();
MultiValueMap<String, ResponseCookie> cookies();
Mono<Void> writeTo(ServerWebExchange var1, ServerResponse.Context var2);
static ServerResponse.BodyBuilder from(ServerResponse other) {
return new DefaultServerResponseBuilder(other);
}
static ServerResponse.BodyBuilder status(HttpStatus status) {
return new DefaultServerResponseBuilder(status);
}
static ServerResponse.BodyBuilder status(int status) {
return new DefaultServerResponseBuilder(status);
}
static ServerResponse.BodyBuilder ok() {
return status(HttpStatus.OK);
}
static ServerResponse.BodyBuilder created(URI location) {
ServerResponse.BodyBuilder builder = status(HttpStatus.CREATED);
return (ServerResponse.BodyBuilder)builder.location(location);
}
static ServerResponse.BodyBuilder accepted() {
return status(HttpStatus.ACCEPTED);
}
static ServerResponse.HeadersBuilder<?> noContent() {
return status(HttpStatus.NO_CONTENT);
}
static ServerResponse.BodyBuilder seeOther(URI location) {
ServerResponse.BodyBuilder builder = status(HttpStatus.SEE_OTHER);
return (ServerResponse.BodyBuilder)builder.location(location);
}
static ServerResponse.BodyBuilder temporaryRedirect(URI location) {
ServerResponse.BodyBuilder builder = status(HttpStatus.TEMPORARY_REDIRECT);
return (ServerResponse.BodyBuilder)builder.location(location);
}
static ServerResponse.BodyBuilder permanentRedirect(URI location) {
ServerResponse.BodyBuilder builder = status(HttpStatus.PERMANENT_REDIRECT);
return (ServerResponse.BodyBuilder)builder.location(location);
}
static ServerResponse.BodyBuilder badRequest() {
return status(HttpStatus.BAD_REQUEST);
}
static ServerResponse.HeadersBuilder<?> notFound() {
return status(HttpStatus.NOT_FOUND);
}
static ServerResponse.BodyBuilder unprocessableEntity() {
return status(HttpStatus.UNPROCESSABLE_ENTITY);
}
public interface Context {
List<HttpMessageWriter<?>> messageWriters();
List<ViewResolver> viewResolvers();
}
public interface BodyBuilder extends ServerResponse.HeadersBuilder<ServerResponse.BodyBuilder> {
ServerResponse.BodyBuilder contentLength(long var1);
ServerResponse.BodyBuilder contentType(MediaType var1);
ServerResponse.BodyBuilder hint(String var1, Object var2);
ServerResponse.BodyBuilder hints(Consumer<Map<String, Object>> var1);
Mono<ServerResponse> bodyValue(Object var1);
<T, P extends Publisher<T>> Mono<ServerResponse> body(P var1, Class<T> var2);
<T, P extends Publisher<T>> Mono<ServerResponse> body(P var1, ParameterizedTypeReference<T> var2);
Mono<ServerResponse> body(Object var1, Class<?> var2);
Mono<ServerResponse> body(Object var1, ParameterizedTypeReference<?> var2);
Mono<ServerResponse> body(BodyInserter<?, ? super ServerHttpResponse> var1);
/** @deprecated */
@Deprecated
Mono<ServerResponse> syncBody(Object var1);
Mono<ServerResponse> render(String var1, Object... var2);
Mono<ServerResponse> render(String var1, Map<String, ?> var2);
}
public interface HeadersBuilder<B extends ServerResponse.HeadersBuilder<B>> {
B header(String var1, String... var2);
B headers(Consumer<HttpHeaders> var1);
B cookie(ResponseCookie var1);
B cookies(Consumer<MultiValueMap<String, ResponseCookie>> var1);
B allow(HttpMethod... var1);
B allow(Set<HttpMethod> var1);
B eTag(String var1);
B lastModified(ZonedDateTime var1);
B lastModified(Instant var1);
B location(URI var1);
B cacheControl(CacheControl var1);
B varyBy(String... var1);
Mono<ServerResponse> build();
Mono<ServerResponse> build(Publisher<Void> var1);
Mono<ServerResponse> build(BiFunction<ServerWebExchange, ServerResponse.Context, Mono<Void>> var1);
}
}
466
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
