root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Merge branch '5.2.x'

This commit is contained in:
Rossen Stoyanchev 2020-05-04 10:55:25 +01:00
parent 1b4b4c3302 9288067ea8
commit 153690e717
9 changed files with 221 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
spring-core/src/main/java/org/springframework/core/ReactiveAdapterRegistry.java
View File

@ -218,7 +218,7 @@ public class ReactiveAdapterRegistry {
source -> source);
registry.registerReactiveType(
ReactiveTypeDescriptor.singleOptionalValue(CompletionStage.class, EmptyCompletableFuture::new),
ReactiveTypeDescriptor.nonDeferredAsyncValue(CompletionStage.class, EmptyCompletableFuture::new),
source -> Mono.fromCompletionStage((CompletionStage<?>) source),
source -> Mono.from(source).toFuture()
);

35
spring-core/src/main/java/org/springframework/core/ReactiveTypeDescriptor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -39,18 +39,24 @@ public final class ReactiveTypeDescriptor {
@Nullable
private final Supplier<?> emptyValueSupplier;
private final boolean deferred;
/**
* Private constructor. See static factory methods.
*/
private ReactiveTypeDescriptor(Class<?> reactiveType, boolean multiValue, boolean noValue,
@Nullable Supplier<?> emptySupplier) {
this(reactiveType, multiValue, noValue, emptySupplier, true);
}
private ReactiveTypeDescriptor(Class<?> reactiveType, boolean multiValue, boolean noValue,
@Nullable Supplier<?> emptySupplier, boolean deferred) {
Assert.notNull(reactiveType, "'reactiveType' must not be null");
this.reactiveType = reactiveType;
this.multiValue = multiValue;
this.noValue = noValue;
this.emptyValueSupplier = emptySupplier;
this.deferred = deferred;
}
@ -95,6 +101,16 @@ public final class ReactiveTypeDescriptor {
return this.emptyValueSupplier.get();
}
/**
* Whether the underlying operation is deferred and needs to be started
* explicitly, e.g. via subscribing (or similar), or whether it is triggered
* without the consumer having any control.
* @since 5.1.16
*/
public boolean isDeferred() {
return this.deferred;
}
@Override
public boolean equals(@Nullable Object other) {
@ -148,4 +164,15 @@ public final class ReactiveTypeDescriptor {
return new ReactiveTypeDescriptor(type, false, true, emptySupplier);
}
/**
* The same as {@link #singleOptionalValue(Class, Supplier)} but for a
* non-deferred, async type such as {@link java.util.concurrent.CompletableFuture}.
* @param type the reactive type
* @param emptySupplier a supplier of an empty-value instance of the reactive type
* @since 5.1.16
*/
public static ReactiveTypeDescriptor nonDeferredAsyncValue(Class<?> type, Supplier<?> emptySupplier) {
return new ReactiveTypeDescriptor(type, false, false, emptySupplier, false);
}
}

21
spring-core/src/test/java/org/springframework/core/ReactiveAdapterRegistryTests.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -265,9 +265,26 @@ class ReactiveAdapterRegistryTests {
assertThat(((Mono<Integer>) target).block(Duration.ofMillis(1000))).isEqualTo(Integer.valueOf(1));
}
@Test
void deferred() {
assertThat(getAdapter(CompletableFuture.class).getDescriptor().isDeferred()).isEqualTo(false);
assertThat(getAdapter(Mono.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(Flux.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(io.reactivex.Completable.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(io.reactivex.Single.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(io.reactivex.Flowable.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(io.reactivex.Observable.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(Deferred.class).getDescriptor().isDeferred()).isEqualTo(true);
assertThat(getAdapter(kotlinx.coroutines.flow.Flow.class).getDescriptor().isDeferred()).isEqualTo(true);
}
private ReactiveAdapter getAdapter(Class<?> reactiveType) {
return this.registry.getAdapter(reactiveType);
ReactiveAdapter adapter = this.registry.getAdapter(reactiveType);
assertThat(adapter).isNotNull();
return adapter;
}
}

6
spring-web/src/main/java/org/springframework/http/server/reactive/WriteResultPublisher.java
View File

@ -175,6 +175,9 @@ class WriteResultPublisher implements Publisher<Void> {
@Override
void publishComplete(WriteResultPublisher publisher) {
publisher.completedBeforeSubscribed = true;
if(State.SUBSCRIBED.equals(publisher.state.get())) {
publisher.state.get().publishComplete(publisher);
}
}
@Override
void publishError(WriteResultPublisher publisher, Throwable ex) {
@ -190,6 +193,9 @@ class WriteResultPublisher implements Publisher<Void> {
@Override
void publishComplete(WriteResultPublisher publisher) {
publisher.completedBeforeSubscribed = true;
if(State.SUBSCRIBED.equals(publisher.state.get())) {
publisher.state.get().publishComplete(publisher);
}
}
@Override
void publishError(WriteResultPublisher publisher, Throwable ex) {

20
spring-web/src/main/java/org/springframework/web/client/HttpMessageConverterExtractor.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -31,6 +31,7 @@ import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.FileCopyUtils;
/**
* Response extractor that uses the given {@linkplain HttpMessageConverter entity converters}
@ -120,17 +121,17 @@ public class HttpMessageConverterExtractor<T> implements ResponseExtractor<T> {
this.responseType + "] and content type [" + contentType + "]", ex);
}
throw new RestClientException("Could not extract response: no suitable HttpMessageConverter found " +
"for response type [" + this.responseType + "] and content type [" + contentType + "]");
throw new UnknownContentTypeException(this.responseType, contentType,
response.getRawStatusCode(), response.getStatusText(), response.getHeaders(),
getResponseBody(response));
}
/**
* Determine the Content-Type of the response based on the "Content-Type"
* header or otherwise default to {@link MediaType#APPLICATION_OCTET_STREAM}.
* @param response the response
* @return the MediaType, possibly {@code null}.
* @return the MediaType, or "application/octet-stream"
*/
@Nullable
protected MediaType getContentType(ClientHttpResponse response) {
MediaType contentType = response.getHeaders().getContentType();
if (contentType == null) {
@ -142,4 +143,13 @@ public class HttpMessageConverterExtractor<T> implements ResponseExtractor<T> {
return contentType;
}
private static byte[] getResponseBody(ClientHttpResponse response) {
try {
return FileCopyUtils.copyToByteArray(response.getBody());
}
catch (IOException ex) {
// ignore
}
return new byte[0];
}
}

128
spring-web/src/main/java/org/springframework/web/client/UnknownContentTypeException.java Normal file
View File

@ -0,0 +1,128 @@
/*
* Copyright 2002-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.client;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.lang.Nullable;
/**
* Raised when no suitable
* {@link org.springframework.http.converter.HttpMessageConverter} could be
* found to extract the response.
*
* @author Rossen Stoyanchev
* @since 5.2.7
*/
public class UnknownContentTypeException extends RestClientException {
private static final long serialVersionUID = 2759516676367274084L;
private final Type targetType;
private final MediaType contentType;
private final int rawStatusCode;
private final String statusText;
private final byte[] responseBody;
private final HttpHeaders responseHeaders;
/**
* Construct a new instance of with the given response data.
* @param targetType the expected target type
* @param contentType the content type of the response
* @param statusCode the raw status code value
* @param statusText the status text
* @param responseHeaders the response headers (may be {@code null})
* @param responseBody the response body content (may be {@code null})
*/
public UnknownContentTypeException(Type targetType, MediaType contentType,
int statusCode, String statusText, HttpHeaders responseHeaders, byte[] responseBody) {
super("Could not extract response: no suitable HttpMessageConverter found " +
"for response type [" + targetType + "] and content type [" + contentType + "]");
this.targetType = targetType;
this.contentType = contentType;
this.rawStatusCode = statusCode;
this.statusText = statusText;
this.responseHeaders = responseHeaders;
this.responseBody = responseBody;
}
/**
* Return the target type expected for the response.
*/
public Type getTargetType() {
return this.targetType;
}
/**
* Return the content type of the response, or "application/octet-stream".
*/
public MediaType getContentType() {
return this.contentType;
}
/**
* Return the raw HTTP status code value.
*/
public int getRawStatusCode() {
return this.rawStatusCode;
}
/**
* Return the HTTP status text.
*/
public String getStatusText() {
return this.statusText;
}
/**
* Return the HTTP response headers.
*/
@Nullable
public HttpHeaders getResponseHeaders() {
return this.responseHeaders;
}
/**
* Return the response body as a byte array.
*/
public byte[] getResponseBody() {
return this.responseBody;
}
/**
* Return the response body converted to String using the charset from the
* response "Content-Type" or {@code "UTF-8"} otherwise.
*/
public String getResponseBodyAsString() {
return new String(this.responseBody, this.contentType.getCharset() != null ?
this.contentType.getCharset() : StandardCharsets.UTF_8);
}
}

27
spring-websocket/src/main/java/org/springframework/web/socket/sockjs/transport/session/AbstractSockJsSession.java
View File

@ -380,23 +380,32 @@ public abstract class AbstractSockJsSession implements SockJsSession {
public void delegateMessages(String... messages) throws SockJsMessageDeliveryException {
for (int i = 0; i < messages.length; i++) {
try {
if (!isClosed()) {
this.handler.handleMessage(this, new TextMessage(messages[i]));
}
else {
List<String> undelivered = getUndelivered(messages, i);
if (undelivered.isEmpty()) {
return;
}
throw new SockJsMessageDeliveryException(this.id, undelivered, "Session closed");
if (isClosed()) {
logUndeliveredMessages(i, messages);
return;
}
this.handler.handleMessage(this, new TextMessage(messages[i]));
}
catch (Exception ex) {
if (isClosed()) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to handle message '" + messages[i] + "'", ex);
}
logUndeliveredMessages(i, messages);
return;
}
throw new SockJsMessageDeliveryException(this.id, getUndelivered(messages, i), ex);
}
}
}
private void logUndeliveredMessages(int index, String[] messages) {
List<String> undelivered = getUndelivered(messages, index);
if (logger.isTraceEnabled() && !undelivered.isEmpty()) {
logger.trace("Dropped inbound message(s) due to closed session: " + undelivered);
}
}
private static List<String> getUndelivered(String[] messages, int i) {
switch (messages.length - i) {
case 0:

6
spring-websocket/src/test/java/org/springframework/web/socket/sockjs/transport/session/SockJsSessionTests.java
View File

@ -26,7 +26,6 @@ import org.junit.jupiter.api.Test;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.handler.ExceptionWebSocketHandlerDecorator;
import org.springframework.web.socket.sockjs.SockJsMessageDeliveryException;
import org.springframework.web.socket.sockjs.SockJsTransportFailureException;
import org.springframework.web.socket.sockjs.frame.SockJsFrame;
@ -118,10 +117,7 @@ public class SockJsSessionTests extends AbstractSockJsSessionTests<TestSockJsSes
willThrow(new IOException()).given(this.webSocketHandler).handleMessage(session, new TextMessage(msg2));
session.delegateConnectionEstablished();
assertThatExceptionOfType(SockJsMessageDeliveryException.class)
.isThrownBy(() -> session.delegateMessages(msg1, msg2, msg3))
.satisfies(ex -> assertThat(ex.getUndeliveredMessages()).containsExactly(msg3));
session.delegateMessages(msg1, msg2, msg3);
verify(this.webSocketHandler).afterConnectionEstablished(session);
verify(this.webSocketHandler).handleMessage(session, new TextMessage(msg1));

4
src/docs/asciidoc/web/webmvc.adoc
View File

@ -1634,7 +1634,7 @@ extracts the name, version, and file extension:
.Java
----
@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\\.[a-z]+}")
public void handle(@PathVariable String version, @PathVariable String ext) {
public void handle(@PathVariable String name, @PathVariable String version, @PathVariable String ext) {
// ...
}
----
@ -1642,7 +1642,7 @@ extracts the name, version, and file extension:
.Kotlin
----
@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\\.[a-z]+}")
fun handle(@PathVariable version: String, @PathVariable ext: String) {
fun handle(@PathVariable name: String, @PathVariable version: String, @PathVariable ext: String) {
// ...
}
----