org.springframework.http.server.reactive

Class AbstractListenerWriteFlushProcessor<T>

java.lang.Object

org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor<T>

Direct Known Subclasses:

ServletServerHttpResponse.ResponseBodyFlushProcessor, UndertowServerHttpResponse.ResponseBodyFlushProcessor

public abstract class AbstractListenerWriteFlushProcessor<T>
extends java.lang.Object

An alternative to AbstractListenerWriteProcessor but instead writing a Publisher<Publisher<T>> with flush boundaries enforces after the completion of each nested Publisher.

Since:

5.0

Author:

Arjen Poutsma, Violeta Georgieva, Rossen Stoyanchev

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	AbstractListenerWriteFlushProcessor.State

Field Summary

Fields

Modifier and Type	Field and Description
protected Log	logger
private WriteResultPublisher	resultPublisher
private java.util.concurrent.atomic.AtomicReference<AbstractListenerWriteFlushProcessor.State>	state
private boolean	subscriberCompleted
private Subscription	subscription

Constructor Summary

Constructors

Constructor and Description
AbstractListenerWriteFlushProcessor()

Method Summary

Modifier and Type	Method and Description
protected void	cancel() Listeners can call this method to cancel further writing.
private boolean	changeState(AbstractListenerWriteFlushProcessor.State oldState, AbstractListenerWriteFlushProcessor.State newState)
protected abstract <any>	createWriteProcessor() Create a new processor for subscribing to the next flush boundary.
protected abstract void	flush() Flush the output.
void	onComplete()
void	onError(java.lang.Throwable t)
void	onNext(<any> publisher)
void	onSubscribe(Subscription subscription)
void	subscribe(<any> subscriber)
private void	writeComplete()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

logger

protected final Log logger

resultPublisher

private final WriteResultPublisher resultPublisher

state

private final java.util.concurrent.atomic.AtomicReference<AbstractListenerWriteFlushProcessor.State> state

subscriberCompleted

private volatile boolean subscriberCompleted

subscription

private Subscription subscription

Constructor Detail

AbstractListenerWriteFlushProcessor

public AbstractListenerWriteFlushProcessor()

Method Detail

onSubscribe

public final void onSubscribe(Subscription subscription)

onNext

public final void onNext(<any> publisher)

onError

public final void onError(java.lang.Throwable t)

onComplete

public final void onComplete()

subscribe

public final void subscribe(<any> subscriber)

cancel

protected void cancel()

Listeners can call this method to cancel further writing.

createWriteProcessor

protected abstract <any> createWriteProcessor()

Create a new processor for subscribing to the next flush boundary.

flush

protected abstract void flush()
                       throws java.io.IOException

Flush the output.

Throws:

java.io.IOException

changeState

private boolean changeState(AbstractListenerWriteFlushProcessor.State oldState,
                            AbstractListenerWriteFlushProcessor.State newState)

writeComplete

private void writeComplete()