All Downloads are FREE. Search and download functionalities are using the official Maven repository.

keycloakjar.org.springframework.util.StreamUtils Maven / Gradle / Ivy

There is a newer version: 2.2.3
Show newest version
/*
 * Copyright 2002-2018 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.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FilterInputStream;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.Charset;

import org.springframework.lang.Nullable;

/**
 * Simple utility methods for dealing with streams. The copy methods of this class are
 * similar to those defined in {@link FileCopyUtils} except that all affected streams are
 * left open when done. All copy methods use a block size of 4096 bytes.
 *
 * 

Mainly for use within the framework, but also useful for application code. * * @author Juergen Hoeller * @author Phillip Webb * @author Brian Clozel * @since 3.2.2 * @see FileCopyUtils */ public abstract class StreamUtils { /** * The default buffer size used why copying bytes. */ public static final int BUFFER_SIZE = 4096; private static final byte[] EMPTY_CONTENT = new byte[0]; /** * Copy the contents of the given InputStream into a new byte array. * Leaves the stream open when done. * @param in the stream to copy from (may be {@code null} or empty) * @return the new byte array that has been copied to (possibly empty) * @throws IOException in case of I/O errors */ public static byte[] copyToByteArray(@Nullable InputStream in) throws IOException { if (in == null) { return new byte[0]; } ByteArrayOutputStream out = new ByteArrayOutputStream(BUFFER_SIZE); copy(in, out); return out.toByteArray(); } /** * Copy the contents of the given InputStream into a String. * Leaves the stream open when done. * @param in the InputStream to copy from (may be {@code null} or empty) * @return the String that has been copied to (possibly empty) * @throws IOException in case of I/O errors */ public static String copyToString(@Nullable InputStream in, Charset charset) throws IOException { if (in == null) { return ""; } StringBuilder out = new StringBuilder(); InputStreamReader reader = new InputStreamReader(in, charset); char[] buffer = new char[BUFFER_SIZE]; int bytesRead = -1; while ((bytesRead = reader.read(buffer)) != -1) { out.append(buffer, 0, bytesRead); } return out.toString(); } /** * Copy the contents of the given byte array to the given OutputStream. * Leaves the stream open when done. * @param in the byte array to copy from * @param out the OutputStream to copy to * @throws IOException in case of I/O errors */ public static void copy(byte[] in, OutputStream out) throws IOException { Assert.notNull(in, "No input byte array specified"); Assert.notNull(out, "No OutputStream specified"); out.write(in); } /** * Copy the contents of the given String to the given output OutputStream. * Leaves the stream open when done. * @param in the String to copy from * @param charset the Charset * @param out the OutputStream to copy to * @throws IOException in case of I/O errors */ public static void copy(String in, Charset charset, OutputStream out) throws IOException { Assert.notNull(in, "No input String specified"); Assert.notNull(charset, "No charset specified"); Assert.notNull(out, "No OutputStream specified"); Writer writer = new OutputStreamWriter(out, charset); writer.write(in); writer.flush(); } /** * Copy the contents of the given InputStream to the given OutputStream. * Leaves both streams open when done. * @param in the InputStream to copy from * @param out the OutputStream to copy to * @return the number of bytes copied * @throws IOException in case of I/O errors */ public static int copy(InputStream in, OutputStream out) throws IOException { Assert.notNull(in, "No InputStream specified"); Assert.notNull(out, "No OutputStream specified"); int byteCount = 0; byte[] buffer = new byte[BUFFER_SIZE]; int bytesRead = -1; while ((bytesRead = in.read(buffer)) != -1) { out.write(buffer, 0, bytesRead); byteCount += bytesRead; } out.flush(); return byteCount; } /** * Copy a range of content of the given InputStream to the given OutputStream. *

If the specified range exceeds the length of the InputStream, this copies * up to the end of the stream and returns the actual number of copied bytes. *

Leaves both streams open when done. * @param in the InputStream to copy from * @param out the OutputStream to copy to * @param start the position to start copying from * @param end the position to end copying * @return the number of bytes copied * @throws IOException in case of I/O errors * @since 4.3 */ public static long copyRange(InputStream in, OutputStream out, long start, long end) throws IOException { Assert.notNull(in, "No InputStream specified"); Assert.notNull(out, "No OutputStream specified"); long skipped = in.skip(start); if (skipped < start) { throw new IOException("Skipped only " + skipped + " bytes out of " + start + " required"); } long bytesToCopy = end - start + 1; byte[] buffer = new byte[StreamUtils.BUFFER_SIZE]; while (bytesToCopy > 0) { int bytesRead = in.read(buffer); if (bytesRead == -1) { break; } else if (bytesRead <= bytesToCopy) { out.write(buffer, 0, bytesRead); bytesToCopy -= bytesRead; } else { out.write(buffer, 0, (int) bytesToCopy); bytesToCopy = 0; } } return (end - start + 1 - bytesToCopy); } /** * Drain the remaining content of the given InputStream. * Leaves the InputStream open when done. * @param in the InputStream to drain * @return the number of bytes read * @throws IOException in case of I/O errors * @since 4.3 */ public static int drain(InputStream in) throws IOException { Assert.notNull(in, "No InputStream specified"); byte[] buffer = new byte[BUFFER_SIZE]; int bytesRead = -1; int byteCount = 0; while ((bytesRead = in.read(buffer)) != -1) { byteCount += bytesRead; } return byteCount; } /** * Return an efficient empty {@link InputStream}. * @return a {@link ByteArrayInputStream} based on an empty byte array * @since 4.2.2 */ public static InputStream emptyInput() { return new ByteArrayInputStream(EMPTY_CONTENT); } /** * Return a variant of the given {@link InputStream} where calling * {@link InputStream#close() close()} has no effect. * @param in the InputStream to decorate * @return a version of the InputStream that ignores calls to close */ public static InputStream nonClosing(InputStream in) { Assert.notNull(in, "No InputStream specified"); return new NonClosingInputStream(in); } /** * Return a variant of the given {@link OutputStream} where calling * {@link OutputStream#close() close()} has no effect. * @param out the OutputStream to decorate * @return a version of the OutputStream that ignores calls to close */ public static OutputStream nonClosing(OutputStream out) { Assert.notNull(out, "No OutputStream specified"); return new NonClosingOutputStream(out); } private static class NonClosingInputStream extends FilterInputStream { public NonClosingInputStream(InputStream in) { super(in); } @Override public void close() throws IOException { } } private static class NonClosingOutputStream extends FilterOutputStream { public NonClosingOutputStream(OutputStream out) { super(out); } @Override public void write(byte[] b, int off, int let) throws IOException { // It is critical that we override this method for performance this.out.write(b, off, let); } @Override public void close() throws IOException { } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy