蜜臀tv,特黄视频,色爱区综合

tomcat下關于壓縮過濾器的代碼。具體路徑為：C:\apache-tomcat-6.0.35\webapps\examples\WEB-INF\classes\compressionFilters。代碼為：

package compressionFilters;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;


public class CompressionResponseStream extends ServletOutputStream {

//是否啟用壓縮的臨界值
protected int compressThreshold = 0;

//臨時容納寫入的數據緩沖區
protected byte[] buffer = null;

//緩沖區實際寫入的數據量
protected int bufferCount = 0;

protected GZIPOutputStream gzipstream = null;

//當前流對象是否處于關閉狀態
protected boolean closed = false;

protected int length = -1;

//用于返回數據的 Response對象
protected HttpServletResponse response = null;

protected ServletOutputStream output = null;



public CompressionResponseStream(HttpServletResponse response) throws IOException{
   super();
   closed = false;
   this.response = response;
   this.output = response.getOutputStream();
}

//設置啟用壓縮的臨界值，并初始化輸出緩沖區
public void setBuffer(int threshold){
   compressThreshold = threshold;
   buffer = new byte[threshold];
}

/**
* 關閉流對象
*/
public void close() throws IOException{
   if(closed){
    throw new IOException("This output stream has already been closed");
   }
  
   //如果當前啟用的是壓縮流，用壓縮流刷新緩沖區
   if(gzipstream != null){
    flushToGZip();
    gzipstream.close();
    gzipstream = null;
   }else{
    //如果未開啟壓縮，則用response的默認輸出流刷新緩沖區
    if(bufferCount > 0){
     output.write(buffer, 0, bufferCount);
     bufferCount = 0;
    }
   }
}

/**
* 刷新輸出緩沖區
*/
public void flush() throws IOException{
   if(closed){
    throw new IOException("Cannot flush a closed output stream");
   }
   if(gzipstream != null){
    gzipstream.flush();
   }
}

public void write(int b) throws IOException {
  
   if(closed){
    throw new IOException("Cannot write to a closed output stream");
   }
  
   //如果數據超出了緩沖區(啟用壓縮的臨界值)，則啟用壓縮模式
   if(bufferCount >= buffer.length){
    flushToGZip();
   }
   //如果沒有超出緩沖區，則將數據寫入緩沖區
   buffer[bufferCount++] = (byte)b;
  
}

public void write(byte[] b,int off,int len) throws IOException{
   if(closed){
    throw new IOException("Cannot write to a closed output stream");
   }
  
   if(len == 0){
    return;
   }
   //如果緩沖區能容納這些數據則寫入緩沖區
   if(len <= buffer.length - bufferCount){
    System.arraycopy(b, off, buffer, bufferCount, len);
    bufferCount += len;
    return;
   }
  
   //如果緩沖區剩余空間不住足，則開啟壓縮流對象
   flushToGZip();
  
   //如果清空后的緩沖區能夠容納傳送過來的數據，則將數據寫入緩沖區
   if(len <= buffer.length - bufferCount){
    System.arraycopy(b, off, buffer, bufferCount, len);
    bufferCount += len;
    return;
   }
  
   //如果緩沖區不能容納傳送進來的數據，則直接將數據寫入壓縮流對象
   writeToGZip(b, off, len);
}


//刷新壓縮流對象的緩沖區
public void flushToGZip() throws IOException{
   if(bufferCount > 0){
    writeToGZip(buffer, 0, bufferCount);
    bufferCount = 0;
   }
}

public void writeToGZip(byte b[],int off,int len)throws IOException{
  
   //如果壓縮流對象為空，這里初始化它
   if(gzipstream == null){
    response.addHeader("Content-Encoding", "gzip");
    gzipstream = new GZIPOutputStream(output);
   }
  
   //將數據聽過壓縮流對象輸出到response的輸出流
   gzipstream.write(b,off,len);
}



public boolean closed(){
   return closed;
}

}

package compressionFilters;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;


