tokenreplacementfilter.java

J2EE开发与Weblogic一书中的源代码

package com.learnweblogic.examples.ch3;

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class TokenReplacementFilter implements Filter {
    private String replToken, replValue;
    
    public void init(FilterConfig filterConfig)
    throws ServletException {
        replToken = filterConfig.getInitParameter("token.name");
        replValue = filterConfig.getInitParameter("token.value");
        if (null == replToken) {
            throw new ServletException("TokenReplacementFilter named " +
            filterConfig.getFilterName() + 
            " missing token.name init parameter.");
        }
        if (null == replValue) {
            throw new ServletException("TokenReplacementFilter named " +
            filterConfig.getFilterName() + 
            " missing token.value init parameter.");
        }
    }
    public void destroy() {}
    
    public void doFilter(ServletRequest request,
    ServletResponse response, FilterChain chain)
    throws IOException, ServletException {
        BufferedResponse resWrapper = new BufferedResponse(
        (HttpServletResponse)response);
        
        chain.doFilter(request, resWrapper);
        
        if (resWrapper.getOutputType() == BufferedResponse.OT_WRITER) {
            String resBody = new String(
            resWrapper.toByteArray(),resWrapper.getCharacterEncoding());
            if (resWrapper.getContentType().equals("text/html")) {
                resBody = resBody.replaceAll("@" + replToken + "@", replValue);
                response.setContentLength(resBody.length());
            }
            PrintWriter writer = response.getWriter();
            writer.println(resBody);
        } else if (resWrapper.getOutputType() == BufferedResponse.OT_OUTPUT_STREAM) {
            ServletOutputStream out = response.getOutputStream();
            out.write(resWrapper.toByteArray());
        }
    }
    
    class BufferedResponse extends HttpServletResponseWrapper {
        
        public static final short OT_NONE = 0, OT_WRITER = 1, OT_OUTPUT_STREAM = 2;
        
        private short outputType = OT_NONE;
        private PrintWriter writer = null;
        private BufServletOutputStream out = null;
        private String contentType;
        
        public BufferedResponse(HttpServletResponse response){
            super(response);
        }
        
        public ServletOutputStream getOutputStream() throws IOException {
            if (outputType == OT_WRITER) {
                throw new IllegalStateException();
            } else if (outputType == OT_OUTPUT_STREAM) {
                return out;
            } else {
                out = new BufServletOutputStream();
                outputType = OT_OUTPUT_STREAM;
                return (ServletOutputStream)out;
            }
        }
        
        public PrintWriter getWriter() throws IOException {
            if (outputType == OT_OUTPUT_STREAM) {
                throw new IllegalStateException();
            } else if (outputType == OT_WRITER) {
                return writer;
            } else {
                writer = new PrintWriter(
                new OutputStreamWriter(
                getOutputStream(),getCharacterEncoding()));
                outputType = OT_WRITER;
                return writer;
            }
        }
        
        public short getOutputType() {
            return outputType;
        }
        
        public String getContentType() {
            return contentType;
        }
        
        public void setContentType(String contentType) {
            this.contentType = contentType;
            super.setContentType(contentType);
        }
        
        public void flushBuffer() throws IOException {
            if (outputType == OT_WRITER) {
                writer.flush();
            } else if (outputType == OT_OUTPUT_STREAM) {
                out.flush();
            }
        }
        
        public void reset() {
            resetBuffer();
            outputType = OT_NONE;
            super.reset();
        }
        
        public void resetBuffer() {
            if(null != out) {
                out.reset();
            }
        }
        
        public byte[] toByteArray() throws IOException {
            flushBuffer();
            if(null != out) {
                return(out.toByteArray());
            } else {
                return null;
            }
        }
    }
    
    class BufServletOutputStream extends ServletOutputStream {
        ByteArrayOutputStream bufferedOut;
        
        public BufServletOutputStream() {
            bufferedOut = new ByteArrayOutputStream();
        }
        
        public void write(int i) throws IOException {
            bufferedOut.write(i);
        }
        
        public byte[] toByteArray() {
            return bufferedOut.toByteArray();
        }
        
        public void reset() {
            bufferedOut.reset();
        }
    }
}