GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #1123 from violetagg/violetagg-flush-last-element

pull/1124/head
Rossen Stoyanchev 10 years ago
parent
fffea06056 d219054b0d
commit
3ffeec97cb
6 changed files with 249 additions and 140 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 32
      spring-web/src/main/java/org/springframework/http/server/reactive/AbstractListenerServerHttpResponse.java
  2. 118
      spring-web/src/main/java/org/springframework/http/server/reactive/AbstractResponseBodyFlushProcessor.java
  3. 62
      spring-web/src/main/java/org/springframework/http/server/reactive/AbstractResponseBodyProcessor.java
  4. 61
      spring-web/src/main/java/org/springframework/http/server/reactive/ServletServerHttpResponse.java
  5. 30
      spring-web/src/main/java/org/springframework/http/server/reactive/UndertowServerHttpResponse.java
  6. 86
      spring-web/src/test/java/org/springframework/http/server/reactive/WriteOnlyHandlerIntegrationTests.java

32
spring-web/src/main/java/org/springframework/http/server/reactive/AbstractListenerServerHttpResponse.java
Unescape View File

@ -26,7 +26,9 @@ import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory; import org.springframework.core.io.buffer.DataBufferFactory;
/** /**
* Abstract base class for listener-based server responses, i.e. Servlet 3.1 and Undertow. * Abstract base class for listener-based server responses, e.g. Servlet 3.1
* and Undertow.
*
* @author Arjen Poutsma * @author Arjen Poutsma
* @since 5.0 * @since 5.0
*/ */
@ -34,51 +36,37 @@ public abstract class AbstractListenerServerHttpResponse extends AbstractServerH
private final AtomicBoolean writeCalled = new AtomicBoolean(); private final AtomicBoolean writeCalled = new AtomicBoolean();
public AbstractListenerServerHttpResponse(DataBufferFactory dataBufferFactory) { public AbstractListenerServerHttpResponse(DataBufferFactory dataBufferFactory) {
super(dataBufferFactory); super(dataBufferFactory);
} }
@Override @Override
protected final Mono<Void> writeWithInternal(Publisher<DataBuffer> body) { protected final Mono<Void> writeWithInternal(Publisher<DataBuffer> body) {
if (this.writeCalled.compareAndSet(false, true)) { return writeAndFlushWithInternal(Mono.just(body));
Processor<DataBuffer, Void> bodyProcessor = createBodyProcessor();
return Mono.from(subscriber -> {
body.subscribe(bodyProcessor);
bodyProcessor.subscribe(subscriber);
});
} else {
return Mono.error(new IllegalStateException(
"writeWith() or writeAndFlushWith() has already been called"));
}
} }
@Override @Override
protected final Mono<Void> writeAndFlushWithInternal(Publisher<Publisher<DataBuffer>> body) { protected final Mono<Void> writeAndFlushWithInternal(Publisher<Publisher<DataBuffer>> body) {
if (this.writeCalled.compareAndSet(false, true)) { if (this.writeCalled.compareAndSet(false, true)) {
Processor<Publisher<DataBuffer>, Void> bodyProcessor = Processor<Publisher<DataBuffer>, Void> bodyProcessor = createBodyFlushProcessor();
createBodyFlushProcessor();
return Mono.from(subscriber -> { return Mono.from(subscriber -> {
body.subscribe(bodyProcessor); body.subscribe(bodyProcessor);
bodyProcessor.subscribe(subscriber); bodyProcessor.subscribe(subscriber);
}); });
} else { }
else {
return Mono.error(new IllegalStateException( return Mono.error(new IllegalStateException(
"writeWith() or writeAndFlushWith() has already been called")); "writeWith() or writeAndFlushWith() has already been called"));
} }
} }
/**
* Abstract template method to create a {@code Processor<DataBuffer, Void>} that
* will write the response body to the underlying output. Called from
* {@link #writeWithInternal(Publisher)}.
*/
protected abstract Processor<DataBuffer, Void> createBodyProcessor();
/** /**
* Abstract template method to create a {@code Processor<Publisher<DataBuffer>, Void>} * Abstract template method to create a {@code Processor<Publisher<DataBuffer>, Void>}
* that will write the response body with flushes to the underlying output. Called from * that will write the response body with flushes to the underlying output. Called from
* {@link #writeAndFlushWithInternal(Publisher)}. * {@link #writeAndFlushWithInternal(Publisher)}.
*/ */
protected abstract Processor<Publisher<DataBuffer>, Void> createBodyFlushProcessor(); protected abstract Processor<Publisher<DataBuffer>, Void> createBodyFlushProcessor();
} }

