Filter过滤器

最新推荐文章于 2023-07-24 14:49:45 发布

iteye_17256

最新推荐文章于 2023-07-24 14:49:45 发布

阅读量135

点赞数

分类专栏： Web开发文章标签： Servlet Web JSP 应用服务器浏览器

Web开发专栏收录该内容

16 篇文章

订阅专栏

第6章    Filter过滤器
6.1    Filter接口
Filter定义了三个方法init()，doFilter()，destory() ,分别用于初始化，运行过滤器和销毁过滤器。
1、    Init()
public void init(FilterConfig filterConfig)
在Web应用程序启动时，Web服务器根据web.xml文件创建注册的Filter实例对象。创建实例对象后会立刻调用init方法，且只调用一次。

FilterConfig接口：Filter程序可能访问Servlet容器，Servlet将ServletContext和Filter配置参数信息封装到FilterConfig中。

FilterConfig常用方法：
getFilterName()/getServletContext()/getInitParameter()/getInitParameterNames()

2、    doFilter()
public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)
当一个Filter对象拦截访问请求后，Servlet容器会调用该Filter对象的doFilter()。
FilterChain接口只有一个方法doFilter()用于通知Web容器吧请求交给FilterChain的下一个Filter或Servlet处理。

3、    destroy()
public void destroy()
6.2    Filter基础实例

public class FirstFilter implements Filter {
    private FilterConfig config = null;
    private String paramvalue = "";

    public void init(FilterConfig config) throws ServletException {
        this.config = config;
        paramvalue = config.getInitParameter("encoding");
}
public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request, response);
    }
public void destroy() {
        this.config = null;
}}

<filter>
        <filter-name>FirstFilter</filter-name>
        <filter-class>filter.FirstFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>GB2312</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>FirstFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

6.3 阻止Servlet容器继续调用Servlet

public void doFilter(ServletRequest request, ServletResponse response, 
FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpSession session = req.getSession();
if (session.getAttribute("user") == null) {
RequestDispatcher rd = req.getRequestDispatcher("/login.jsp");
rd.forward(req, resp);
} else {chain.doFilter(request, response);}}

6.4 修改Servlet容器传给Servlet的请求信息
下面实例是一个将Servlet的Request对象获取的请求中的HTML特殊字符进行转换。

