Skip to content

Commit 91e96d8

Browse files
committed
Improve RouterFunction builder
This commit improves the RouterFunctions.Builder based on conversations had during the weekly team meeting. Issue: SPR-16953
1 parent 22ccdb2 commit 91e96d8

File tree

3 files changed

+343
-175
lines changed

3 files changed

+343
-175
lines changed

spring-webflux/src/main/java/org/springframework/web/reactive/function/server/RouterFunctionBuilder.java

+71-50
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@
2626

2727
import reactor.core.publisher.Mono;
2828

29-
import org.springframework.http.HttpMethod;
29+
import org.springframework.core.io.Resource;
3030
import org.springframework.util.Assert;
3131

3232
/**
@@ -40,89 +40,111 @@ class RouterFunctionBuilder implements RouterFunctions.Builder {
4040

4141
private List<HandlerFilterFunction<ServerResponse, ServerResponse>> filterFunctions = new ArrayList<>();
4242

43-
4443
@Override
45-
public RouterFunctions.Builder route(RequestPredicate predicate,
44+
public RouterFunctions.Builder add(RouterFunction<ServerResponse> routerFunction) {
45+
Assert.notNull(routerFunction, "RouterFunction must not be null");
46+
this.routerFunctions.add(routerFunction);
47+
return this;
48+
}
49+
50+
private RouterFunctions.Builder add(RequestPredicate predicate,
4651
HandlerFunction<ServerResponse> handlerFunction) {
4752
this.routerFunctions.add(RouterFunctions.route(predicate, handlerFunction));
4853
return this;
4954
}
5055

5156
@Override
52-
public RouterFunctions.Builder routeGet(HandlerFunction<ServerResponse> handlerFunction) {
53-
return route(RequestPredicates.method(HttpMethod.GET), handlerFunction);
57+
public RouterFunctions.Builder GET(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
58+
return add(RequestPredicates.GET(pattern), handlerFunction);
59+
}
60+
61+
@Override
62+
public RouterFunctions.Builder GET(String pattern, RequestPredicate predicate,
63+
HandlerFunction<ServerResponse> handlerFunction) {
64+
return add(RequestPredicates.GET(pattern).and(predicate), handlerFunction);
65+
}
66+
67+
@Override
68+
public RouterFunctions.Builder HEAD(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
69+
return add(RequestPredicates.HEAD(pattern), handlerFunction);
5470
}
5571

5672
@Override
57-
public RouterFunctions.Builder routeGet(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
58-
return route(RequestPredicates.GET(pattern), handlerFunction);
73+
public RouterFunctions.Builder HEAD(String pattern, RequestPredicate predicate,
74+
HandlerFunction<ServerResponse> handlerFunction) {
75+
return add(RequestPredicates.HEAD(pattern).and(predicate), handlerFunction);
5976
}
6077

6178
@Override
62-
public RouterFunctions.Builder routeHead(HandlerFunction<ServerResponse> handlerFunction) {
63-
return route(RequestPredicates.method(HttpMethod.HEAD), handlerFunction);
79+
public RouterFunctions.Builder POST(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
80+
return add(RequestPredicates.POST(pattern), handlerFunction);
6481
}
6582

6683
@Override
67-
public RouterFunctions.Builder routeHead(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
68-
return route(RequestPredicates.HEAD(pattern), handlerFunction);
84+
public RouterFunctions.Builder POST(String pattern, RequestPredicate predicate,
85+
HandlerFunction<ServerResponse> handlerFunction) {
86+
return add(RequestPredicates.POST(pattern).and(predicate), handlerFunction);
6987
}
7088

7189
@Override
72-
public RouterFunctions.Builder routePost(HandlerFunction<ServerResponse> handlerFunction) {
73-
return route(RequestPredicates.method(HttpMethod.POST), handlerFunction);
90+
public RouterFunctions.Builder PUT(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
91+
return add(RequestPredicates.PUT(pattern), handlerFunction);
7492
}
7593

7694
@Override
77-
public RouterFunctions.Builder routePost(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
78-
return route(RequestPredicates.POST(pattern), handlerFunction);
95+
public RouterFunctions.Builder PUT(String pattern, RequestPredicate predicate,
96+
HandlerFunction<ServerResponse> handlerFunction) {
97+
return add(RequestPredicates.PUT(pattern).and(predicate), handlerFunction);
7998
}
8099

81100
@Override
82-
public RouterFunctions.Builder routePut(HandlerFunction<ServerResponse> handlerFunction) {
83-
return route(RequestPredicates.method(HttpMethod.PUT), handlerFunction);
101+
public RouterFunctions.Builder PATCH(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
102+
return add(RequestPredicates.PATCH(pattern), handlerFunction);
84103
}
85104

86105
@Override
87-
public RouterFunctions.Builder routePut(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
88-
return route(RequestPredicates.PUT(pattern), handlerFunction);
106+
public RouterFunctions.Builder PATCH(String pattern, RequestPredicate predicate,
107+
HandlerFunction<ServerResponse> handlerFunction) {
108+
return add(RequestPredicates.PATCH(pattern).and(predicate), handlerFunction);
89109
}
90110

91111
@Override
92-
public RouterFunctions.Builder routePatch(HandlerFunction<ServerResponse> handlerFunction) {
93-
return route(RequestPredicates.method(HttpMethod.PATCH), handlerFunction);
112+
public RouterFunctions.Builder DELETE(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
113+
return add(RequestPredicates.DELETE(pattern), handlerFunction);
94114
}
95115

96116
@Override
97-
public RouterFunctions.Builder routePatch(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
98-
return route(RequestPredicates.PATCH(pattern), handlerFunction);
117+
public RouterFunctions.Builder DELETE(String pattern, RequestPredicate predicate,
118+
HandlerFunction<ServerResponse> handlerFunction) {
119+
return add(RequestPredicates.DELETE(pattern).and(predicate), handlerFunction);
99120
}
100121

101122
@Override
102-
public RouterFunctions.Builder routeDelete(HandlerFunction<ServerResponse> handlerFunction) {
103-
return route(RequestPredicates.method(HttpMethod.DELETE), handlerFunction);
123+
public RouterFunctions.Builder OPTIONS(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
124+
return add(RequestPredicates.OPTIONS(pattern), handlerFunction);
104125
}
105126

106127
@Override
107-
public RouterFunctions.Builder routeDelete(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
108-
return route(RequestPredicates.DELETE(pattern), handlerFunction);
128+
public RouterFunctions.Builder OPTIONS(String pattern, RequestPredicate predicate,
129+
HandlerFunction<ServerResponse> handlerFunction) {
130+
return add(RequestPredicates.OPTIONS(pattern).and(predicate), handlerFunction);
109131
}
110132

111133
@Override
112-
public RouterFunctions.Builder routeOptions(HandlerFunction<ServerResponse> handlerFunction) {
113-
return route(RequestPredicates.method(HttpMethod.OPTIONS), handlerFunction);
134+
public RouterFunctions.Builder resources(String pattern, Resource location) {
135+
return add(RouterFunctions.resources(pattern, location));
114136
}
115137

116138
@Override
117-
public RouterFunctions.Builder routeOptions(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
118-
return route(RequestPredicates.OPTIONS(pattern), handlerFunction);
139+
public RouterFunctions.Builder resources(Function<ServerRequest, Mono<Resource>> lookupFunction) {
140+
return add(RouterFunctions.resources(lookupFunction));
119141
}
120142

121143
@Override
122144
public RouterFunctions.Builder nest(RequestPredicate predicate,
123145
Consumer<RouterFunctions.Builder> builderConsumer) {
124146

125-
Assert.notNull(builderConsumer, "'builderConsumer' must not be null");
147+
Assert.notNull(builderConsumer, "Consumer must not be null");
126148

127149
RouterFunctionBuilder nestedBuilder = new RouterFunctionBuilder();
128150
builderConsumer.accept(nestedBuilder);
@@ -136,7 +158,7 @@ public RouterFunctions.Builder nest(RequestPredicate predicate,
136158
public RouterFunctions.Builder nest(RequestPredicate predicate,
137159
Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) {
138160

139-
Assert.notNull(routerFunctionSupplier, "'routerFunctionSupplier' must not be null");
161+
Assert.notNull(routerFunctionSupplier, "RouterFunction Supplier must not be null");
140162

141163
RouterFunction<ServerResponse> nestedRoute = routerFunctionSupplier.get();
142164

@@ -145,57 +167,56 @@ public RouterFunctions.Builder nest(RequestPredicate predicate,
145167
}
146168

147169
@Override
148-
public RouterFunctions.Builder nestPath(String pattern,
170+
public RouterFunctions.Builder path(String pattern,
149171
Consumer<RouterFunctions.Builder> builderConsumer) {
150172
return nest(RequestPredicates.path(pattern), builderConsumer);
151173
}
152174

153175
@Override
154-
public RouterFunctions.Builder nestPath(String pattern,
176+
public RouterFunctions.Builder path(String pattern,
155177
Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) {
156178
return nest(RequestPredicates.path(pattern), routerFunctionSupplier);
157179
}
158180

159181
@Override
160182
public RouterFunctions.Builder filter(HandlerFilterFunction<ServerResponse, ServerResponse> filterFunction) {
161-
Assert.notNull(filterFunction, "'filterFunction' must not be null");
183+
Assert.notNull(filterFunction, "HandlerFilterFunction must not be null");
162184

163185
this.filterFunctions.add(filterFunction);
164186
return this;
165187
}
166188

167189
@Override
168-
public RouterFunctions.Builder filterBefore(
169-
Function<ServerRequest, Mono<ServerRequest>> requestProcessor) {
170-
171-
Assert.notNull(requestProcessor, "Function must not be null");
172-
return filter((request, next) -> requestProcessor.apply(request).flatMap(next::handle));
190+
public RouterFunctions.Builder before(Function<ServerRequest, ServerRequest> requestProcessor) {
191+
Assert.notNull(requestProcessor, "RequestProcessor must not be null");
192+
return filter((request, next) -> next.handle(requestProcessor.apply(request)));
173193
}
174194

175195
@Override
176-
public RouterFunctions.Builder filterAfter(
177-
BiFunction<ServerRequest, ServerResponse, Mono<ServerResponse>> responseProcessor) {
196+
public RouterFunctions.Builder after(
197+
BiFunction<ServerRequest, ServerResponse, ServerResponse> responseProcessor) {
198+
Assert.notNull(responseProcessor, "ResponseProcessor must not be null");
178199
return filter((request, next) -> next.handle(request)
179-
.flatMap(serverResponse -> responseProcessor.apply(request, serverResponse)));
200+
.map(serverResponse -> responseProcessor.apply(request, serverResponse)));
180201
}
181202

182203
@Override
183-
public RouterFunctions.Builder filterException(Predicate<? super Throwable> predicate,
204+
public RouterFunctions.Builder onError(Predicate<? super Throwable> predicate,
184205
BiFunction<? super Throwable, ServerRequest, Mono<ServerResponse>> responseProvider) {
185206

186-
Assert.notNull(predicate, "'exceptionType' must not be null");
187-
Assert.notNull(responseProvider, "'fallback' must not be null");
207+
Assert.notNull(predicate, "Predicate must not be null");
208+
Assert.notNull(responseProvider, "ResponseProvider must not be null");
188209

189210
return filter((request, next) -> next.handle(request)
190211
.onErrorResume(predicate, t -> responseProvider.apply(t, request)));
191212
}
192213

193214
@Override
194-
public <T extends Throwable> RouterFunctions.Builder filterException(
215+
public <T extends Throwable> RouterFunctions.Builder onError(
195216
Class<T> exceptionType,
196217
BiFunction<? super T, ServerRequest, Mono<ServerResponse>> responseProvider) {
197-
Assert.notNull(exceptionType, "'exceptionType' must not be null");
198-
Assert.notNull(responseProvider, "'fallback' must not be null");
218+
Assert.notNull(exceptionType, "ExceptionType must not be null");
219+
Assert.notNull(responseProvider, "ResponseProvider must not be null");
199220

200221
return filter((request, next) -> next.handle(request)
201222
.onErrorResume(exceptionType, t -> responseProvider.apply(t, request)));

0 commit comments

Comments
 (0)