SpringBoot 压缩数据流如何解压

0x01：HTTP压缩数据传输简介

通过请求和响应头中增加

Accept-Encoding: gzip
Content-Encodin:gzip

确定客户端或服务器端是否支持压缩

举例，客户端发送请求，服务端压缩响应数据返给客户端

• 客户端请求中增加 Accept-Encoding: gzip 表示客户端支持gzip；

• 服务端接收到请求后，将结果通过 gzip 压缩后返回给客户端并在响应头中增加 Content-Encoding: gzip 表示响应数据已被压缩

• 客户端接收请求，响应头中有 Content-Encoding: gzip 表示数据需解压处理

客户端也可以发送压缩数据给服务端，通过代码将请求数据压缩即可，规范起见同样要在请求中加入 Content-Encoding: gzip

0x02：SpringBoot 案例

pom.xml 引入如下依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.iothw</groupId>
    <artifactId>gzip-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>gzip-demo</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <spring-cloud.version>Finchley.SR2</spring-cloud.version>
        <mybatis.version>1.3.0</mybatis.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
        </dependency>

    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-parent</artifactId>
                <version>2.3.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>aliyunmaven</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
    </repositories>
</project>

编写Gzip解压过滤器

package com.iothw.gzip.filter;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ReadListener;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;

import lombok.extern.slf4j.Slf4j;

/**
 * GZIP处理Filter
 */
@WebFilter(filterName = "gzipFilter", urlPatterns = "/")
public class GzipFilter implements Filter {

    @Override
    public void destroy() {
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        chain.doFilter(new HttpServletRequestWrapper((HttpServletRequest) request), response);
    }

    @Override
    public void init(FilterConfig arg0) throws ServletException {
    }
}

@Slf4j
class HttpServletRequestWrapper extends javax.servlet.http.HttpServletRequestWrapper {
    private HttpServletRequest request;

    public HttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        this.request = request;
    }

    /**
     * 根据 request header 的 Content-Encoding 判断是否启用 gzip 解压数据流
     */
    @Override
    public ServletInputStream getInputStream() throws IOException {
        ServletInputStream stream = request.getInputStream();
        String contentEncoding = request.getHeader("Content-Encoding");
        if (null != contentEncoding && contentEncoding.indexOf("gzip") != -1) {
            GZIPInputStream gzipInputStream = new GZIPInputStream(stream);
            try {
                ByteArrayOutputStream bout = new ByteArrayOutputStream();
                int len = -1;
                byte[] buffer = new byte[128];
                while((len = gzipInputStream.read(buffer))!=-1){
                    bout.write(buffer, 0, len);
                }
                ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
                ServletInputStream newStream = new ServletInputStream() {
                    @Override
                    public int read() throws IOException {
                        return bin.read();
                    }

                    @Override
                    public boolean isFinished() {
                        return false;
                    }

                    @Override
                    public boolean isReady() {
                        return false;
                    }

                    @Override
                    public void setReadListener(ReadListener readListener) {
                    }
                };
                return newStream;
            } catch (Exception e) {
                log.error("uncompress content fail", e);
            }finally{
                try {
                    gzipInputStream.close();
                } catch (Exception e) {
                }
            }
        }

        return stream;
    }
}

注册过滤器

package com.iothw.gzip.config;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.Filter;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.iothw.gzip.filter.GzipFilter;

@Configuration
public class FilterConfig {
    /**
     * 注册 HttpServletFilter
     *
     * @return
     */
    @Bean
    public FilterRegistrationBean<Filter> filterRegistrationBean() {
        FilterRegistrationBean<Filter> registrationBean = new FilterRegistrationBean<Filter>();
        registrationBean.setFilter(new GzipFilter());

        List<String> urlPatterns = new ArrayList<>();
        urlPatterns.add("/*");
        registrationBean.setUrlPatterns(urlPatterns);

        return registrationBean;
    }
}

编写SpringBoot引导类

package com.iothw.gzip;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class Application {
    public static void main( String[] args ){
        SpringApplication.run(Application.class, args);
    }
}

0x03：测试验证

• okhttp

引入依赖

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>4.4.1</version>
</dependency>

测试类

package com.test;

import java.io.IOException;

import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okio.BufferedSink;
import okio.GzipSink;
import okio.Okio;

public class OkHttpGzipTest {

    public void processPost() {
        String url = "http://localhost:8080/gzip/gzipTest";
        String str = "我是要被压缩上传的数据，看好了我是压缩的数据";
        try {
            String response = post(url, str);
            System.out.println(response);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String post(String url, String json) throws IOException {
        OkHttpClient client = new OkHttpClient.Builder()
                // 通过GzipRequestInterceptor类拦截响应，自动处理gzip解压
                .addInterceptor(new GzipRequestInterceptor())
                .build();
        MediaType JSON = MediaType.get("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(json, JSON);
        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .build();
        try (Response response = client.newCall(request).execute()) {
            return response.body().string();
        }
    }

    class GzipRequestInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request originalRequest = chain.request();
            if (originalRequest.body() == null || originalRequest.header("Content-Encoding") != null) {
                return chain.proceed(originalRequest);
            }

            Request compressedRequest = originalRequest.newBuilder()
                    .header("Content-Encoding", "gzip")
                    .method(originalRequest.method(), gzip(originalRequest.body()))
                    .build();
            return chain.proceed(compressedRequest);
        }

        private RequestBody gzip(final RequestBody body) {
            return new RequestBody() {
                @Override
                public MediaType contentType() {
                    return body.contentType();
                }

                @Override
                public long contentLength() {
                    // We don't know the compressed length in advance!
                    return -1;
                }

                @Override
                public void writeTo(BufferedSink sink) throws IOException {
                    BufferedSink gzipSink = Okio.buffer(new GzipSink(sink));
                    body.writeTo(gzipSink);
                    gzipSink.close();
                }
            };
        }
    }

    public static void main(String[] args) {
        OkHttpGzipTest gt = new OkHttpGzipTest();
        gt.processPost();
    }
}

• httpclient
  

引入依赖

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.10</version>
</dependency>

测试类

package com.test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.zip.GZIPOutputStream;

import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

public class HttpClientGzipTest {

    /**
     * gzip 压缩发送
     */
    public void sendHttp(String url, String message) throws ClientProtocolException, IOException {
        HttpClient httpClient = new DefaultHttpClient();
        HttpPost httpPost = new HttpPost(url);
        httpPost.setHeader("Content-Encoding", "gzip");
        try {
            ByteArrayOutputStream originalContent = new ByteArrayOutputStream();
            originalContent.write(message.getBytes(Charset.forName("UTF-8")));
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            GZIPOutputStream gzipOut = new GZIPOutputStream(baos);
            originalContent.writeTo(gzipOut);
            gzipOut.finish();
            httpPost.setEntity(new ByteArrayEntity(baos.toByteArray()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        HttpResponse httpResponse = httpClient.execute(httpPost);
        if (httpResponse.getStatusLine().getStatusCode() == 200) {
            System.out.println(EntityUtils.toString(httpResponse.getEntity()));
        }
    }

    public static void main(String[] args) {
        HttpClientGzipTest ht = new HttpClientGzipTest();

        String url = "http://localhost:8080/gzip/gzipTest";
        String message = "我是要被压缩上传的数据，看好了我是压缩的数据";

        try {
            ht.sendHttp(url, message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

喜欢，在看