Java GZip壓縮詳解

一、GZip壓縮介紹

GZip是一種數據壓縮演算法，它使用Lempel-Ziv演算法(LZ77)和哈夫曼編碼來壓縮數據。它可以壓縮任何數據類型，但最適用於純文本文件，例如HTML、CSS和JavaScript文件。GZip使用DEFLATE演算法來實現數據壓縮和解壓縮。

在Java中，GZip壓縮功能由java.util.zip.GZIPOutputStream和java.util.zip.GZIPInputStream類提供。

二、GZip壓縮的優點

1、文件大小明顯縮小。對於大型文本文件（如日誌文件、XML文件等），GZip壓縮可以將文件大小縮小到原來的1/3或1/4。

2、網路傳輸效率提高。通過使用GZip壓縮，可以減少數據傳輸量，從而提高網路傳輸效率，特別是在低速網路或網路擁塞情況下。

3、更安全的數據傳輸。GZip壓縮可以提高數據的安全性，因為壓縮後的文件更難以解密。

三、使用GZip壓縮和解壓縮文件

GZip壓縮和解壓縮文件的方法如下：

import java.util.zip.*;
import java.io.*;

public class GZipDemo {

    public static void main(String[] args) {
        String fileToCompress = "example.txt";
        String compressedFile = "example.txt.gz";
        String decompressedFile = "exampleCopy.txt";

        compressFile(fileToCompress, compressedFile);
        decompressFile(compressedFile, decompressedFile);
    }

    public static void compressFile(String fileToCompress, String compressedFile) {
        try {
            FileInputStream fileInputStream = new FileInputStream(fileToCompress);
            FileOutputStream fileOutputStream = new FileOutputStream(compressedFile);
            GZIPOutputStream gzipOutputStream = new GZIPOutputStream(fileOutputStream);

            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = fileInputStream.read(buffer)) > 0) {
                gzipOutputStream.write(buffer, 0, bytesRead);
            }

            fileInputStream.close();

            gzipOutputStream.finish();
            gzipOutputStream.close();

            System.out.println("File " + fileToCompress + " has been compressed to " + compressedFile + ".");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public static void decompressFile(String compressedFile, String decompressedFile) {
        try {
            FileInputStream fileInputStream = new FileInputStream(compressedFile);
            GZIPInputStream gzipInputStream = new GZIPInputStream(fileInputStream);
            FileOutputStream fileOutputStream = new FileOutputStream(decompressedFile);

            byte[] buffer = new byte[1024];
            int bytesRead;

            while ((bytesRead = gzipInputStream.read(buffer)) > 0) {
                fileOutputStream.write(buffer, 0, bytesRead);
            }

            gzipInputStream.close();
            fileOutputStream.close();

            System.out.println("File " + compressedFile + " has been decompressed to " + decompressedFile + ".");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}

上述示例代碼演示了如何壓縮和解壓縮文件。首先，我們創建了一個包含要壓縮的文件的字元串，一個包含壓縮文件的字元串和一個包含解壓縮文件的字元串。然後，我們使用compressFile()方法壓縮原始文件，並使用decompressFile()方法解壓縮壓縮文件。

四、GZip壓縮HTTP響應

GZip壓縮可以通過HTTP傳輸減少響應大小，從而提高網路傳輸效率。可以使用Java Servlet API的GZipFilter類來輕鬆實現GZip壓縮HTTP響應。

以下是一個使用GZipFilter類進行HTTP響應壓縮的示例：

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
import javax.servlet.http.HttpServlet;

public class GZipServlet extends HttpServlet {

    static final String ENCODING_HEADER = "Content-Encoding";
    static final String ENCODING = "gzip";

    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        String acceptEncoding = request.getHeader("Accept-Encoding");
        if (acceptEncoding != null && acceptEncoding.indexOf(ENCODING) >= 0) {
            GZipServletResponseWrapper gzipResponse = new GZipServletResponseWrapper(response);
            gzipResponse.setCompressionThreshold(256);
            try {
                super.service(request, gzipResponse);
            } finally {
                gzipResponse.finishResponse();
            }
            return;
        }

        super.service(request, response);
    }

    private static class GZipServletResponseWrapper extends HttpServletResponseWrapper {

        protected HttpServletResponse response = null;
        protected GZipServletOutputStream gzipOutputStream = null;
        protected PrintWriter printWriter = null;
        protected int compressionThreshold = 0;

        public GZipServletResponseWrapper(HttpServletResponse response) throws IOException {
            super(response);
            this.response = response;
        }

        public void setCompressionThreshold(int compressionThreshold) {
            this.compressionThreshold = compressionThreshold;
        }

        private void finishResponse() throws IOException {
            if (this.printWriter != null) {
                this.printWriter.close();
            }
            if (this.gzipOutputStream != null) {
                this.gzipOutputStream.close();
            }
        }

        public void flushBuffer() throws IOException {
            if (this.printWriter != null) {
                this.printWriter.flush();
            }
            IOException exception1 = null;
            try {
                if (this.gzipOutputStream != null) {
                    this.gzipOutputStream.flush();
                }
            } catch (IOException ex) {
                exception1 = ex;
            }
            IOException exception2 = null;
            try {
                super.flushBuffer();
            } catch (IOException ex) {
                exception2 = ex;
            }
            if (exception1 != null) {
                throw exception1;
            }
            if (exception2 != null) {
                throw exception2;
            }
        }

        public ServletOutputStream getOutputStream() throws IOException {
            if (this.printWriter != null) {
                throw new IllegalStateException("PrintWriter obtained already - cannot get OutputStream");
            }
            if (this.gzipOutputStream == null) {
                this.gzipOutputStream = new GZipServletOutputStream(this.response.getOutputStream());
                this.response.addHeader(ENCODING_HEADER, ENCODING);
            }
            return this.gzipOutputStream;
        }

        public PrintWriter getWriter() throws IOException {
            if (this.printWriter == null && this.gzipOutputStream != null) {
                throw new IllegalStateException("OutputStream obtained already - cannot get PrintWriter");
            }
            if (this.printWriter == null) {
                this.gzipOutputStream = new GZipServletOutputStream(this.response.getOutputStream());
                this.response.addHeader(ENCODING_HEADER, ENCODING);
                this.printWriter = new PrintWriter(new OutputStreamWriter(this.gzipOutputStream, this.response.getCharacterEncoding()));
            }
            return this.printWriter;
        }
    }

    private static class GZipServletOutputStream extends ServletOutputStream {

        protected OutputStream outputStream = null;

        public GZipServletOutputStream(OutputStream outputStream) throws IOException {
            super();
            this.outputStream = outputStream;
        }

        public void close() throws IOException {
            this.outputStream.close();
            super.close();
        }

        public void flush() throws IOException {
            this.outputStream.flush();
        }

        public void write(byte[] b) throws IOException {
            this.outputStream.write(b);
        }

        public void write(byte[] b, int off, int len) throws IOException {
            this.outputStream.write(b, off, len);
        }

        public void write(int b) throws IOException {
            this.outputStream.write(b);
        }
    }
}

上述示例代碼演示了如何使用GZipFilter類將HTTP響應壓縮並發送給客戶端。在GZipServlet中，我們首先檢查瀏覽器是否支持GZip壓縮，如果支持，我們將響應包裝在一個GZipServletResponseWrapper中，然後使用GZipServletOutputStream類將響應壓縮。最後，我們在響應頭中添加Content-Encoding：gzip標頭，並發送響應。