public class ConvertSpecialCharacterServletRequestWrapper extends
HttpServletRequestWrapper {
    public ConvertSpecialCharacterServletRequestWrapper(
            HttpServletRequest request) {
        super(request);
    }
    public String getParameter(String name) {
        String value = super.getParameter(name);
        if (null != value) {
            return toHtml(value.trim());
        } else {
            return null;
        }
    }
    public String toHtml(String str) {
        if (str == null) {
            return null;
        }
        StringBuffer sb = new StringBuffer();
        int len = str.length();
        for (int i = 0; i < len; i++) {
            char c = str.charAt(i);
            switch (c) {
            case ' ':
                sb.append("&nbsp;");
                break;
            case '<':
                sb.append("&lt;");
                break;
            case '>':
                sb.append("&gt;");
                break;
            case '&':
                sb.append("&amp;");
                break;
            case '"':
                sb.append("&#34;");
                break;
            case '\\':
                sb.append("&#92;");
                break;
            default:
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

public class SpecialCharacterFilter implements Filter {

    public void init(FilterConfig config) throws ServletException {
    }
    public void doFilter(ServletRequest request, ServletResponse response, 
FilterChain chain) 
throws IOException, ServletException {
HttpServletRequestWrapper requestWrapper = 
(HttpServletRequestWrapper) request;
    chain.doFilter(requestWrapper, response);
    }
    public void destroy() {}
}

6.5 修改Servlet回送给Servlet容器的响应结果
下例中将JSP内容通过ServletResponse打印出来

public class JSPOutputServletResponseWrapper extends HttpServletResponseWrapper {
    private MyPrintWriter tmpWriter;
    private ByteArrayOutputStream output;
    public JSPOutputServletResponseWrapper(HttpServletResponse response) {
        super(response);
        output = new ByteArrayOutputStream();
        tmpWriter = new MyPrintWriter(output);
    }
    public void finalize() throws Throwable {
        super.finalize();
        output.close();
        tmpWriter.close();
    }
    public String getContent() {
        try {
tmpWriter.flush(); // 刷新该流的缓冲
            String s = tmpWriter.getByteArrayOutputStream().toString("UTF-8");
            // 此处可根据需要进行对输出流以及Writer的重置操作
            // 比如tmpWriter.getByteArrayOutputStream().reset()
            return s;
        } catch (UnsupportedEncodingException e) {
            return "UnsupportedEncoding";
        }
    }

    // 覆盖getWriter()方法，使用我们自己定义的Writer
    public PrintWriter getWriter() throws IOException {
        return tmpWriter;
    }

    public void close() throws IOException {
        tmpWriter.close();
    }

    // 自定义PrintWriter，为的是把response流写到自己指定的输入流当中
    // 而非默认的ServletOutputStream
    private static class MyPrintWriter extends PrintWriter {
        ByteArrayOutputStream myOutput; // 此即为存放response输入流的对象
        public MyPrintWriter(ByteArrayOutputStream output) {
            super(output);
            myOutput = output;
        }
        public ByteArrayOutputStream getByteArrayOutputStream() {
            return myOutput;
        }
    }
}

6.6 使用Filter压缩HTML正文

public class CompressionResponseStream extends ServletOutputStream {
    protected int compressionThreshold = 0;// 是否启用压缩的临界值
    protected byte[] buffer = null;// 临时容纳写入的数据的缓冲区
    protected int bufferCount = 0; // 缓冲区实际写入的数据量
    protected GZIPOutputStream gzipstream = null;
    protected boolean closed = false;// 对当前流对象是否处于关闭状态
    protected int length = -1;
    protected HttpServletResponse response = null;
    protected ServletOutputStream output = null;
    public CompressionResponseStream(HttpServletResponse response)
            throws IOException {
        super();
        closed = false;
        this.response = response;
        this.output = response.getOutputStream();
    }
    protected void setBuffer(int threshold) {
        compressionThreshold = threshold;
        buffer = new byte[compressionThreshold];
    }
    public void close() throws IOException {
        if (closed) {
        throw new IOException("This output stream has already been closed");
        }
        /*
         * 根据gzipstream是否为null，就可以判断写入的内容是否达到
         * 启用压缩的临界值，因为到达临界值时，write方法会自动创建gzipstream对象
         */
        if (gzipstream != null) {
            flushToGZip();
            gzipstream.close();
            gzipstream = null;
        } else {
            if (bufferCount > 0) {
                output.write(buffer, 0, bufferCount);
                bufferCount = 0;
            }
        }
        output.close();
        closed = true;
    }
    public void flush() throws IOException {
        if (closed) {
            throw new IOException("Can't flush a closed output stream");
        }
        if (gzipstream != null) {
            gzipstream.flush();
        }
    }
    /**
     * 将buffer缓冲区中的数据写入到gzipstream中
     *
     * @throws IOException
     */
    public void flushToGZip() throws IOException {
        if (bufferCount > 0) {
            writeToGZip(buffer, 0, bufferCount);
            bufferCount = 0;
        }
    }

    @Override
    public void write(int b) throws IOException {
        if (closed) {
            throw new IOException("Can't write to a closed output stream");
        }

        /*
         * 当写入的数据达到启用压缩的临界值时， 则先将buffer缓冲区的数据写入到gzipstream对象中
         */
        if (bufferCount >= buffer.length) {
            flushToGZip();
        }
        buffer[bufferCount++] = (byte) b;
    }

    public void write(byte b[]) throws IOException {
        write(b, 0, b.length);
    }

    public void write(byte[] b, int off, int len) throws IOException {
        if (closed) {
            throw new IOException("Can't write to a closed output stream");
        }
        if (len == 0) {
            return;
        }
        /*
         * 如果buffer缓冲区中剩余的空间能够容纳要写入的数据， 则先将这些数据写入到buffer缓冲区中
         */
        if (len <= (buffer.length - bufferCount)) {
            System.arraycopy(b, off, buffer, bufferCount, len);
            bufferCount += len;
            return;
        }
        /*
         * 如果buffer缓冲区剩余的空间不能容纳要写入的数据， 则先将buffer缓冲区的原有数据写入到gzipstream对象中
         */
        flushToGZip();

        /*
         * 腾空buffer缓冲区数据后，判断整个buffer缓冲区是否能够容纳要写入的数据， 如果能将这些数据写入到buffer缓冲区中
         */
        if (len <= (buffer.length - bufferCount)) {
            System.arraycopy(b, off, buffer, bufferCount, len);
            bufferCount += len;
            return;
        }
        /*
         * 如果整个buffer缓冲区的空间都不能容纳要写入的数据， 则直接将这些数据写入gzipstream中
         */
        writeToGZip(b, off, len);
    }

    /**
     * 将gzipstream对象中写入数据，如果第一次写入 则还需创建gzips实体对象
     *
     * @param b
     * @param off
     * @param len
     * @throws IOException
     */
    public void writeToGZip(byte b[], int off, int len) throws IOException {
        if (gzipstream == null) {
            response.addHeader("Content-Encoding", "gzip");
            gzipstream = new GZIPOutputStream(output);
        }
        gzipstream.write(b, off, len);
    }
}
public class CompressionServletResponseWrapper extends
        HttpServletResponseWrapper {

    protected HttpServletResponse origResponse = null;
    protected static final String info = "CompressionServletResponseWrapper";
    protected ServletOutputStream stream = null;
    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);
    }

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

    /**
     * 创建自定义response对象包括输出流对象
     *
     * @return
     * @throws IOException
     */
    public ServletOutputStream createOutputStream() throws IOException {
        CompressionResponseStream stream = new CompressionResponseStream(
                origResponse);
        stream.setBuffer(threshold);
        return stream;
    }

    /**
     * 为了防止目标Servlet没有关闭输出流对象，Filter调用该方法 以便自动关闭输出流对象
     */
    public void finishResponse() {
        try {
            if (writer != null) {
                writer.close();
            } else {
                if (stream != null) {
                    stream.close();
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    /**
     * 覆盖flushBuffer方法
     */
    public void flushBuffer() throws IOException {
        ((CompressionResponseStream) stream).flush();
    }
    /**
     * 覆盖getOutputStream方法
     */
    public ServletOutputStream getOutputStream() throws IOException {
        if (writer != null) {
            throw new IllegalStateException(
                    "getWriter() has already been called for this resposne");
        }
        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 resposne");
        }
        stream = createOutputStream();

        String charEnc = origResponse.getCharacterEncoding();
        if (charEnc != null) {
            writer = new PrintWriter(new OutputStreamWriter(stream, charEnc));
        } else {
            writer = new PrintWriter(stream);
        }
        return writer;
    }
}
public class CompressionFilter implements Filter {
    private FilterConfig config = null;
    private int minThreshold = 128;
    protected int compressionThreshold;
    public void init(FilterConfig filterConfig) throws ServletException {
        this.config = filterConfig;
        if (filterConfig != null) {
            String str = filterConfig.getInitParameter("compressionThreshold");
            if (compressionThreshold != 0 & compressionThreshold < minThreshold) {
                compressionThreshold = minThreshold;
            } else {
                // 不对响应信息的实体内容进行压缩
                compressionThreshold = 0;
            }
        } else {
            compressionThreshold = 0;
        }
    }
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        /*
         * 不对响应信息的实体内容进行压缩
         */
        if (compressionThreshold == 0) {
            chain.doFilter(request, response);
        }
        /*
         * 检测客户端浏览器是否支持gzip数据压缩格式
         */
        boolean supportCompression = false;
        if (request instanceof HttpServletRequest) {
            Enumeration<String> e = ((HttpServletRequest) request)
                    .getHeaders("Accept-Encoding");
            while (e.hasMoreElements()) {
                String name = e.nextElement();
                if (name.indexOf("gzip") != -1) {
                    supportCompression = true;
                }
            }
        }
        if (!supportCompression) {
            chain.doFilter(request, response);
            return;
        } else {
            if (response instanceof HttpServletResponse) {
                /*
                 * 创建自定义的Response对象
                 */
CompressionServletResponseWrapper wrapperResponse = new 
CompressionServletResponseWrapper((HttpServletResponse) response);
    wrapperResponse.setCompressionThreshold(compressionThreshold);
                try {
                    chain.doFilter(request, wrapperResponse);
                } finally {
                    wrapperResponse.finishResponse();
                }
            }
            return;
        }
    }
    public void destroy() {
        this.config = null;
    }
}