org.springframework.core.io.buffer

Class DataBufferUtils

  • java.lang.Object
    • org.springframework.core.io.buffer.DataBufferUtils


  • public abstract class DataBufferUtils
    extends java.lang.Object
    Utility class for working with DataBuffers.
    Since:
    5.0
    Author:
    Arjen Poutsma, Brian Clozel
    • Constructor Summary

      Constructors 
      Constructor and Description
      DataBufferUtils() 
    • Method Summary

      All Methods Static Methods Concrete Methods 
      Modifier and Type Method and Description
      static reactor.core.publisher.Mono<DataBuffer> join(org.reactivestreams.Publisher<DataBuffer> dataBuffers)
      Return a new DataBuffer composed of the dataBuffers elements joined together.
      static reactor.core.publisher.Flux<DataBuffer> read(Resource resource, DataBufferFactory dataBufferFactory, int bufferSize)
      Read the given Resource into a Flux of DataBuffers.
      static reactor.core.publisher.Flux<DataBuffer> read(Resource resource, long position, DataBufferFactory dataBufferFactory, int bufferSize)
      Read the given Resource into a Flux of DataBuffers starting at the given position.
      static reactor.core.publisher.Flux<DataBuffer> readAsynchronousFileChannel(java.util.concurrent.Callable<java.nio.channels.AsynchronousFileChannel> channelSupplier, DataBufferFactory dataBufferFactory, int bufferSize)
      Obtain a AsynchronousFileChannel from the given supplier, and read it into a Flux of DataBuffers.
      static reactor.core.publisher.Flux<DataBuffer> readAsynchronousFileChannel(java.util.concurrent.Callable<java.nio.channels.AsynchronousFileChannel> channelSupplier, long position, DataBufferFactory dataBufferFactory, int bufferSize)
      Obtain a AsynchronousFileChannel from the given supplier, and read it into a Flux of DataBuffers, starting at the given position.
      static reactor.core.publisher.Flux<DataBuffer> readByteChannel(java.util.concurrent.Callable<java.nio.channels.ReadableByteChannel> channelSupplier, DataBufferFactory dataBufferFactory, int bufferSize)
      Obtain a ReadableByteChannel from the given supplier, and read it into a Flux of DataBuffers.
      static reactor.core.publisher.Flux<DataBuffer> readInputStream(java.util.concurrent.Callable<java.io.InputStream> inputStreamSupplier, DataBufferFactory dataBufferFactory, int bufferSize)
      Obtain a InputStream from the given supplier, and read it into a Flux of DataBuffers.
      static boolean release(DataBuffer dataBuffer)
      Release the given data buffer, if it is a PooledDataBuffer and has been allocated.
      static java.util.function.Consumer<DataBuffer> releaseConsumer()
      Return a consumer that calls release(DataBuffer) on all passed data buffers.
      static <T extends DataBuffer>
      T
      retain(T dataBuffer)
      Retain the given data buffer, it it is a PooledDataBuffer.
      static reactor.core.publisher.Flux<DataBuffer> skipUntilByteCount(org.reactivestreams.Publisher<DataBuffer> publisher, long maxByteCount)
      Skip buffers from the given Publisher until the total byte count reaches the given maximum byte count, or until the publisher is complete.
      static reactor.core.publisher.Flux<DataBuffer> takeUntilByteCount(org.reactivestreams.Publisher<DataBuffer> publisher, long maxByteCount)
      Relay buffers from the given Publisher until the total byte count reaches the given maximum byte count, or until the publisher is complete.
      static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source, java.nio.channels.AsynchronousFileChannel channel)
      Write the given stream of DataBuffers to the given AsynchronousFileChannel.
      static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source, java.nio.channels.AsynchronousFileChannel channel, long position)
      Write the given stream of DataBuffers to the given AsynchronousFileChannel.
      static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source, java.io.OutputStream outputStream)
      Write the given stream of DataBuffers to the given OutputStream.
      static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source, java.nio.channels.WritableByteChannel channel)
      Write the given stream of DataBuffers to the given WritableByteChannel.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • DataBufferUtils

        public DataBufferUtils()
    • Method Detail

      • readInputStream

        public static reactor.core.publisher.Flux<DataBuffer> readInputStream(java.util.concurrent.Callable<java.io.InputStream> inputStreamSupplier,
                                                                              DataBufferFactory dataBufferFactory,
                                                                              int bufferSize)
        Obtain a InputStream from the given supplier, and read it into a Flux of DataBuffers. Closes the input stream when the flux is terminated.
        Parameters:
        inputStreamSupplier - the supplier for the input stream to read from
        dataBufferFactory - the factory to create data buffers with
        bufferSize - the maximum size of the data buffers
        Returns:
        a flux of data buffers read from the given channel
      • readByteChannel

        public static reactor.core.publisher.Flux<DataBuffer> readByteChannel(java.util.concurrent.Callable<java.nio.channels.ReadableByteChannel> channelSupplier,
                                                                              DataBufferFactory dataBufferFactory,
                                                                              int bufferSize)
        Obtain a ReadableByteChannel from the given supplier, and read it into a Flux of DataBuffers. Closes the channel when the flux is terminated.
        Parameters:
        channelSupplier - the supplier for the channel to read from
        dataBufferFactory - the factory to create data buffers with
        bufferSize - the maximum size of the data buffers
        Returns:
        a flux of data buffers read from the given channel
      • readAsynchronousFileChannel

        public static reactor.core.publisher.Flux<DataBuffer> readAsynchronousFileChannel(java.util.concurrent.Callable<java.nio.channels.AsynchronousFileChannel> channelSupplier,
                                                                                          DataBufferFactory dataBufferFactory,
                                                                                          int bufferSize)
        Obtain a AsynchronousFileChannel from the given supplier, and read it into a Flux of DataBuffers. Closes the channel when the flux is terminated.
        Parameters:
        channelSupplier - the supplier for the channel to read from
        dataBufferFactory - the factory to create data buffers with
        bufferSize - the maximum size of the data buffers
        Returns:
        a flux of data buffers read from the given channel
      • readAsynchronousFileChannel

        public static reactor.core.publisher.Flux<DataBuffer> readAsynchronousFileChannel(java.util.concurrent.Callable<java.nio.channels.AsynchronousFileChannel> channelSupplier,
                                                                                          long position,
                                                                                          DataBufferFactory dataBufferFactory,
                                                                                          int bufferSize)
        Obtain a AsynchronousFileChannel from the given supplier, and read it into a Flux of DataBuffers, starting at the given position. Closes the channel when the flux is terminated.
        Parameters:
        channelSupplier - the supplier for the channel to read from
        position - the position to start reading from
        dataBufferFactory - the factory to create data buffers with
        bufferSize - the maximum size of the data buffers
        Returns:
        a flux of data buffers read from the given channel
      • read

        public static reactor.core.publisher.Flux<DataBuffer> read(Resource resource,
                                                                   long position,
                                                                   DataBufferFactory dataBufferFactory,
                                                                   int bufferSize)
        Read the given Resource into a Flux of DataBuffers starting at the given position.

        If the resource is a file, it is read into an AsynchronousFileChannel and turned to Flux via readAsynchronousFileChannel(Callable, DataBufferFactory, int) or else fall back on readByteChannel(Callable, DataBufferFactory, int). Closes the channel when the flux is terminated.

        Parameters:
        resource - the resource to read from
        position - the position to start reading from
        dataBufferFactory - the factory to create data buffers with
        bufferSize - the maximum size of the data buffers
        Returns:
        a flux of data buffers read from the given channel
      • write

        public static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source,
                                                                    java.io.OutputStream outputStream)
        Write the given stream of DataBuffers to the given OutputStream. Does not close the output stream when the flux is terminated, and does not release the data buffers in the source. If releasing is required, then subscribe to the returned Flux with a releaseConsumer().

        Note that the writing process does not start until the returned Flux is subscribed to.

        Parameters:
        source - the stream of data buffers to be written
        outputStream - the output stream to write to
        Returns:
        a flux containing the same buffers as in source, that starts the writing process when subscribed to, and that publishes any writing errors and the completion signal
      • write

        public static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source,
                                                                    java.nio.channels.WritableByteChannel channel)
        Write the given stream of DataBuffers to the given WritableByteChannel. Does not close the channel when the flux is terminated, and does not release the data buffers in the source. If releasing is required, then subscribe to the returned Flux with a releaseConsumer().

        Note that the writing process does not start until the returned Flux is subscribed to.

        Parameters:
        source - the stream of data buffers to be written
        channel - the channel to write to
        Returns:
        a flux containing the same buffers as in source, that starts the writing process when subscribed to, and that publishes any writing errors and the completion signal
      • write

        public static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source,
                                                                    java.nio.channels.AsynchronousFileChannel channel)
        Write the given stream of DataBuffers to the given AsynchronousFileChannel. Does not close the channel when the flux is terminated, and does not release the data buffers in the source. If releasing is required, then subscribe to the returned Flux with a releaseConsumer().

        Note that the writing process does not start until the returned Flux is subscribed to.

        Parameters:
        source - the stream of data buffers to be written
        channel - the channel to write to
        Returns:
        a flux containing the same buffers as in source, that starts the writing process when subscribed to, and that publishes any writing errors and the completion signal
        Since:
        5.1
      • write

        public static reactor.core.publisher.Flux<DataBuffer> write(org.reactivestreams.Publisher<DataBuffer> source,
                                                                    java.nio.channels.AsynchronousFileChannel channel,
                                                                    long position)
        Write the given stream of DataBuffers to the given AsynchronousFileChannel. Does not close the channel when the flux is terminated, and does not release the data buffers in the source. If releasing is required, then subscribe to the returned Flux with a releaseConsumer().

        Note that the writing process does not start until the returned Flux is subscribed to.

        Parameters:
        source - the stream of data buffers to be written
        channel - the channel to write to
        position - the file position at which the write is to begin; must be non-negative
        Returns:
        a flux containing the same buffers as in source, that starts the writing process when subscribed to, and that publishes any writing errors and the completion signal
      • takeUntilByteCount

        public static reactor.core.publisher.Flux<DataBuffer> takeUntilByteCount(org.reactivestreams.Publisher<DataBuffer> publisher,
                                                                                 long maxByteCount)
        Relay buffers from the given Publisher until the total byte count reaches the given maximum byte count, or until the publisher is complete.
        Parameters:
        publisher - the publisher to filter
        maxByteCount - the maximum byte count
        Returns:
        a flux whose maximum byte count is maxByteCount
      • skipUntilByteCount

        public static reactor.core.publisher.Flux<DataBuffer> skipUntilByteCount(org.reactivestreams.Publisher<DataBuffer> publisher,
                                                                                 long maxByteCount)
        Skip buffers from the given Publisher until the total byte count reaches the given maximum byte count, or until the publisher is complete.
        Parameters:
        publisher - the publisher to filter
        maxByteCount - the maximum byte count
        Returns:
        a flux with the remaining part of the given publisher
      • retain

        public static <T extends DataBuffer> T retain(T dataBuffer)
        Retain the given data buffer, it it is a PooledDataBuffer.
        Parameters:
        dataBuffer - the data buffer to retain
        Returns:
        the retained buffer
      • release

        public static boolean release(@Nullable
                                      DataBuffer dataBuffer)
        Release the given data buffer, if it is a PooledDataBuffer and has been allocated.
        Parameters:
        dataBuffer - the data buffer to release
        Returns:
        true if the buffer was released; false otherwise.
      • releaseConsumer

        public static java.util.function.Consumer<DataBuffer> releaseConsumer()
        Return a consumer that calls release(DataBuffer) on all passed data buffers.
      • join

        public static reactor.core.publisher.Mono<DataBuffer> join(org.reactivestreams.Publisher<DataBuffer> dataBuffers)
        Return a new DataBuffer composed of the dataBuffers elements joined together. Depending on the DataBuffer implementation, the returned buffer may be a single buffer containing all data of the provided buffers, or it may be a true composite that contains references to the buffers.

        If dataBuffers contains an error signal, then all buffers that preceded the error will be released, and the error is stored in the returned Mono.

        Parameters:
        dataBuffers - the data buffers that are to be composed
        Returns:
        a buffer that is composed from the dataBuffers argument
        Since:
        5.0.3