blob: 1d875db7adc82b03e0b747dcb52a3710cc49d18f (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// Copyright Verizon Media. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.restapi;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.yahoo.container.jdisc.HttpRequest;
import com.yahoo.container.jdisc.HttpResponse;
import com.yahoo.slime.Slime;
import com.yahoo.slime.SlimeUtils;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalLong;
/**
* Rest API routing and response serialization
*
* @author bjorncs
*/
public interface RestApi {
static Builder builder() { return new RestApiImpl.BuilderImpl(); }
static RouteBuilder route(String pathPattern) { return new RestApiImpl.RouteBuilderImpl(pathPattern); }
HttpResponse handleRequest(HttpRequest request);
ObjectMapper jacksonJsonMapper();
interface Builder {
Builder setObjectMapper(ObjectMapper mapper);
Builder setDefaultRoute(RouteBuilder route);
Builder addRoute(RouteBuilder route);
Builder addFilter(Filter filter);
<EXCEPTION extends RuntimeException> Builder addExceptionMapper(Class<EXCEPTION> type, ExceptionMapper<EXCEPTION> mapper);
<ENTITY> Builder addResponseMapper(Class<ENTITY> type, ResponseMapper<ENTITY> mapper);
Builder disableDefaultExceptionMappers();
Builder disableDefaultResponseMappers();
RestApi build();
}
interface RouteBuilder {
RouteBuilder name(String name);
RouteBuilder get(MethodHandler<?> handler);
RouteBuilder post(MethodHandler<?> handler);
RouteBuilder put(MethodHandler<?> handler);
RouteBuilder delete(MethodHandler<?> handler);
RouteBuilder patch(MethodHandler<?> handler);
RouteBuilder defaultHandler(MethodHandler<?> handler);
RouteBuilder addFilter(Filter filter);
}
@FunctionalInterface interface ExceptionMapper<EXCEPTION extends RuntimeException> { HttpResponse toResponse(EXCEPTION exception, RequestContext context); }
@FunctionalInterface interface MethodHandler<ENTITY> { ENTITY handleRequest(RequestContext context) throws RestApiException; }
@FunctionalInterface interface ResponseMapper<ENTITY> { HttpResponse toHttpResponse(ENTITY responseEntity, RequestContext context); }
@FunctionalInterface interface Filter { HttpResponse filterRequest(FilterContext context); }
/** Marker interface required for automatic serialization of Jackson response entities */
interface JacksonResponseEntity {}
/** Marker interface required for automatic serialization of Jackson request entities */
interface JacksonRequestEntity {}
interface RequestContext {
HttpRequest request();
PathParameters pathParameters();
QueryParameters queryParameters();
Headers headers();
Attributes attributes();
Optional<RequestContent> requestContent();
interface Parameters {
Optional<String> getString(String name);
String getStringOrThrow(String name);
default Optional<Boolean> getBoolean(String name) { return getString(name).map(Boolean::valueOf);}
default boolean getBooleanOrThrow(String name) { return Boolean.parseBoolean(getStringOrThrow(name)); }
default OptionalLong getLong(String name) {
return getString(name).map(Long::parseLong).map(OptionalLong::of).orElseGet(OptionalLong::empty);
}
default long getLongOrThrow(String name) { return Long.parseLong(getStringOrThrow(name)); }
default OptionalDouble getDouble(String name) {
return getString(name).map(Double::parseDouble).map(OptionalDouble::of).orElseGet(OptionalDouble::empty);
}
default double getDoubleOrThrow(String name) { return Double.parseDouble(getStringOrThrow(name)); }
}
interface PathParameters extends Parameters {}
interface QueryParameters extends Parameters {}
interface Headers extends Parameters {}
interface Attributes {
Optional<Object> get(String name);
void set(String name, Object value);
}
interface RequestContent {
String contentType();
InputStream inputStream();
ObjectMapper jacksonJsonMapper();
default byte[] consumeByteArray() throws IOException { return inputStream().readAllBytes(); }
default String consumeString() throws IOException { return new String(consumeByteArray(), StandardCharsets.UTF_8); }
default JsonNode consumeJsonNode() throws IOException { return jacksonJsonMapper().readTree(inputStream()); }
default Slime consumeSlime() throws IOException { return SlimeUtils.jsonToSlime(consumeByteArray()); }
default <T extends JacksonRequestEntity> T consumeJacksonEntity(Class<T> type) throws IOException {
return jacksonJsonMapper().readValue(inputStream(), type);
}
}
}
interface FilterContext {
RequestContext requestContext();
String route();
HttpResponse executeNext();
}
}
|