public class CompressionResponseStream extends ServletOutputStream {

//是否啟用壓縮的臨界值
protected int compressThreshold = 0;

//臨時容納寫入的數據緩沖區
protected byte[] buffer = null;

//緩沖區實際寫入的數據量
protected int bufferCount = 0;

protected GZIPOutputStream gzipstream = null;

//當前流對象是否處于關閉狀態
protected boolean closed = false;

protected int length = -1;

//用于返回數據的 Response對象
protected HttpServletResponse response = null;

protected ServletOutputStream output = null;



public CompressionResponseStream(HttpServletResponse response) throws IOException{
   super();
   closed = false;
   this.response = response;
   this.output = response.getOutputStream();
}

//設置啟用壓縮的臨界值，并初始化輸出緩沖區
public void setBuffer(int threshold){
   compressThreshold = threshold;
   buffer = new byte[threshold];
}

/**
* 關閉流對象
*/
public void close() throws IOException{
   if(closed){
    throw new IOException("This output stream has already been closed");
   }
  
   //如果當前啟用的是壓縮流，用壓縮流刷新緩沖區
   if(gzipstream != null){
    flushToGZip();
    gzipstream.close();
    gzipstream = null;
   }else{
    //如果未開啟壓縮，則用response的默認輸出流刷新緩沖區
    if(bufferCount > 0){
     output.write(buffer, 0, bufferCount);
     bufferCount = 0;
    }
   }
}

/**
* 刷新輸出緩沖區
*/
public void flush() throws IOException{
   if(closed){
    throw new IOException("Cannot flush a closed output stream");
   }
   if(gzipstream != null){
    gzipstream.flush();
   }
}

public void write(int b) throws IOException {
  
   if(closed){
    throw new IOException("Cannot write to a closed output stream");
   }
  
   //如果數據超出了緩沖區(啟用壓縮的臨界值)，則啟用壓縮模式
   if(bufferCount >= buffer.length){
    flushToGZip();
   }
   //如果沒有超出緩沖區，則將數據寫入緩沖區
   buffer[bufferCount++] = (byte)b;
  
}

public void write(byte[] b,int off,int len) throws IOException{
   if(closed){
    throw new IOException("Cannot write to a closed output stream");
   }
  
   if(len == 0){
    return;
   }
   //如果緩沖區能容納這些數據則寫入緩沖區
   if(len <= buffer.length - bufferCount){
    System.arraycopy(b, off, buffer, bufferCount, len);
    bufferCount += len;
    return;
   }
  
   //如果緩沖區剩余空間不住足，則開啟壓縮流對象
   flushToGZip();
  
   //如果清空后的緩沖區能夠容納傳送過來的數據，則將數據寫入緩沖區
   if(len <= buffer.length - bufferCount){
    System.arraycopy(b, off, buffer, bufferCount, len);
    bufferCount += len;
    return;
   }
  
   //如果緩沖區不能容納傳送進來的數據，則直接將數據寫入壓縮流對象
   writeToGZip(b, off, len);
}


//刷新壓縮流對象的緩沖區
public void flushToGZip() throws IOException{
   if(bufferCount > 0){
    writeToGZip(buffer, 0, bufferCount);
    bufferCount = 0;
   }
}

public void writeToGZip(byte b[],int off,int len)throws IOException{
  
   //如果壓縮流對象為空，這里初始化它
   if(gzipstream == null){
    response.addHeader("Content-Encoding", "gzip");
    gzipstream = new GZIPOutputStream(output);
   }
  
   //將數據聽過壓縮流對象輸出到response的輸出流
   gzipstream.write(b,off,len);
}



public boolean closed(){
   return closed;
}

}

package compressionFilters;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

public class CompressionServletResponseWrapper extends
   HttpServletResponseWrapper {

/**
* 原始的response對象
*/
protected HttpServletResponse origResponse = null;

protected static final String info = "CompressionServletResponseWrapper";

/**
* response對象的輸出流
*/
protected ServletOutputStream stream = null;

/**
* response
*/
protected PrintWriter writer = null;

protected int threshold = 0;

protected String contentType = null;

public CompressionServletResponseWrapper(HttpServletResponse response) {
   super(response);
   origResponse = response;
}

/**
* 設置實體類型
*/
public void setContentType(String contentType){
   this.contentType = contentType;
   origResponse.setContentType(contentType);  
}

/**
* 設置啟用壓縮的臨界值
* @param threshold 臨界值
*/
public void setCompressionThreshold(int threshold){
   this.threshold = threshold;
}


public ServletOutputStream createOutputStream() throws IOException{
   CompressionResponseStream stream = new CompressionResponseStream(origResponse);
   stream.setBuffer(threshold);
   return stream;
}

//關閉輸出對象
public void finishResponse(){
   try {
    if(writer != null){
     writer.close();
    }else{
     if(stream != null){
      stream.close();
     }
    }
   } catch (IOException e) {

   }
}

public void flushBuffer() throws IOException{
   ((CompressionResponseStream)stream).flush();
}

public ServletOutputStream getOutputStream() throws IOException{
  
   //如果字符流打開，則拋出異常
   if(writer != null)
    throw new IllegalStateException("getWriter() has already been called for this response");
  
   if(stream == null) stream = createOutputStream();
   return stream;
}

public PrintWriter getWriter() throws IOException{
   if(writer != null){
    return (writer);
   }
   if(stream != null)
    throw new IllegalStateException("getOutputStream() has already been called for this response");
  
   stream = createOutputStream();
   String charEnc = origResponse.getCharacterEncoding();
   if(charEnc != null){
    writer = new PrintWriter(new OutputStreamWriter(stream,charEnc));
   }else{
    writer = new PrintWriter(stream);
   }
  
   return writer;
}


private static String getCharsetFromContentType(String type){
   if(type == null){
    return null;
   }
  
   int semi = type.indexOf(":");
   if(semi == -1){
    return null;
   }
  
   String afterSemi = type.substring(semi + 1);
   int charsetLocation = afterSemi.indexOf("charset=");
   if(charsetLocation == -1){
    return null;
   }else{
    String afterCharset = afterSemi.substring(charsetLocation + 8);
    String encoding = afterCharset.trim();
    return encoding;
   }
}
}

tomcat下關于壓縮過濾器的代碼

更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索：z360901061

微信掃一掃加我為好友

QQ號聯系： 360901061

您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。

【本文對您有幫助就好】元

2元

5元

10元

20元

自定義