118
spring-web/src/main/java/org/springframework/http/server/reactive/AbstractResponseBodyFlushProcessor.java
Unescape View File

@ -35,26 +35,25 @@ import org.springframework.core.io.buffer.DataBuffer;
* Servlet 3.1 and Undertow support. * Servlet 3.1 and Undertow support.
* *
* @author Arjen Poutsma * @author Arjen Poutsma
* @author Violeta Georgieva
* @since 5.0 * @since 5.0
* @see ServletServerHttpRequest * @see ServletServerHttpRequest
* @see UndertowHttpHandlerAdapter * @see UndertowHttpHandlerAdapter
* @see ServerHttpResponse#writeAndFlushWith(Publisher) * @see ServerHttpResponse#writeAndFlushWith(Publisher)
*/ */
abstract class AbstractResponseBodyFlushProcessor abstract class AbstractResponseBodyFlushProcessor implements Processor<Publisher<DataBuffer>, Void> {
implements Processor<Publisher<DataBuffer>, Void> {
protected final Log logger = LogFactory.getLog(getClass()); protected final Log logger = LogFactory.getLog(getClass());
private final ResponseBodyWriteResultPublisher publisherDelegate = private final ResponseBodyWriteResultPublisher resultPublisher = new ResponseBodyWriteResultPublisher();
new ResponseBodyWriteResultPublisher();
private final AtomicReference<State> state = private final AtomicReference<State> state = new AtomicReference<>(State.UNSUBSCRIBED);
new AtomicReference<>(State.UNSUBSCRIBED);
private volatile boolean subscriberCompleted; private volatile boolean subscriberCompleted;
private Subscription subscription; private Subscription subscription;
// Subscriber // Subscriber
@Override @Override
@ -89,13 +88,15 @@ abstract class AbstractResponseBodyFlushProcessor
this.state.get().onComplete(this); this.state.get().onComplete(this);
} }
// Publisher // Publisher
@Override @Override
public final void subscribe(Subscriber<? super Void> subscriber) { public final void subscribe(Subscriber<? super Void> subscriber) {
this.publisherDelegate.subscribe(subscriber); this.resultPublisher.subscribe(subscriber);
} }
/** /**
* Creates a new processor for subscribing to a body chunk. * Creates a new processor for subscribing to a body chunk.
*/ */
@ -106,6 +107,11 @@ abstract class AbstractResponseBodyFlushProcessor
*/ */
protected abstract void flush() throws IOException; protected abstract void flush() throws IOException;
private boolean changeState(State oldState, State newState) {
return this.state.compareAndSet(oldState, newState);
}
private void writeComplete() { private void writeComplete() {
if (logger.isTraceEnabled()) { if (logger.isTraceEnabled()) {
logger.trace(this.state + " writeComplete"); logger.trace(this.state + " writeComplete");
@ -114,17 +120,19 @@ abstract class AbstractResponseBodyFlushProcessor
} }
private boolean changeState(State oldState, State newState) { private void cancel() {
return this.state.compareAndSet(oldState, newState); this.subscription.cancel();
} }
private enum State { private enum State {
UNSUBSCRIBED { UNSUBSCRIBED {
@Override @Override
public void onSubscribe(AbstractResponseBodyFlushProcessor processor, public void onSubscribe(AbstractResponseBodyFlushProcessor processor, Subscription subscription) {
Subscription subscription) {
Objects.requireNonNull(subscription, "Subscription cannot be null"); Objects.requireNonNull(subscription, "Subscription cannot be null");
if (processor.changeState(this, SUBSCRIBED)) { if (processor.changeState(this, REQUESTED)) {
processor.subscription = subscription; processor.subscription = subscription;
subscription.request(1); subscription.request(1);
} }
@ -132,86 +140,97 @@ abstract class AbstractResponseBodyFlushProcessor
super.onSubscribe(processor, subscription); super.onSubscribe(processor, subscription);
} }
} }
}, SUBSCRIBED { },
REQUESTED {
@Override @Override
public void onNext(AbstractResponseBodyFlushProcessor processor, public void onNext(AbstractResponseBodyFlushProcessor processor, Publisher<DataBuffer> chunk) {
Publisher<DataBuffer> chunk) { if (processor.changeState(this, RECEIVED)) {
Processor<DataBuffer, Void> chunkProcessor = Processor<DataBuffer, Void> chunkProcessor = processor.createBodyProcessor();
processor.createBodyProcessor(); chunk.subscribe(chunkProcessor);
chunk.subscribe(chunkProcessor); chunkProcessor.subscribe(new WriteSubscriber(processor));
chunkProcessor.subscribe(new WriteSubscriber(processor)); }
} }
@Override @Override
void onComplete(AbstractResponseBodyFlushProcessor processor) { public void onComplete(AbstractResponseBodyFlushProcessor processor) {
processor.subscriberCompleted = true; if (processor.changeState(this, COMPLETED)) {
processor.resultPublisher.publishComplete();
}
} }
},
RECEIVED {
@Override @Override
public void writeComplete(AbstractResponseBodyFlushProcessor processor) { public void writeComplete(AbstractResponseBodyFlushProcessor processor) {
try {
processor.flush();
}
catch (IOException ex) {
processor.cancel();
processor.onError(ex);
}
if (processor.subscriberCompleted) { if (processor.subscriberCompleted) {
if (processor.changeState(this, COMPLETED)) { if (processor.changeState(this, COMPLETED)) {
processor.publisherDelegate.publishComplete(); processor.resultPublisher.publishComplete();
} }
} }
else { else {
try { if (processor.changeState(this, REQUESTED)) {
processor.flush(); processor.subscription.request(1);
}
catch (IOException ex) {
processor.onError(ex);
} }
processor.subscription.request(1);
} }
} }
}, COMPLETED {
@Override
public void onNext(AbstractResponseBodyFlushProcessor processor,
Publisher<DataBuffer> publisher) {
// ignore
@Override
public void onComplete(AbstractResponseBodyFlushProcessor processor) {
processor.subscriberCompleted = true;
} }
},
COMPLETED {
@Override @Override
void onError(AbstractResponseBodyFlushProcessor processor, Throwable t) { public void onNext(AbstractResponseBodyFlushProcessor processor,
Publisher<DataBuffer> publisher) {
// ignore // ignore
} }
@Override @Override
void onComplete(AbstractResponseBodyFlushProcessor processor) { public void onError(AbstractResponseBodyFlushProcessor processor, Throwable t) {
// ignore // ignore
} }
@Override @Override
public void writeComplete(AbstractResponseBodyFlushProcessor processor) { public void onComplete(AbstractResponseBodyFlushProcessor processor) {
// ignore // ignore
} }
}; };
public void onSubscribe(AbstractResponseBodyFlushProcessor processor, public void onSubscribe(AbstractResponseBodyFlushProcessor processor, Subscription subscription) {
Subscription subscription) {
subscription.cancel(); subscription.cancel();
} }
public void onNext(AbstractResponseBodyFlushProcessor processor, public void onNext(AbstractResponseBodyFlushProcessor processor, Publisher<DataBuffer> publisher) {
Publisher<DataBuffer> publisher) {
throw new IllegalStateException(toString()); throw new IllegalStateException(toString());
} }
void onError(AbstractResponseBodyFlushProcessor processor, Throwable t) { public void onError(AbstractResponseBodyFlushProcessor processor, Throwable ex) {
if (processor.changeState(this, COMPLETED)) { if (processor.changeState(this, COMPLETED)) {
processor.publisherDelegate.publishError(t); processor.resultPublisher.publishError(ex);
} }
} }
void onComplete(AbstractResponseBodyFlushProcessor processor) { public void onComplete(AbstractResponseBodyFlushProcessor processor) {
throw new IllegalStateException(toString()); throw new IllegalStateException(toString());
} }
public void writeComplete(AbstractResponseBodyFlushProcessor processor) { public void writeComplete(AbstractResponseBodyFlushProcessor processor) {
throw new IllegalStateException(toString()); // ignore
} }
private static class WriteSubscriber implements Subscriber<Void> { private static class WriteSubscriber implements Subscriber<Void> {
private final AbstractResponseBodyFlushProcessor processor; private final AbstractResponseBodyFlushProcessor processor;
@ -221,8 +240,8 @@ abstract class AbstractResponseBodyFlushProcessor
} }
@Override @Override
public void onSubscribe(Subscription s) { public void onSubscribe(Subscription subscription) {
s.request(Long.MAX_VALUE); subscription.request(Long.MAX_VALUE);
} }
@Override @Override
@ -230,13 +249,14 @@ abstract class AbstractResponseBodyFlushProcessor
} }
@Override @Override
public void onError(Throwable t) { public void onError(Throwable ex) {
processor.onError(t); this.processor.cancel();
this.processor.onError(ex);
} }
@Override @Override
public void onComplete() { public void onComplete() {
processor.writeComplete(); this.processor.writeComplete();
} }
} }
} }

