下面列出了怎么用org.springframework.http.ResponseCookie的API类实例代码及写法，或者点击链接到github查看源代码。
@Test
public void from() {
ResponseCookie cookie = ResponseCookie.from("foo", "bar").build();
ServerResponse other = ServerResponse.ok().header("foo", "bar")
.cookie(cookie)
.hint("foo", "bar")
.build().block();
Mono<ServerResponse> result = ServerResponse.from(other).build();
StepVerifier.create(result)
.expectNextMatches(response -> HttpStatus.OK.equals(response.statusCode()) &&
"bar".equals(response.headers().getFirst("foo")) &&
cookie.equals(response.cookies().getFirst("foo")))
.expectComplete()
.verify();
}
@Test
public void build() {
ResponseCookie cookie = ResponseCookie.from("name", "value").build();
Mono<ServerResponse>
result = ServerResponse.status(HttpStatus.CREATED)
.header("MyKey", "MyValue")
.cookie(cookie).build();
MockServerHttpRequest request = MockServerHttpRequest.get("https://example.com").build();
MockServerWebExchange exchange = MockServerWebExchange.from(request);
result.flatMap(res -> res.writeTo(exchange, EMPTY_CONTEXT)).block();
MockServerHttpResponse response = exchange.getResponse();
assertEquals(HttpStatus.CREATED, response.getStatusCode());
assertEquals("MyValue", response.getHeaders().getFirst("MyKey"));
assertEquals("value", response.getCookies().getFirst("name").getValue());
StepVerifier.create(response.getBody()).expectComplete().verify();
}
@Test
public void build() {
ResponseCookie cookie = ResponseCookie.from("name", "value").build();
Mono<ServerResponse>
result = ServerResponse.status(HttpStatus.CREATED)
.header("MyKey", "MyValue")
.cookie(cookie).build();
MockServerHttpRequest request = MockServerHttpRequest.get("http://example.com").build();
MockServerWebExchange exchange = MockServerWebExchange.from(request);
result.flatMap(res -> res.writeTo(exchange, EMPTY_CONTEXT)).block();
MockServerHttpResponse response = exchange.getResponse();
assertEquals(HttpStatus.CREATED, response.getStatusCode());
assertEquals("MyValue", response.getHeaders().getFirst("MyKey"));
assertEquals("value", response.getCookies().getFirst("name").getValue());
StepVerifier.create(response.getBody()).expectComplete().verify();
}
@Test
public void beforeCommitWithComplete() throws Exception {
ResponseCookie cookie = ResponseCookie.from("ID", "123").build();
TestServerHttpResponse response = new TestServerHttpResponse();
response.beforeCommit(() -> Mono.fromRunnable(() -> response.getCookies().add(cookie.getName(), cookie)));
response.writeWith(Flux.just(wrap("a"), wrap("b"), wrap("c"))).block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertSame(cookie, response.getCookies().getFirst("ID"));
assertEquals(3, response.body.size());
assertEquals("a", new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("b", new String(response.body.get(1).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("c", new String(response.body.get(2).asByteBuffer().array(), StandardCharsets.UTF_8));
}
@Test
public void cookieSetInResponse() {
final String token = "test_token";
WebFilterChain filterChain = (filterExchange) -> {
try {
ResponseCookie cookie = filterExchange.getResponse().getCookies().getFirst(CSRF_COOKIE_NAME);
assertThat(cookie).isNotNull();
assertThat(cookie.getName()).isEqualTo(CSRF_COOKIE_NAME);
assertThat(cookie.getValue()).isEqualTo(token);
assertThat(cookie.getPath()).isEqualTo("/");
assertThat(cookie.getMaxAge()).isEqualTo(Duration.ofSeconds(-1));
assertThat(cookie.isHttpOnly()).isFalse();
assertThat(cookie.isSecure()).isFalse();
} catch (AssertionError ex) {
return Mono.error(ex);
}
return Mono.empty();
};
MockServerWebExchange exchange = MockServerWebExchange.from(
MockServerHttpRequest.post(TEST_URL)
);
exchange.getAttributes().put(CsrfToken.class.getName(), Mono.just(new DefaultCsrfToken(CSRF_COOKIE_NAME, "_csrf", token)));
this.filter.filter(exchange, filterChain).block();
}
private ResponseCookie initSessionCookie(
ServerWebExchange exchange, String id, Duration maxAge) {
ResponseCookie.ResponseCookieBuilder cookieBuilder = ResponseCookie.from(this.cookieName, id)
.path(exchange.getRequest().getPath().contextPath().value() + "/")
.maxAge(maxAge)
.httpOnly(true)
.secure("https".equalsIgnoreCase(exchange.getRequest().getURI().getScheme()))
.sameSite("Lax");
if (this.cookieInitializer != null) {
this.cookieInitializer.accept(cookieBuilder);
}
return cookieBuilder.build();
}
@Override
public MultiValueMap<String, ResponseCookie> getCookies() {
MultiValueMap<String, ResponseCookie> result = new LinkedMultiValueMap<>();
List<String> cookieHeader = getHeaders().get(HttpHeaders.SET_COOKIE);
if (cookieHeader != null) {
cookieHeader.forEach(header ->
HttpCookie.parse(header)
.forEach(cookie -> result.add(cookie.getName(),
ResponseCookie.from(cookie.getName(), cookie.getValue())
.domain(cookie.getDomain())
.path(cookie.getPath())
.maxAge(cookie.getMaxAge())
.secure(cookie.getSecure())
.httpOnly(cookie.isHttpOnly())
.build()))
);
}
return CollectionUtils.unmodifiableMultiValueMap(result);
}
@Test
public void shouldGetCookies() {
ResponseCookie simpleCookie = ResponseCookie.from("key2", "value2")
.build();
ResponseCookie complexCookie = ResponseCookie.from("key1", "value1")
.domain("domain")
.httpOnly(true)
.maxAge(1)
.path("path")
.secure(true)
.build();
given(mockDelegate.cookies()).willReturn(
Arrays.asList(simpleCookie.toString(), complexCookie.toString()));
MultiValueMap<String, ResponseCookie> expectedCookies = new LinkedMultiValueMap<>();
expectedCookies.add(simpleCookie.getName(), simpleCookie);
expectedCookies.add(complexCookie.getName(), complexCookie);
VertxClientHttpResponse response = new VertxClientHttpResponse(mockDelegate, Flux.empty());
MultiValueMap<String, ResponseCookie> actualCookies = response.getCookies();
assertThat(actualCookies).isEqualTo(expectedCookies);
}
@Override
protected void applyCookies() {
for (String name : getCookies().keySet()) {
for (ResponseCookie httpCookie : getCookies().get(name)) {
Cookie cookie = new CookieImpl(name, httpCookie.getValue());
if (!httpCookie.getMaxAge().isNegative()) {
cookie.setMaxAge((int) httpCookie.getMaxAge().getSeconds());
}
if (httpCookie.getDomain() != null) {
cookie.setDomain(httpCookie.getDomain());
}
if (httpCookie.getPath() != null) {
cookie.setPath(httpCookie.getPath());
}
cookie.setSecure(httpCookie.isSecure());
cookie.setHttpOnly(httpCookie.isHttpOnly());
this.exchange.getResponseCookies().putIfAbsent(name, cookie);
}
}
}
@Override
protected void applyCookies() {
for (String name : getCookies().keySet()) {
for (ResponseCookie httpCookie : getCookies().get(name)) {
Cookie cookie = new Cookie(name, httpCookie.getValue());
if (!httpCookie.getMaxAge().isNegative()) {
cookie.setMaxAge((int) httpCookie.getMaxAge().getSeconds());
}
if (httpCookie.getDomain() != null) {
cookie.setDomain(httpCookie.getDomain());
}
if (httpCookie.getPath() != null) {
cookie.setPath(httpCookie.getPath());
}
cookie.setSecure(httpCookie.isSecure());
cookie.setHttpOnly(httpCookie.isHttpOnly());
this.response.addCookie(cookie);
}
}
}
@Override
public MultiValueMap<String, ResponseCookie> getCookies() {
MultiValueMap<String, ResponseCookie> result = new LinkedMultiValueMap<>();
List<String> cookieHeader = getHeaders().get(HttpHeaders.SET_COOKIE);
if (cookieHeader != null) {
cookieHeader.forEach(header -> {
HttpCookie.parse(header)
.forEach(cookie -> result.add(cookie.getName(),
ResponseCookie.from(cookie.getName(), cookie.getValue())
.domain(cookie.getDomain())
.path(cookie.getPath())
.maxAge(cookie.getMaxAge())
.secure(cookie.getSecure())
.httpOnly(cookie.isHttpOnly())
.build()));
});
}
return CollectionUtils.unmodifiableMultiValueMap(result);
}
@Test
public void cookieInitializer() {
this.resolver.addCookieInitializer(builder -> builder.domain("example.org"));
this.resolver.addCookieInitializer(builder -> builder.sameSite("Strict"));
this.resolver.addCookieInitializer(builder -> builder.secure(false));
MockServerHttpRequest request = MockServerHttpRequest.get("https://example.org/path").build();
MockServerWebExchange exchange = MockServerWebExchange.from(request);
this.resolver.setSessionId(exchange, "123");
MultiValueMap<String, ResponseCookie> cookies = exchange.getResponse().getCookies();
assertEquals(1, cookies.size());
ResponseCookie cookie = cookies.getFirst(this.resolver.getCookieName());
assertNotNull(cookie);
assertEquals("SESSION=123; Path=/; Domain=example.org; HttpOnly; SameSite=Strict", cookie.toString());
}
@Test
public void beforeCommitWithComplete() throws Exception {
ResponseCookie cookie = ResponseCookie.from("ID", "123").build();
TestServerHttpResponse response = new TestServerHttpResponse();
response.beforeCommit(() -> Mono.fromRunnable(() -> response.getCookies().add(cookie.getName(), cookie)));
response.writeWith(Flux.just(wrap("a"), wrap("b"), wrap("c"))).block();
assertTrue(response.statusCodeWritten);
assertTrue(response.headersWritten);
assertTrue(response.cookiesWritten);
assertSame(cookie, response.getCookies().getFirst("ID"));
assertEquals(3, response.body.size());
assertEquals("a", new String(response.body.get(0).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("b", new String(response.body.get(1).asByteBuffer().array(), StandardCharsets.UTF_8));
assertEquals("c", new String(response.body.get(2).asByteBuffer().array(), StandardCharsets.UTF_8));
}
@Test
public void cookieInitializer() {
this.resolver.addCookieInitializer(builder -> builder.domain("example.org"));
this.resolver.addCookieInitializer(builder -> builder.sameSite("Strict"));
this.resolver.addCookieInitializer(builder -> builder.secure(false));
MockServerHttpRequest request = MockServerHttpRequest.get("https://example.org/path").build();
MockServerWebExchange exchange = MockServerWebExchange.from(request);
this.resolver.setSessionId(exchange, "123");
MultiValueMap<String, ResponseCookie> cookies = exchange.getResponse().getCookies();
assertEquals(1, cookies.size());
ResponseCookie cookie = cookies.getFirst(this.resolver.getCookieName());
assertNotNull(cookie);
assertEquals("SESSION=123; Path=/; Domain=example.org; HttpOnly; SameSite=Strict", cookie.toString());
}
/**
* Converts the specified {@link ResponseCookie} to Netty's {@link Cookie} interface.
*/
private static Cookie toArmeriaCookie(ResponseCookie resCookie) {
final CookieBuilder builder = Cookie.builder(resCookie.getName(), resCookie.getValue());
if (!resCookie.getMaxAge().isNegative()) {
builder.maxAge(resCookie.getMaxAge().getSeconds());
}
if (resCookie.getDomain() != null) {
builder.domain(resCookie.getDomain());
}
if (resCookie.getPath() != null) {
builder.path(resCookie.getPath());
}
builder.secure(resCookie.isSecure());
builder.httpOnly(resCookie.isHttpOnly());
if (resCookie.getSameSite() != null) {
builder.sameSite(resCookie.getSameSite());
}
return builder.build();
}
@Test
public void cookieHeaderSet() throws Exception {
ResponseCookie foo11 = ResponseCookie.from("foo1", "bar1").build();
ResponseCookie foo12 = ResponseCookie.from("foo1", "bar2").build();
ResponseCookie foo21 = ResponseCookie.from("foo2", "baz1").build();
ResponseCookie foo22 = ResponseCookie.from("foo2", "baz2").build();
MockServerHttpResponse response = new MockServerHttpResponse();
response.addCookie(foo11);
response.addCookie(foo12);
response.addCookie(foo21);
response.addCookie(foo22);
response.applyCookies();
assertEquals(Arrays.asList("foo1=bar1", "foo1=bar2", "foo2=baz1", "foo2=baz2"),
response.getHeaders().get(HttpHeaders.SET_COOKIE));
}
@Override
protected void applyCookies() {
for (String name : getCookies().keySet()) {
for (ResponseCookie httpCookie : getCookies().get(name)) {
Cookie cookie = new CookieImpl(name, httpCookie.getValue());
if (!httpCookie.getMaxAge().isNegative()) {
cookie.setMaxAge((int) httpCookie.getMaxAge().getSeconds());
}
if (httpCookie.getDomain() != null) {
cookie.setDomain(httpCookie.getDomain());
}
if (httpCookie.getPath() != null) {
cookie.setPath(httpCookie.getPath());
}
cookie.setSecure(httpCookie.isSecure());
cookie.setHttpOnly(httpCookie.isHttpOnly());
this.exchange.getResponseCookies().putIfAbsent(name, cookie);
}
}
}
@Override
protected void applyCookies() {
for (String name : getCookies().keySet()) {
for (ResponseCookie httpCookie : getCookies().get(name)) {
Cookie cookie = new Cookie(name, httpCookie.getValue());
if (!httpCookie.getMaxAge().isNegative()) {
cookie.setMaxAge((int) httpCookie.getMaxAge().getSeconds());
}
if (httpCookie.getDomain() != null) {
cookie.setDomain(httpCookie.getDomain());
}
if (httpCookie.getPath() != null) {
cookie.setPath(httpCookie.getPath());
}
cookie.setSecure(httpCookie.isSecure());
cookie.setHttpOnly(httpCookie.isHttpOnly());
this.response.addCookie(cookie);
}
}
}
private ResponseCookie initSessionCookie(
ServerWebExchange exchange, String id, Duration maxAge) {
ResponseCookie.ResponseCookieBuilder cookieBuilder = ResponseCookie.from(this.cookieName, id)
.path(exchange.getRequest().getPath().contextPath().value() + "/")
.maxAge(maxAge)
.httpOnly(true)
.secure("https".equalsIgnoreCase(exchange.getRequest().getURI().getScheme()))
.sameSite("Lax");
if (this.cookieInitializer != null) {
this.cookieInitializer.accept(cookieBuilder);
}
return cookieBuilder.build();
}
public BuiltClientHttpResponse(HttpStatus statusCode, HttpHeaders headers,
MultiValueMap<String, ResponseCookie> cookies, Flux<DataBuffer> body) {
this.statusCode = statusCode;
this.headers = HttpHeaders.readOnlyHttpHeaders(headers);
this.cookies = CollectionUtils.unmodifiableMultiValueMap(cookies);
this.body = body;
}
private static ResponseCookie toResponseCookie(java.net.HttpCookie cookie) {
return ResponseCookie.from(cookie.getName(), cookie.getValue())
.domain(cookie.getDomain())
.httpOnly(cookie.isHttpOnly())
.maxAge(cookie.getMaxAge())
.path(cookie.getPath())
.secure(cookie.getSecure())
.build();
}
protected AbstractServerResponse(
int statusCode, HttpHeaders headers, MultiValueMap<String, ResponseCookie> cookies,
Map<String, Object> hints) {
this.statusCode = statusCode;
this.headers = HttpHeaders.readOnlyHttpHeaders(headers);
this.cookies = CollectionUtils.unmodifiableMultiValueMap(new LinkedMultiValueMap<>(cookies));
this.hints = hints;
}
public WriterFunctionResponse(int statusCode, HttpHeaders headers,
MultiValueMap<String, ResponseCookie> cookies,
BiFunction<ServerWebExchange, Context, Mono<Void>> writeFunction) {
super(statusCode, headers, cookies, Collections.emptyMap());
Assert.notNull(writeFunction, "BiFunction must not be null");
this.writeFunction = writeFunction;
}
public DefaultRenderingResponse(int statusCode, HttpHeaders headers,
MultiValueMap<String, ResponseCookie> cookies, String name, Map<String, Object> model) {
super(statusCode, headers, cookies, Collections.emptyMap());
this.name = name;
this.model = Collections.unmodifiableMap(new LinkedHashMap<>(model));
}
public DefaultEntityResponse(int statusCode, HttpHeaders headers,
MultiValueMap<String, ResponseCookie> cookies, T entity,
BodyInserter<T, ? super ServerHttpResponse> inserter, Map<String, Object> hints) {
super(statusCode, headers, cookies, hints);
this.entity = entity;
this.inserter = inserter;
}
@Test
public void from() {
MockServerHttpRequest request = MockServerHttpRequest.post("https://example.com")
.header("foo", "bar")
.build();
MockServerWebExchange exchange = MockServerWebExchange.from(request);
ServerRequest other =
ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders());
Flux<DataBuffer> body = Flux.just("baz")
.map(s -> s.getBytes(StandardCharsets.UTF_8))
.map(dataBufferFactory::wrap);
ServerRequest result = ServerRequest.from(other)
.method(HttpMethod.HEAD)
.headers(httpHeaders -> httpHeaders.set("foo", "baar"))
.cookies(cookies -> cookies.set("baz", ResponseCookie.from("baz", "quux").build()))
.body(body)
.build();
assertEquals(HttpMethod.HEAD, result.method());
assertEquals(1, result.headers().asHttpHeaders().size());
assertEquals("baar", result.headers().asHttpHeaders().getFirst("foo"));
assertEquals(1, result.cookies().size());
assertEquals("quux", result.cookies().getFirst("baz").getValue());
StepVerifier.create(result.bodyToFlux(String.class))
.expectNext("baz")
.verifyComplete();
}
@Override
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
this.requestCookies = request.getCookies();
this.requestCookies.size(); // Cause lazy loading
response.getCookies().add("SID", ResponseCookie.from("SID", "31d4d96e407aad42")
.path("/").secure(true).httpOnly(true).build());
response.getCookies().add("lang", ResponseCookie.from("lang", "en-US")
.domain("example.com").path("/").build());
return response.setComplete();
}
@Test
public void from() {
MockServerHttpRequest request = MockServerHttpRequest.post("http://example.com")
.header("foo", "bar")
.build();
MockServerWebExchange exchange = MockServerWebExchange.from(request);
ServerRequest other =
ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders());
Flux<DataBuffer> body = Flux.just("baz")
.map(s -> s.getBytes(StandardCharsets.UTF_8))
.map(dataBufferFactory::wrap);
ServerRequest result = ServerRequest.from(other)
.method(HttpMethod.HEAD)
.headers(httpHeaders -> httpHeaders.set("foo", "baar"))
.cookies(cookies -> cookies.set("baz", ResponseCookie.from("baz", "quux").build()))
.body(body)
.build();
assertEquals(HttpMethod.HEAD, result.method());
assertEquals(1, result.headers().asHttpHeaders().size());
assertEquals("baar", result.headers().asHttpHeaders().getFirst("foo"));
assertEquals(1, result.cookies().size());
assertEquals("quux", result.cookies().getFirst("baz").getValue());
StepVerifier.create(result.bodyToFlux(String.class))
.expectNext("baz")
.verifyComplete();
}
@Test
public void toHttpHandlerHandlerReturnResponseStatusExceptionInResponseWriteTo() {
HandlerFunction<ServerResponse> handlerFunction =
// Mono.<ServerResponse> is required for compilation in Eclipse
request -> Mono.just(new ServerResponse() {
@Override
public HttpStatus statusCode() {
return HttpStatus.OK;
}
@Override
public HttpHeaders headers() {
return new HttpHeaders();
}
@Override
public MultiValueMap<String, ResponseCookie> cookies() {
return new LinkedMultiValueMap<>();
}
@Override
public Mono<Void> writeTo(ServerWebExchange exchange, Context context) {
return Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "Not found"));
}
});
RouterFunction<ServerResponse> routerFunction =
RouterFunctions.route(RequestPredicates.all(), handlerFunction);
HttpHandler result = RouterFunctions.toHttpHandler(routerFunction);
assertNotNull(result);
MockServerHttpRequest httpRequest = MockServerHttpRequest.get("http://localhost").build();
MockServerHttpResponse httpResponse = new MockServerHttpResponse();
result.handle(httpRequest, httpResponse).block();
assertEquals(HttpStatus.NOT_FOUND, httpResponse.getStatusCode());
}
@Test
public void cookies() {
MultiValueMap<String, ResponseCookie> newCookies = new LinkedMultiValueMap<>();
newCookies.add("name", ResponseCookie.from("name", "value").build());
Mono<RenderingResponse> result =
RenderingResponse.create("foo").cookies(cookies -> cookies.addAll(newCookies)).build();
StepVerifier.create(result)
.expectNextMatches(response -> newCookies.equals(response.cookies()))
.expectComplete()
.verify();
}