cmsflexresponse.java

来自「java 编写的程序」· Java 代码 · 共 801 行 · 第 1/3 页

    /**
     * Sets the cache key for this response from 
     * a pre-calculated cache key.
     *
     * @param value The cache key to set
     */
    void setCmsCacheKey(CmsFlexCacheKey value) {
        m_key = value;
    }
    
    /**
     * Helper method to add a value in the internal header list.
     */
    private void addHeaderList(Map headers, String name, String value) {
        ArrayList values = (ArrayList) headers.get(name);
        if (values == null) {
            values = new ArrayList();
            headers.put(name, values);            
        } 
        values.add(value);        
    }
   
    /**
     * Helper method to set a value in the internal header list.
     */
    private void setHeaderList(Map headers, String name, String value) {
        ArrayList values = new ArrayList();
        values.add(C_SETHEADER + value);
        headers.put(name, values);        
    }
    
    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */
    public java.io.PrintWriter getWriter() throws IOException {
        if (m_writer == null) initStream();
        return m_writer;
    }
    
    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */
    public javax.servlet.ServletOutputStream getOutputStream() throws IOException {
        if (m_out == null) initStream();
        return m_out;
    }

    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */
    public void sendRedirect(String location) throws IOException {
        // Ignore any redirects after the first one
        if (isSuspended() && (! location.equals(m_buffer_redirect))) return;
        if (DEBUG) System.err.println("FlexResponse: sendRedirect to target " + location);
                
        if (m_cachingRequired && ! m_includeMode) {
            m_buffer_redirect = location;
        }
        
        if (! m_cachingRequired) {
            // If caching is required a cachen entry will be constructed first and redirect will
            // be called after this is completed and stored in the cache
            if (DEBUG) System.err.println("FlexResponse: getTopResponse.sendRedirect() to target " + location);
            getTopResponse().sendRedirect(location);           
        }
        
        setSuspended(true);
    }
    
    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */
    public static void processHeaders(Map headers, HttpServletResponse res) {
        if (headers != null) {
            java.util.Iterator i = headers.keySet().iterator();
            while (i.hasNext()) {
                String key = (String)i.next();
                ArrayList l = (ArrayList)headers.get(key);  
                java.util.ListIterator j = l.listIterator(); 
                while (j.hasNext()) {
                    if ((j.nextIndex() == 0) && (((String)l.get(0)).startsWith(C_SETHEADER)))  {
                        String s = (String)j.next();
                        res.setHeader(key, s.substring(C_SETHEADER.length()));
                        if (DEBUG && (! (res instanceof CmsFlexResponse))) System.err.println("FlexResponse: setHeader(" + key + ") to final stream");               
                    } else {
                        res.addHeader(key, (String)j.next());
                        if (DEBUG && (! (res instanceof CmsFlexResponse))) System.err.println("FlexResponse: addHeader(" + key + ") to final stream");               
                    }
                }
            }        
        }          
    }
    
    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */
    public void setHeader(String name, String value) {
        if (isSuspended()) return;

        if (m_cachingRequired && ! m_includeMode) {
            setHeaderList(m_buffer_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: setHeader(" + name + ", " + value + ") in element buffer");
        }
        
        if (m_writeOnlyToBuffer) {
            setHeaderList(m_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: setHeader(" + name + ", " + value + ") in main header buffer");
        } else {
            if (DEBUG) System.err.println("FlexResponse: setHeader(" + name + ", " + value + ") passing to parent");
            m_res.setHeader(name, value);
        }
    }
    
    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */    
    public void addHeader(String name, String value) {
        if (isSuspended()) return;

        if (m_cachingRequired && ! m_includeMode) {
            addHeaderList(m_buffer_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: addHeader(" + name + ", " + value + ") to element buffer");
        }
        
        if (m_writeOnlyToBuffer) {
            addHeaderList(m_headers, name, value);
            if (DEBUG) System.err.println("FlexResponse: addHeader(" + name + ", " + value + ") to main header buffer");
        } else {
            if (DEBUG) System.err.println("FlexResponse: addHeader(" + name + ", " + value + ") passing to parent");
            m_res.addHeader(name, value);
        }
    }
    
    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */    
    public void setDateHeader(String name, long date) {
        java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", java.util.Locale.US);
        setHeader(name, format.format(new java.util.Date(date)));
    }

    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */    
    public void addDateHeader(String name, long date) {
        java.text.SimpleDateFormat format = new java.text.SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", java.util.Locale.US);
        addHeader(name, format.format(new java.util.Date(date)));
    }

    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */    
    public void setIntHeader(String name, int value) {
        setHeader(name, "" + value);       
    }

    /**
     * Method overlodad from the standard javax.servlet.http.HttpServletRequest.
     */    
    public void addIntHeader(String name, int value) {
        addHeader(name, "" + value);
    }    
    
    /**
     * Wrapped implementation of the ServletOutputStream.
     * It writes to an internal buffer and optionally to another output stream at the same time.
     * It should be fully transparent to the standard ServletOutputStream.
     */    
    private class CmsServletOutputStream extends javax.servlet.ServletOutputStream {

        /** The internal steam buffer */
        private java.io.ByteArrayOutputStream stream = null;
        
        /** The optional output stream to write to */
        private javax.servlet.ServletOutputStream servletStream = null;
        
        /** Debug flag */
        private boolean DEBUG = false;

        /**
         * Constructor that must be used if the stream should write 
         * only to a buffer.
         */
        public CmsServletOutputStream() {
            this.servletStream = null;
            clear();
        }   

        /**
         * Constructor that must be used if the stream should write 
         * to a buffer and to another stream at the same time.
         *
         * @param servletStream The stream to write to
         */        
        public CmsServletOutputStream(javax.servlet.ServletOutputStream servletStream) {
            this.servletStream = servletStream;
            clear();
        }   
                
        /**
         * Writes the specified byte to this output stream. The general
         * contract for <code>write</code> is that one byte is written
         * to the output stream. The byte to be written is the eight
         * low-order bits of the argument <code>b</code>. The 24
         * high-order bits of <code>b</code> are ignored.
         * <p>
         * Subclasses of <code>OutputStream</code> must provide an
         * implementation for this method.
         *
         * @param b   the <code>byte</code>.
         * @exception IOException  if an I/O error occurs. In particular,
         *             an <code>IOException</code> may be thrown if the
         *             output stream has been closed.
         */
        public void write(int b) throws IOException {
            stream.write(b);
            if (servletStream != null) servletStream.write(b);
        }
        
        /**
         * Method overlodad from the standard javax.servlet.ServletOutputStream.
         */    
        public void write(byte[] b, int off, int len) throws IOException {
            stream.write(b, off, len);
            if (servletStream != null) servletStream.write(b, off, len);
        }
        
        /**
         * Writes an array of bytes only to the included servlet stream,
         * not to the buffer.
         *
         * @param b The bytes to write to the stream
         * @throws IOException In case the write() operation on the included servlet stream raises one
         */
        public void writeToServletStream(byte[] b) throws IOException {
            if (servletStream != null) servletStream.write(b);
        }
        
        /**
         * Provides access to the bytes cached in the buffer.
         *
         * @return The cached bytes from the buffer
         */
        public byte[] getBytes() {
            return stream.toByteArray();
        }
        
        /**
         * Clears the buffer by initializing the buffer with a new stream.
         */
        public void clear() {
            stream = new java.io.ByteArrayOutputStream(1024);
        }
        
        /**
         * Flushes the buffer of the included servlet stream.
         *
         * @throws IOException In case the flush() operation on the included servlet stream raises one
         */
        public void flush() throws IOException {
            if (DEBUG) System.err.println("CmsServletOutputStream: flush() called! servletStream=" + servletStream);
            if (servletStream != null) servletStream.flush();
        }
    }    
    
}