Compression is performed using {@link CompressorFactory}, which returns a corresponding + *
Compression is performed using {@link CompressingFactory}, which returns a corresponding * {@link OutputStream} for the requested compression type. This class does not support * reading the content directly through {@link #getContent()} as the content is always compressed * during write operations.
@@ -108,20 +108,17 @@ public class CompressingEntity extends HttpEntityWrapper { @Override public void writeTo(final OutputStream outStream) throws IOException { Args.notNull(outStream, "Output stream"); - // Get the compressor based on the specified content encoding - final OutputStream compressorStream; - try { - compressorStream = CompressorFactory.INSTANCE.getCompressorOutputStream(contentEncoding, outStream); + + try (final OutputStream compressorStream = CompressingFactory.INSTANCE.getCompressorOutputStream(contentEncoding, outStream)) { + if (compressorStream != null) { + // Write compressed data + super.writeTo(compressorStream); + } else { + throw new UnsupportedOperationException("Unsupported compression: " + contentEncoding); + } } catch (final CompressorException e) { - throw new IOException("Error initializing decompression stream", e); - } - if (compressorStream != null) { - // Write compressed data - super.writeTo(compressorStream); - // Close the compressor stream after writing - compressorStream.close(); - } else { - throw new UnsupportedOperationException("Unsupported compression: " + contentEncoding); + throw new IOException("Error initializing compression stream", e); } } + } diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/entity/CompressorFactory.java b/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/CompressingFactory.java similarity index 60% rename from httpclient5/src/main/java/org/apache/hc/client5/http/entity/CompressorFactory.java rename to httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/CompressingFactory.java index 93f187281..d9d2a4ada 100644 --- a/httpclient5/src/main/java/org/apache/hc/client5/http/entity/CompressorFactory.java +++ b/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/CompressingFactory.java @@ -25,7 +25,7 @@ * */ -package org.apache.hc.client5.http.entity; +package org.apache.hc.client5.http.entity.compress; import java.io.InputStream; import java.io.OutputStream; @@ -42,8 +42,6 @@ import org.apache.commons.compress.compressors.deflate.DeflateCompressorInputStr import org.apache.commons.compress.compressors.deflate.DeflateParameters; import org.apache.hc.core5.http.HttpEntity; import org.apache.hc.core5.util.Args; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; /** * A factory class for managing compression and decompression of HTTP entities using different compression formats. @@ -64,13 +62,12 @@ import org.slf4j.LoggerFactory; * * @since 5.5 */ -public class CompressorFactory { +public class CompressingFactory { - private static final Logger LOG = LoggerFactory.getLogger(CompressorFactory.class); /** * Singleton instance of the factory. */ - public static final CompressorFactory INSTANCE = new CompressorFactory(); + public static final CompressingFactory INSTANCE = new CompressingFactory(); private final CompressorStreamFactory compressorStreamFactory = new CompressorStreamFactory(); private final AtomicReference- * If the provided name matches an alias (e.g., "gzip" or "x-gzip"), the method will return the standard name. + * If the provided name matches a known alias (e.g., "gzip" or "x-gzip"), + * the method returns the corresponding standard key (e.g., "gz"). + * If no match is found, it returns the original name as-is. *
* - * @param name the compression format name. - * @return the formatted name, or the original name if no alias is found. + * @param name the compression format name or alias. + * @return the corresponding standard key or the original name if no alias is found. * @throws IllegalArgumentException if the name is null or empty. */ public String getFormattedName(final String name) { - if (name == null || name.isEmpty()) { - LOG.warn("Compression name is null or empty"); - return null; - } + Args.notEmpty(name, "name"); final String lowerCaseName = name.toLowerCase(Locale.ROOT); return formattedNameCache.computeIfAbsent(lowerCaseName, key -> { if ("gzip".equals(key) || "x-gzip".equals(key)) { @@ -122,32 +134,36 @@ public class CompressorFactory { } /** - * Creates an input stream for the specified compression format and decompresses the provided input stream. + * Creates a decompressor input stream for the specified format type and decompresses the provided input stream. *- * This method uses the specified compression name to decompress the input stream and supports the "noWrap" option - * for deflate streams. + * If the format type is supported, this method returns a new input stream that decompresses data from the original input stream. + * For "deflate" format, the "noWrap" option controls the inclusion of zlib headers: + * - If {@code noWrap} is {@code true}, zlib headers and trailers are omitted, resulting in raw deflate data. + * - If {@code noWrap} is {@code false}, the deflate stream includes standard zlib headers. *
* - * @param name the compression format. - * @param inputStream the input stream to decompress. - * @param noWrap if true, disables the zlib header and trailer for deflate streams. - * @return the decompressed input stream, or the original input stream if the format is not supported. + * @param name the format type to use for decompression. + * @param inputStream the input stream to be decompressed. + * @param noWrap whether to exclude zlib headers and trailers for deflate streams (applicable to "deflate" only). + * @return a decompressed input stream if the format type is supported; otherwise, the original input stream. + * @throws CompressorException if an error occurs while creating the decompressor input stream. */ - public InputStream getCompressorInputStream(final String name, final InputStream inputStream, final boolean noWrap) throws CompressorException { + public InputStream getDecompressorInputStream(final String name, final InputStream inputStream, final boolean noWrap) throws CompressorException { Args.notNull(inputStream, "InputStream"); Args.notNull(name, "name"); final String formattedName = getFormattedName(name); return isSupported(formattedName, false) - ? createCompressorInputStream(formattedName, inputStream, noWrap) + ? createDecompressorInputStream(formattedName, inputStream, noWrap) : inputStream; } /** - * Creates an output stream for the specified compression format and compresses the provided output stream. + * Creates an output stream to compress the provided output stream based on the specified format type. * - * @param name the compression format. + * @param name the format type. * @param outputStream the output stream to compress. * @return the compressed output stream, or the original output stream if the format is not supported. + * @throws CompressorException if an error occurs while creating the compressor output stream. */ public OutputStream getCompressorOutputStream(final String name, final OutputStream outputStream) throws CompressorException { final String formattedName = getFormattedName(name); @@ -157,11 +173,11 @@ public class CompressorFactory { } /** - * Decompresses the provided HTTP entity using the specified compression format. + * Decompresses the provided HTTP entity based on the specified format type. * * @param entity the HTTP entity to decompress. - * @param contentEncoding the compression format. - * @return a decompressed {@link HttpEntity}, or {@code null} if the compression format is unsupported. + * @param contentEncoding the format type. + * @return a decompressed {@link HttpEntity}, or {@code null} if the format type is unsupported. */ public HttpEntity decompressEntity(final HttpEntity entity, final String contentEncoding) { return decompressEntity(entity, contentEncoding, false); @@ -179,69 +195,43 @@ public class CompressorFactory { Args.notNull(entity, "Entity"); Args.notNull(contentEncoding, "Content Encoding"); if (!isSupported(contentEncoding, false)) { - LOG.warn("Unsupported decompression type: {}", contentEncoding); return null; } - return new DecompressEntity(entity, contentEncoding, noWrap); + return new DecompressingEntity(entity, contentEncoding, noWrap); } /** - * Compresses the provided HTTP entity using the specified compression format. + * Compresses the provided HTTP entity based on the specified format type. * * @param entity the HTTP entity to compress. - * @param contentEncoding the compression format. - * @return a compressed {@link HttpEntity}, or {@code null} if the compression format is unsupported. + * @param contentEncoding the format type. + * @return a compressed {@link HttpEntity}, or {@code null} if the format type is unsupported. */ public HttpEntity compressEntity(final HttpEntity entity, final String contentEncoding) { Args.notNull(entity, "Entity"); Args.notNull(contentEncoding, "Content Encoding"); if (!isSupported(contentEncoding, true)) { - LOG.warn("Unsupported compression type: {}", contentEncoding); return null; } return new CompressingEntity(entity, contentEncoding); } /** - * Fetches the available input stream compression providers from Commons Compress. - * - * @return a set of available input stream compression providers in lowercase. - */ - private Set- * This method handles the special case for deflate compression where the zlib header can be optionally included. - * The noWrap parameter directly controls the behavior of the zlib header: - * - If noWrap is {@code true}, the deflate stream is processed without zlib headers (raw Deflate). - * - If noWrap is {@code false}, the deflate stream includes the zlib header. + * If the format type is supported, this method returns an input stream that decompresses the original input data. + * For "deflate" format, the `noWrap` parameter determines whether the stream should include standard zlib headers: + * - If {@code noWrap} is {@code true}, the stream is created without zlib headers (raw deflate). + * - If {@code noWrap} is {@code false}, zlib headers are included. *
* - * @param name the compression format (e.g., "gzip", "deflate"). - * @param inputStream the input stream to decompress; must not be {@code null}. - * @param noWrap if {@code true}, disables the zlib header and trailer for deflate streams (raw Deflate). - * @return a decompressed input stream, or {@code null} if an error occurs during stream creation. - * @throws CompressorException if an error occurs while creating the compressor input stream or if the compression format is unsupported. + * @param name the format type (e.g., "gzip", "deflate") for decompression. + * @param inputStream the input stream containing compressed data; must not be {@code null}. + * @param noWrap only applicable to "deflate" format. If {@code true}, omits zlib headers for a raw deflate stream. + * @return a decompressed input stream for the specified format, or throws an exception if the format is unsupported. + * @throws CompressorException if an error occurs while creating the decompressor stream or if the format type is unsupported. */ - private InputStream createCompressorInputStream(final String name, final InputStream inputStream, final boolean noWrap) throws CompressorException { + private InputStream createDecompressorInputStream(final String name, final InputStream inputStream, final boolean noWrap) throws CompressorException { if ("deflate".equalsIgnoreCase(name)) { final DeflateParameters parameters = new DeflateParameters(); parameters.setWithZlibHeader(noWrap); @@ -251,9 +241,9 @@ public class CompressorFactory { } /** - * Creates a compressor output stream for the given compression format and output stream. + * Creates a compressor output stream for the given format type and output stream. * - * @param name the compression format. + * @param name the format type. * @param outputStream the output stream to compress. * @return a compressed output stream, or null if an error occurs. * @throws CompressorException if an error occurs while creating the compressor output stream. @@ -263,11 +253,11 @@ public class CompressorFactory { } /** - * Determines if the specified compression format is supported for either input or output streams. + * Determines if the specified format type is supported for either input (decompression) or output (compression) streams. * - * @param name the compression format. - * @param isOutput if true, checks if the format is supported for output; otherwise, checks for input support. - * @return true if the format is supported, false otherwise. + * @param name the format type. + * @param isOutput if true, checks if the format type is supported for output; otherwise, checks for input support. + * @return true if the format type is supported, false otherwise. */ private boolean isSupported(final String name, final boolean isOutput) { final SetDecompression is performed using a {@link LazyDecompressInputStream} that + *
Decompression is performed using a {@link LazyDecompressingInputStream} that * applies decompression lazily when content is requested.
* *
@@ -54,7 +54,7 @@ import org.apache.hc.core5.util.Args;
* @since 5.5
*/
@Contract(threading = ThreadingBehavior.UNSAFE)
-public class DecompressEntity extends HttpEntityWrapper {
+public class DecompressingEntity extends HttpEntityWrapper {
/**
* The content input stream, initialized lazily during the first read.
@@ -72,25 +72,25 @@ public class DecompressEntity extends HttpEntityWrapper {
private final boolean noWrap;
/**
- * Constructs a new {@link DecompressEntity} with the specified compression type and noWrap setting.
+ * Constructs a new {@link DecompressingEntity} with the specified compression type and noWrap setting.
*
* @param wrapped the non-null {@link HttpEntity} to be wrapped.
* @param compressionType the compression type (e.g., "gzip", "deflate").
* @param noWrap whether to decompress without headers for certain compression formats.
*/
- public DecompressEntity(final HttpEntity wrapped, final String compressionType, final boolean noWrap) {
+ public DecompressingEntity(final HttpEntity wrapped, final String compressionType, final boolean noWrap) {
super(wrapped);
this.compressionType = compressionType;
this.noWrap = noWrap;
}
/**
- * Constructs a new {@link DecompressEntity} with the specified compression type, defaulting to no noWrap handling.
+ * Constructs a new {@link DecompressingEntity} with the specified compression type, defaulting to no noWrap handling.
*
* @param wrapped the non-null {@link HttpEntity} to be wrapped.
* @param compressionType the compression type (e.g., "gzip", "deflate").
*/
- public DecompressEntity(final HttpEntity wrapped, final String compressionType) {
+ public DecompressingEntity(final HttpEntity wrapped, final String compressionType) {
this(wrapped, compressionType, false);
}
@@ -102,7 +102,7 @@ public class DecompressEntity extends HttpEntityWrapper {
* @throws IOException if an error occurs during decompression.
*/
private InputStream getDecompressingStream() throws IOException {
- return new LazyDecompressInputStream(super.getContent(), compressionType, noWrap);
+ return new LazyDecompressingInputStream(super.getContent(), compressionType, noWrap);
}
/**
diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/entity/LazyDecompressInputStream.java b/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/LazyDecompressingInputStream.java
similarity index 90%
rename from httpclient5/src/main/java/org/apache/hc/client5/http/entity/LazyDecompressInputStream.java
rename to httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/LazyDecompressingInputStream.java
index cc0262902..cd4ac8271 100644
--- a/httpclient5/src/main/java/org/apache/hc/client5/http/entity/LazyDecompressInputStream.java
+++ b/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/LazyDecompressingInputStream.java
@@ -24,7 +24,7 @@
*
This implementation delays the creation of the decompression stream until it is required, optimizing
@@ -44,7 +44,7 @@ import org.apache.hc.core5.io.Closer;
*
* @since 5.5
*/
-public class LazyDecompressInputStream extends FilterInputStream {
+public class LazyDecompressingInputStream extends FilterInputStream {
/**
* The lazily initialized decompression stream.
@@ -62,26 +62,26 @@ public class LazyDecompressInputStream extends FilterInputStream {
private final boolean noWrap;
/**
- * Constructs a new {@link LazyDecompressInputStream} that applies the specified compression type and noWrap setting.
+ * Constructs a new {@link LazyDecompressingInputStream} that applies the specified compression type and noWrap setting.
*
* @param wrappedStream the non-null {@link InputStream} to be wrapped and decompressed.
* @param compressionType the compression type (e.g., "gzip", "deflate").
* @param noWrap whether to decompress without headers for certain compression formats.
*/
- public LazyDecompressInputStream(final InputStream wrappedStream, final String compressionType, final boolean noWrap) {
+ public LazyDecompressingInputStream(final InputStream wrappedStream, final String compressionType, final boolean noWrap) {
super(wrappedStream);
this.compressionType = compressionType;
this.noWrap = noWrap;
}
/**
- * Constructs a new {@link LazyDecompressInputStream} that applies the specified compression type,
+ * Constructs a new {@link LazyDecompressingInputStream} that applies the specified compression type,
* defaulting to no noWrap handling.
*
* @param wrappedStream the non-null {@link InputStream} to be wrapped and decompressed.
* @param compressionType the compression type (e.g., "gzip", "deflate").
*/
- public LazyDecompressInputStream(final InputStream wrappedStream, final String compressionType) {
+ public LazyDecompressingInputStream(final InputStream wrappedStream, final String compressionType) {
this(wrappedStream, compressionType, false);
}
@@ -94,7 +94,7 @@ public class LazyDecompressInputStream extends FilterInputStream {
private InputStream initWrapper() throws IOException {
if (wrapperStream == null) {
try {
- wrapperStream = CompressorFactory.INSTANCE.getCompressorInputStream(compressionType, in, noWrap);
+ wrapperStream = CompressingFactory.INSTANCE.getDecompressorInputStream(compressionType, in, noWrap);
} catch (final CompressorException e) {
throw new IOException("Error initializing decompression stream", e);
}
diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/package-info.java b/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/package-info.java
new file mode 100644
index 000000000..2807ef39a
--- /dev/null
+++ b/httpclient5/src/main/java/org/apache/hc/client5/http/entity/compress/package-info.java
@@ -0,0 +1,46 @@
+/*
+ * ====================================================================
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation. For more
+ * information on the Apache Software Foundation, please see
+ *
This package contains classes for handling compression and decompression of HTTP entities + * using various algorithms, such as GZIP and Deflate. It includes classes for compressing and + * decompressing HTTP entity content, as well as utilities to handle lazy decompression of input streams. + * + *
These classes use the Apache Commons Compress library to support multiple compression formats.
+ * + * @since 5.5 + */ +package org.apache.hc.client5.http.entity.compress; diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/ContentCompressionExec.java b/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/ContentCompressionExec.java index 7de31ac67..cb9766886 100644 --- a/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/ContentCompressionExec.java +++ b/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/ContentCompressionExec.java @@ -36,8 +36,8 @@ import java.util.zip.GZIPInputStream; import org.apache.hc.client5.http.classic.ExecChain; import org.apache.hc.client5.http.classic.ExecChainHandler; import org.apache.hc.client5.http.config.RequestConfig; -import org.apache.hc.client5.http.entity.CompressorFactory; -import org.apache.hc.client5.http.entity.DecompressEntity; +import org.apache.hc.client5.http.entity.compress.CompressingFactory; +import org.apache.hc.client5.http.entity.compress.DecompressingEntity; import org.apache.hc.client5.http.entity.DeflateInputStream; import org.apache.hc.client5.http.protocol.HttpClientContext; import org.apache.hc.core5.annotation.Contract; @@ -83,11 +83,11 @@ public final class ContentCompressionExec implements ExecChainHandler { if (acceptEncoding != null) { this.normalizedEncodings = acceptEncoding.stream() - .map(CompressorFactory.INSTANCE::getFormattedName) - .filter(CompressorFactory.INSTANCE.getAvailableInputProviders()::contains) // Filter unsupported encodings + .map(CompressingFactory.INSTANCE::getFormattedName) + .filter(CompressingFactory.INSTANCE.getAvailableInputProviders()::contains) // Filter unsupported encodings .collect(Collectors.toList()); } else { - this.normalizedEncodings = new ArrayList<>(CompressorFactory.INSTANCE.getAvailableInputProviders()); + this.normalizedEncodings = new ArrayList<>(CompressingFactory.INSTANCE.getAvailableInputProviders()); } // Set the 'Accept-Encoding' header @@ -149,9 +149,9 @@ public final class ContentCompressionExec implements ExecChainHandler { final ParserCursor cursor = new ParserCursor(0, contentEncoding.length()); final HeaderElement[] codecs = BasicHeaderValueParser.INSTANCE.parseElements(contentEncoding, cursor); for (final HeaderElement codec : codecs) { - final String codecname = CompressorFactory.INSTANCE.getFormattedName(codec.getName()); + final String codecname = CompressingFactory.INSTANCE.getFormattedName(codec.getName()); if (normalizedEncodings.contains(codecname)) { - response.setEntity(new DecompressEntity(response.getEntity(), codecname, noWrap)); + response.setEntity(new DecompressingEntity(response.getEntity(), codecname, noWrap)); response.removeHeaders(HttpHeaders.CONTENT_LENGTH); response.removeHeaders(HttpHeaders.CONTENT_ENCODING); response.removeHeaders(HttpHeaders.CONTENT_MD5); diff --git a/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/HttpClientBuilder.java b/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/HttpClientBuilder.java index b32756543..d94cfe26b 100644 --- a/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/HttpClientBuilder.java +++ b/httpclient5/src/main/java/org/apache/hc/client5/http/impl/classic/HttpClientBuilder.java @@ -727,7 +727,7 @@ public class HttpClientBuilder { * * @param encodings a list of encoding names to support for automatic content compression and decompression * @return this {@code HttpClientBuilder} instance for method chaining - * @since 5.0 + * @since 5.5 */ public final HttpClientBuilder setEncodings(final List