62
spring-web/src/main/java/org/springframework/http/server/reactive/AbstractResponseBodyProcessor.java
Unescape View File

@ -48,11 +48,9 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
protected final Log logger = LogFactory.getLog(getClass()); protected final Log logger = LogFactory.getLog(getClass());
private final ResponseBodyWriteResultPublisher publisherDelegate = private final ResponseBodyWriteResultPublisher resultPublisher = new ResponseBodyWriteResultPublisher();
new ResponseBodyWriteResultPublisher();
private final AtomicReference<State> state = private final AtomicReference<State> state = new AtomicReference<>(State.UNSUBSCRIBED);
new AtomicReference<>(State.UNSUBSCRIBED);
private volatile DataBuffer currentBuffer; private volatile DataBuffer currentBuffer;
@ -60,6 +58,7 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
private Subscription subscription; private Subscription subscription;
// Subscriber // Subscriber
@Override @Override
@ -94,13 +93,15 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
this.state.get().onComplete(this); this.state.get().onComplete(this);
} }
// Publisher // Publisher
@Override @Override
public final void subscribe(Subscriber<? super Void> subscriber) { public final void subscribe(Subscriber<? super Void> subscriber) {
this.publisherDelegate.subscribe(subscriber); this.resultPublisher.subscribe(subscriber);
} }
// listener methods // listener methods
/** /**
@ -159,10 +160,15 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
*/ */
protected abstract boolean write(DataBuffer dataBuffer) throws IOException; protected abstract boolean write(DataBuffer dataBuffer) throws IOException;
protected void cancel() {
this.subscription.cancel();
}
private boolean changeState(State oldState, State newState) { private boolean changeState(State oldState, State newState) {
return this.state.compareAndSet(oldState, newState); return this.state.compareAndSet(oldState, newState);
} }
/** /**
* Represents a state for the {@link Subscriber} to be in. The following figure * Represents a state for the {@link Subscriber} to be in. The following figure
* indicate the four different states that exist, and the relationships between them. * indicate the four different states that exist, and the relationships between them.
@ -189,9 +195,9 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
* #REQUESTED}. * #REQUESTED}.
*/ */
UNSUBSCRIBED { UNSUBSCRIBED {
@Override @Override
void onSubscribe(AbstractResponseBodyProcessor processor, public void onSubscribe(AbstractResponseBodyProcessor processor, Subscription subscription) {
Subscription subscription) {
Objects.requireNonNull(subscription, "Subscription cannot be null"); Objects.requireNonNull(subscription, "Subscription cannot be null");
if (processor.changeState(this, REQUESTED)) { if (processor.changeState(this, REQUESTED)) {
processor.subscription = subscription; processor.subscription = subscription;
@ -209,8 +215,9 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
* changing state to {@link #COMPLETED}. * changing state to {@link #COMPLETED}.
*/ */
REQUESTED { REQUESTED {
@Override @Override
void onNext(AbstractResponseBodyProcessor processor, DataBuffer dataBuffer) { public void onNext(AbstractResponseBodyProcessor processor, DataBuffer dataBuffer) {
if (processor.changeState(this, RECEIVED)) { if (processor.changeState(this, RECEIVED)) {
processor.receiveBuffer(dataBuffer); processor.receiveBuffer(dataBuffer);
processor.writeIfPossible(); processor.writeIfPossible();
@ -218,10 +225,9 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
} }
@Override @Override
void onComplete(AbstractResponseBodyProcessor processor) { public void onComplete(AbstractResponseBodyProcessor processor) {
if (processor.changeState(this, COMPLETED)) { if (processor.changeState(this, COMPLETED)) {
processor.subscriberCompleted = true; processor.resultPublisher.publishComplete();
processor.publisherDelegate.publishComplete();
} }
} }
}, },
@ -235,8 +241,9 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
* be written completely the state will be changed to {@link #RECEIVED}. * be written completely the state will be changed to {@link #RECEIVED}.
*/ */
RECEIVED { RECEIVED {
@Override @Override
void onWritePossible(AbstractResponseBodyProcessor processor) { public void onWritePossible(AbstractResponseBodyProcessor processor) {
if (processor.changeState(this, WRITING)) { if (processor.changeState(this, WRITING)) {
DataBuffer dataBuffer = processor.currentBuffer; DataBuffer dataBuffer = processor.currentBuffer;
try { try {
@ -249,7 +256,7 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
} }
else { else {
processor.changeState(WRITING, COMPLETED); processor.changeState(WRITING, COMPLETED);
processor.publisherDelegate.publishComplete(); processor.resultPublisher.publishComplete();
} }
} }
else { else {
@ -258,13 +265,14 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
} }
} }
catch (IOException ex) { catch (IOException ex) {
processor.cancel();
processor.onError(ex); processor.onError(ex);
} }
} }
} }
@Override @Override
void onComplete(AbstractResponseBodyProcessor processor) { public void onComplete(AbstractResponseBodyProcessor processor) {
processor.subscriberCompleted = true; processor.subscriberCompleted = true;
} }
}, },
@ -273,8 +281,9 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
* {@code onWritePossible started}. * {@code onWritePossible started}.
*/ */
WRITING { WRITING {
@Override @Override
void onComplete(AbstractResponseBodyProcessor processor) { public void onComplete(AbstractResponseBodyProcessor processor) {
processor.subscriberCompleted = true; processor.subscriberCompleted = true;
} }
}, },
@ -282,43 +291,44 @@ abstract class AbstractResponseBodyProcessor implements Processor<DataBuffer, Vo
* The terminal completed state. Does not respond to any events. * The terminal completed state. Does not respond to any events.
*/ */
COMPLETED { COMPLETED {
@Override @Override
void onNext(AbstractResponseBodyProcessor processor, DataBuffer dataBuffer) { public void onNext(AbstractResponseBodyProcessor processor, DataBuffer dataBuffer) {
// ignore // ignore
} }
@Override @Override
void onError(AbstractResponseBodyProcessor processor, Throwable t) { public void onError(AbstractResponseBodyProcessor processor, Throwable ex) {
// ignore // ignore
} }
@Override @Override
void onComplete(AbstractResponseBodyProcessor processor) { public void onComplete(AbstractResponseBodyProcessor processor) {
// ignore // ignore
} }
}; };
void onSubscribe(AbstractResponseBodyProcessor processor, Subscription s) { public void onSubscribe(AbstractResponseBodyProcessor processor, Subscription subscription) {
s.cancel(); subscription.cancel();
} }
void onNext(AbstractResponseBodyProcessor processor, DataBuffer dataBuffer) { public void onNext(AbstractResponseBodyProcessor processor, DataBuffer dataBuffer) {
throw new IllegalStateException(toString()); throw new IllegalStateException(toString());
} }
void onError(AbstractResponseBodyProcessor processor, Throwable t) { public void onError(AbstractResponseBodyProcessor processor, Throwable ex) {
if (processor.changeState(this, COMPLETED)) { if (processor.changeState(this, COMPLETED)) {
processor.publisherDelegate.publishError(t); processor.resultPublisher.publishError(ex);
} }
} }
void onComplete(AbstractResponseBodyProcessor processor) { public void onComplete(AbstractResponseBodyProcessor processor) {
throw new IllegalStateException(toString()); throw new IllegalStateException(toString());
} }
void onWritePossible(AbstractResponseBodyProcessor processor) {
public void onWritePossible(AbstractResponseBodyProcessor processor) {
// ignore // ignore
} }
} }
} }

61
spring-web/src/main/java/org/springframework/http/server/reactive/ServletServerHttpResponse.java
Unescape View File

@ -22,13 +22,13 @@ import java.io.UncheckedIOException;
import java.nio.charset.Charset; import java.nio.charset.Charset;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.servlet.ServletOutputStream; import javax.servlet.ServletOutputStream;
import javax.servlet.WriteListener; import javax.servlet.WriteListener;
import javax.servlet.http.Cookie; import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.reactivestreams.Processor; import org.reactivestreams.Processor;
import org.reactivestreams.Publisher;
import org.springframework.core.io.buffer.DataBuffer; import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferFactory; import org.springframework.core.io.buffer.DataBufferFactory;
@ -44,7 +44,7 @@ import org.springframework.util.Assert;
*/ */
public class ServletServerHttpResponse extends AbstractListenerServerHttpResponse { public class ServletServerHttpResponse extends AbstractListenerServerHttpResponse {
private final AtomicBoolean listenerRegistered = new AtomicBoolean(); private final ResponseBodyWriteListener writeListener = new ResponseBodyWriteListener();
private volatile ResponseBodyProcessor bodyProcessor; private volatile ResponseBodyProcessor bodyProcessor;
@ -54,8 +54,10 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
private volatile boolean flushOnNext; private volatile boolean flushOnNext;
public ServletServerHttpResponse(HttpServletResponse response, public ServletServerHttpResponse(HttpServletResponse response,
DataBufferFactory dataBufferFactory, int bufferSize) throws IOException { DataBufferFactory dataBufferFactory, int bufferSize) throws IOException {
super(dataBufferFactory); super(dataBufferFactory);
Assert.notNull(response, "'response' must not be null"); Assert.notNull(response, "'response' must not be null");
Assert.notNull(dataBufferFactory, "'dataBufferFactory' must not be null"); Assert.notNull(dataBufferFactory, "'dataBufferFactory' must not be null");
@ -65,6 +67,7 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
this.bufferSize = bufferSize; this.bufferSize = bufferSize;
} }
public HttpServletResponse getServletResponse() { public HttpServletResponse getServletResponse() {
return this.response; return this.response;
} }
@ -112,15 +115,28 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
} }
} }
private void registerListener() throws IOException { @Override
if (this.listenerRegistered.compareAndSet(false, true)) { protected Processor<Publisher<DataBuffer>, Void> createBodyFlushProcessor() {
ResponseBodyWriteListener writeListener = new ResponseBodyWriteListener(); Processor<Publisher<DataBuffer>, Void> processor = new ResponseBodyFlushProcessor();
this.response.getOutputStream().setWriteListener(writeListener); registerListener();
return processor;
}
private void registerListener() {
try {
outputStream().setWriteListener(writeListener);
}
catch (IOException e) {
throw new UncheckedIOException(e);
} }
} }
private ServletOutputStream outputStream() throws IOException {
return this.response.getOutputStream();
}
private void flush() throws IOException { private void flush() throws IOException {
ServletOutputStream outputStream = this.response.getOutputStream(); ServletOutputStream outputStream = outputStream();
if (outputStream.isReady()) { if (outputStream.isReady()) {
try { try {
outputStream.flush(); outputStream.flush();
@ -136,23 +152,6 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
} }
} }
@Override
protected ResponseBodyProcessor createBodyProcessor() {
try {
registerListener();
this.bodyProcessor = new ResponseBodyProcessor(this.response.getOutputStream(),
this.bufferSize);
return this.bodyProcessor;
}
catch (IOException ex) {
throw new UncheckedIOException(ex);
}
}
@Override
protected AbstractResponseBodyFlushProcessor createBodyFlushProcessor() {
return new ResponseBodyFlushProcessor();
}
private class ResponseBodyProcessor extends AbstractResponseBodyProcessor { private class ResponseBodyProcessor extends AbstractResponseBodyProcessor {
@ -160,11 +159,13 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
private final int bufferSize; private final int bufferSize;
public ResponseBodyProcessor(ServletOutputStream outputStream, int bufferSize) { public ResponseBodyProcessor(ServletOutputStream outputStream, int bufferSize) {
this.outputStream = outputStream; this.outputStream = outputStream;
this.bufferSize = bufferSize; this.bufferSize = bufferSize;
} }
@Override @Override
protected boolean isWritePossible() { protected boolean isWritePossible() {
return this.outputStream.isReady(); return this.outputStream.isReady();
@ -206,8 +207,7 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
byte[] buffer = new byte[this.bufferSize]; byte[] buffer = new byte[this.bufferSize];
int bytesRead = -1; int bytesRead = -1;
while (this.outputStream.isReady() && while (this.outputStream.isReady() && (bytesRead = input.read(buffer)) != -1) {
(bytesRead = input.read(buffer)) != -1) {
this.outputStream.write(buffer, 0, bytesRead); this.outputStream.write(buffer, 0, bytesRead);
bytesWritten += bytesRead; bytesWritten += bytesRead;
} }
@ -229,6 +229,7 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
@Override @Override
public void onError(Throwable ex) { public void onError(Throwable ex) {
if (bodyProcessor != null) { if (bodyProcessor != null) {
bodyProcessor.cancel();
bodyProcessor.onError(ex); bodyProcessor.onError(ex);
} }
} }
@ -238,7 +239,13 @@ public class ServletServerHttpResponse extends AbstractListenerServerHttpRespons
@Override @Override
protected Processor<DataBuffer, Void> createBodyProcessor() { protected Processor<DataBuffer, Void> createBodyProcessor() {
return ServletServerHttpResponse.this.createBodyProcessor(); try {
bodyProcessor = new ResponseBodyProcessor(outputStream(), bufferSize);
return bodyProcessor;
}
catch (IOException ex) {
throw new UncheckedIOException(ex);
}
} }
@Override @Override

30
spring-web/src/main/java/org/springframework/http/server/reactive/UndertowServerHttpResponse.java
Unescape View File

@ -55,13 +55,14 @@ public class UndertowServerHttpResponse extends AbstractListenerServerHttpRespon
private StreamSinkChannel responseChannel; private StreamSinkChannel responseChannel;
public UndertowServerHttpResponse(HttpServerExchange exchange,
DataBufferFactory dataBufferFactory) { public UndertowServerHttpResponse(HttpServerExchange exchange, DataBufferFactory bufferFactory) {
super(dataBufferFactory); super(bufferFactory);
Assert.notNull(exchange, "'exchange' is required."); Assert.notNull(exchange, "'exchange' is required.");
this.exchange = exchange; this.exchange = exchange;
} }
public HttpServerExchange getUndertowExchange() { public HttpServerExchange getUndertowExchange() {
return this.exchange; return this.exchange;
} }
@ -78,10 +79,8 @@ public class UndertowServerHttpResponse extends AbstractListenerServerHttpRespon
public Mono<Void> writeWith(File file, long position, long count) { public Mono<Void> writeWith(File file, long position, long count) {
writeHeaders(); writeHeaders();
writeCookies(); writeCookies();
try { try {
StreamSinkChannel responseChannel = StreamSinkChannel responseChannel = getUndertowExchange().getResponseChannel();
getUndertowExchange().getResponseChannel();
@SuppressWarnings("resource") @SuppressWarnings("resource")
FileChannel in = new FileInputStream(file).getChannel(); FileChannel in = new FileInputStream(file).getChannel();
long result = responseChannel.transferFrom(in, position, count); long result = responseChannel.transferFrom(in, position, count);
@ -124,20 +123,19 @@ public class UndertowServerHttpResponse extends AbstractListenerServerHttpRespon
} }
@Override @Override
protected ResponseBodyProcessor createBodyProcessor() { protected AbstractResponseBodyFlushProcessor createBodyFlushProcessor() {
return new ResponseBodyFlushProcessor();
}
private ResponseBodyProcessor createBodyProcessor() {
if (this.responseChannel == null) { if (this.responseChannel == null) {
this.responseChannel = this.exchange.getResponseChannel(); this.responseChannel = this.exchange.getResponseChannel();
} }
ResponseBodyProcessor bodyProcessor = ResponseBodyProcessor bodyProcessor = new ResponseBodyProcessor( this.responseChannel);
new ResponseBodyProcessor( this.responseChannel);
bodyProcessor.registerListener(); bodyProcessor.registerListener();
return bodyProcessor; return bodyProcessor;
} }
@Override
protected AbstractResponseBodyFlushProcessor createBodyFlushProcessor() {
return new ResponseBodyFlushProcessor();
}
private static class ResponseBodyProcessor extends AbstractResponseBodyProcessor { private static class ResponseBodyProcessor extends AbstractResponseBodyProcessor {
@ -147,11 +145,13 @@ public class UndertowServerHttpResponse extends AbstractListenerServerHttpRespon
private volatile ByteBuffer byteBuffer; private volatile ByteBuffer byteBuffer;
public ResponseBodyProcessor(StreamSinkChannel responseChannel) { public ResponseBodyProcessor(StreamSinkChannel responseChannel) {
Assert.notNull(responseChannel, "'responseChannel' must not be null"); Assert.notNull(responseChannel, "'responseChannel' must not be null");
this.responseChannel = responseChannel; this.responseChannel = responseChannel;
} }
public void registerListener() { public void registerListener() {
this.responseChannel.getWriteSetter().set(this.listener); this.responseChannel.getWriteSetter().set(this.listener);
this.responseChannel.resumeWrites(); this.responseChannel.resumeWrites();
@ -203,9 +203,7 @@ public class UndertowServerHttpResponse extends AbstractListenerServerHttpRespon
public void handleEvent(StreamSinkChannel channel) { public void handleEvent(StreamSinkChannel channel) {
onWritePossible(); onWritePossible();
} }
} }
} }
private class ResponseBodyFlushProcessor extends AbstractResponseBodyFlushProcessor { private class ResponseBodyFlushProcessor extends AbstractResponseBodyFlushProcessor {
@ -224,6 +222,6 @@ public class UndertowServerHttpResponse extends AbstractListenerServerHttpRespon
UndertowServerHttpResponse.this.responseChannel.flush(); UndertowServerHttpResponse.this.responseChannel.flush();
} }
} }
} }
} }

86
spring-web/src/test/java/org/springframework/http/server/reactive/WriteOnlyHandlerIntegrationTests.java
Unescape View File

@ -0,0 +1,86 @@
/*
* Copyright 2002-2016 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
*
* http://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.http.server.reactive;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.Random;
import org.junit.Test;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.client.RestTemplate;
import static org.junit.Assert.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
/**
* @author Violeta Georgieva
* @since 5.0
*/
public class WriteOnlyHandlerIntegrationTests extends AbstractHttpHandlerIntegrationTests {
private static final int REQUEST_SIZE = 4096 * 3;
private Random rnd = new Random();
private byte[] body;
@Override
protected WriteOnlyHandler createHttpHandler() {
return new WriteOnlyHandler();
}
@Test
public void writeOnly() throws Exception {
RestTemplate restTemplate = new RestTemplate();
this.body = randomBytes();
RequestEntity<byte[]> request = RequestEntity.post(
new URI("http://localhost:" + port)).body(
"".getBytes(StandardCharsets.UTF_8));
ResponseEntity<byte[]> response = restTemplate.exchange(request, byte[].class);
assertArrayEquals(body, response.getBody());
}
private byte[] randomBytes() {
byte[] buffer = new byte[REQUEST_SIZE];
rnd.nextBytes(buffer);
return buffer;
}
public class WriteOnlyHandler implements HttpHandler {
@Override
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
DataBuffer buffer = response.bufferFactory().allocateBuffer(body.length);
buffer.write(body);
return response.writeAndFlushWith(Flux.just(Flux.just(buffer)));
}
}
}
Write Preview
Loading…
Cancel
Save