Java tutorial
// ======================================================================== // $Id: HttpOutputStream.java,v 1.28 2006/10/08 14:13:05 gregwilkins Exp $ // Copyright 199-2004 Mort Bay Consulting Pty. Ltd. // ------------------------------------------------------------------------ // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // http://www.apache.org/licenses/LICENSE-2.0 // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // ======================================================================== package org.openqa.jetty.http; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.Writer; import java.util.ArrayList; import org.apache.commons.logging.Log; import org.openqa.jetty.log.LogFactory; import org.openqa.jetty.util.ByteArrayPool; import org.openqa.jetty.util.IO; import org.openqa.jetty.util.LogSupport; import org.openqa.jetty.util.OutputObserver; import org.openqa.jetty.util.StringUtil; /* ---------------------------------------------------------------- */ /** HTTP Http OutputStream. * Acts as a BufferedOutputStream until setChunking() is called. * Once chunking is enabled, the raw stream is chunk encoded as per RFC2616. * * Implements the following HTTP and Servlet features: <UL> * <LI>Filters for content and transfer encodings. * <LI>Allows output to be reset if not committed (buffer never flushed). * <LI>Notification of significant output events for filter triggering, * header flushing, etc. * </UL> * * This class is not synchronized and should be synchronized * explicitly if an instance is used by multiple threads. * * @version $Id: HttpOutputStream.java,v 1.28 2006/10/08 14:13:05 gregwilkins Exp $ * @author Greg Wilkins */ public class HttpOutputStream extends OutputStream implements OutputObserver, HttpMessage.HeaderWriter { private static Log log = LogFactory.getLog(HttpOutputStream.class); /* ------------------------------------------------------------ */ final static int __BUFFER_SIZE = 4096; final static int __FIRST_RESERVE = 512; public final static Class[] __filterArg = { java.io.OutputStream.class }; /* ------------------------------------------------------------ */ private OutputStream _out; private OutputStream _realOut; private BufferedOutputStream _bufferedOut; private boolean _written; private ArrayList _observers; private int _bufferSize; private int _headerReserve; private HttpWriter _iso8859writer; private HttpWriter _utf8writer; private HttpWriter _asciiwriter; private boolean _nulled; private boolean _closing = false; private int _contentLength = -1; private int _bytes; private boolean _disableFlush; /* ------------------------------------------------------------ */ /** Constructor. * @param outputStream The outputStream to buffer or chunk to. */ public HttpOutputStream(OutputStream outputStream) { this(outputStream, __BUFFER_SIZE, __FIRST_RESERVE); } /* ------------------------------------------------------------ */ /** Constructor. * @param outputStream The outputStream to buffer or chunk to. */ public HttpOutputStream(OutputStream outputStream, int bufferSize) { this(outputStream, bufferSize, __FIRST_RESERVE); } /* ------------------------------------------------------------ */ /** Constructor. * @param outputStream The outputStream to buffer or chunk to. */ public HttpOutputStream(OutputStream outputStream, int bufferSize, int headerReserve) { _written = false; _bufferSize = bufferSize; _headerReserve = headerReserve; _realOut = outputStream; _out = _realOut; } /* ------------------------------------------------------------ */ public void setContentLength(int length) { if (length >= 0 && length < _bytes) throw new IllegalStateException(); _contentLength = length; } /* ------------------------------------------------------------ */ public void setBufferedOutputStream(BufferedOutputStream bos) { _bufferedOut = bos; _bufferedOut.setCommitObserver(this); if (_out != null && _out != _realOut) _out = _bufferedOut; } /* ------------------------------------------------------------ */ /** Get the backing output stream. * A stream without filters or chunking is returned. * @return Raw OutputStream. */ public OutputStream getOutputStream() { return _realOut; } /* ------------------------------------------------------------ */ /** Get the buffered output stream. */ public OutputStream getBufferedOutputStream() { return _out; } /* ------------------------------------------------------------ */ /** Has any data been written to the stream. * @return True if write has been called. */ public boolean isWritten() { return _written; } /* ------------------------------------------------------------ */ /** Get the output buffer capacity. * @return Buffer capacity in bytes. */ public int getBufferSize() { return _bufferSize; } /* ------------------------------------------------------------ */ /** Set the output buffer size. * Note that this is the minimal buffer size and that installed * filters may perform their own buffering and are likely to change * the size of the output. Also the pre and post reserve buffers may be * allocated within the buffer for headers and chunking. * @param size Minimum buffer size in bytes * @exception IllegalStateException If output has been written. */ public void setBufferSize(int size) throws IllegalStateException { if (size <= _bufferSize) return; if (_bufferedOut != null && _bufferedOut.size() > 0) throw new IllegalStateException("Not Reset"); try { _bufferSize = size; if (_bufferedOut != null) { boolean fixed = _bufferedOut.isFixed(); _bufferedOut.setFixed(false); _bufferedOut.ensureSize(size); _bufferedOut.setFixed(fixed); } } catch (IOException e) { log.warn(LogSupport.EXCEPTION, e); } } /* ------------------------------------------------------------ */ public int getBytesWritten() { return _bytes; } /* ------------------------------------------------------------ */ /** Reset Buffered output. * If no data has been committed, the buffer output is discarded and * the filters may be reinitialized. * @exception IllegalStateException */ public void resetBuffer() throws IllegalStateException { // Shutdown filters without observation if (_out != null && _out != _realOut) { ArrayList save_observers = _observers; _observers = null; _nulled = true; try { // discard current buffer and set it to output if (_bufferedOut != null) { _bufferedOut.resetStream(); if (_bufferedOut instanceof ChunkingOutputStream) ((ChunkingOutputStream) _bufferedOut).setChunking(false); } } catch (Exception e) { LogSupport.ignore(log, e); } finally { _observers = save_observers; } } _contentLength = -1; _nulled = false; _bytes = 0; _written = false; _out = _realOut; try { notify(OutputObserver.__RESET_BUFFER); } catch (IOException e) { LogSupport.ignore(log, e); } } /* ------------------------------------------------------------ */ /** Add an Output Observer. * Output Observers get notified of significant events on the * output stream. Observers are called in the reverse order they * were added. * They are removed when the stream is closed. * @param observer The observer. */ public void addObserver(OutputObserver observer) { if (_observers == null) _observers = new ArrayList(4); _observers.add(observer); _observers.add(null); } /* ------------------------------------------------------------ */ /** Add an Output Observer. * Output Observers get notified of significant events on the * output stream. Observers are called in the reverse order they * were added. * They are removed when the stream is closed. * @param observer The observer. * @param data Data to be passed wit notify calls. */ public void addObserver(OutputObserver observer, Object data) { if (_observers == null) _observers = new ArrayList(4); _observers.add(observer); _observers.add(data); } /* ------------------------------------------------------------ */ /** Reset the observers. */ public void resetObservers() { _observers = null; } /* ------------------------------------------------------------ */ /** Null the output. * All output written is discarded until the stream is reset. Used * for HEAD requests. */ public void nullOutput() throws IOException { _nulled = true; } /* ------------------------------------------------------------ */ /** is the output Nulled? */ public boolean isNullOutput() throws IOException { return _nulled; } /* ------------------------------------------------------------ */ /** Set chunking mode. */ public void setChunking() { checkOutput(); if (_bufferedOut instanceof ChunkingOutputStream) ((ChunkingOutputStream) _bufferedOut).setChunking(true); else throw new IllegalStateException(_bufferedOut.getClass().toString()); } /* ------------------------------------------------------------ */ /** Get chunking mode */ public boolean isChunking() { return (_bufferedOut instanceof ChunkingOutputStream) && ((ChunkingOutputStream) _bufferedOut).isChunking(); } /* ------------------------------------------------------------ */ /** Reset the stream. * Turn disable all filters. * @exception IllegalStateException The stream cannot be * reset if chunking is enabled. */ public void resetStream() throws IOException, IllegalStateException { if (isChunking()) close(); _out = null; _nulled = true; if (_bufferedOut != null) { _bufferedOut.resetStream(); if (_bufferedOut instanceof ChunkingOutputStream) ((ChunkingOutputStream) _bufferedOut).setChunking(false); } if (_iso8859writer != null) _iso8859writer.flush(); if (_utf8writer != null) _utf8writer.flush(); if (_asciiwriter != null) _asciiwriter.flush(); _bytes = 0; _written = false; _out = _realOut; _closing = false; _contentLength = -1; _nulled = false; if (_observers != null) _observers.clear(); } /* ------------------------------------------------------------ */ public void destroy() { if (_bufferedOut != null) _bufferedOut.destroy(); _bufferedOut = null; if (_iso8859writer != null) _iso8859writer.destroy(); _iso8859writer = null; if (_utf8writer != null) _utf8writer.destroy(); _utf8writer = null; if (_asciiwriter != null) _asciiwriter.destroy(); _asciiwriter = null; } /* ------------------------------------------------------------ */ public void writeHeader(HttpMessage httpMessage) throws IOException { checkOutput(); _bufferedOut.writeHeader(httpMessage); } /* ------------------------------------------------------------ */ public void write(int b) throws IOException { prepareOutput(1); if (!_nulled) _out.write(b); if (_bytes == _contentLength) flush(); } /* ------------------------------------------------------------ */ public void write(byte b[]) throws IOException { write(b, 0, b.length); } /* ------------------------------------------------------------ */ public void write(byte b[], int off, int len) throws IOException { len = prepareOutput(len); if (!_nulled) _out.write(b, off, len); if (_bytes == _contentLength) flush(); } /* ------------------------------------------------------------ */ protected void checkOutput() { if (_out == _realOut) { if (_bufferedOut == null) { _bufferedOut = new ChunkingOutputStream(_realOut, _bufferSize, _headerReserve, false); _bufferedOut.setCommitObserver(this); _bufferedOut.setBypassBuffer(true); _bufferedOut.setFixed(true); } _out = _bufferedOut; } } /* ------------------------------------------------------------ */ protected int prepareOutput(int length) throws IOException { if (_out == null) throw new IOException("closed"); checkOutput(); if (!_written) { _written = true; notify(OutputObserver.__FIRST_WRITE); } if (_contentLength >= 0) { if (_bytes + length >= _contentLength) { length = _contentLength - _bytes; if (length == 0) _nulled = true; } } _bytes += length; return length; } /* ------------------------------------------------------------ */ public void flush() throws IOException { if (!_disableFlush && _out != null && !_closing) _out.flush(); } /* ------------------------------------------------------------ */ /** Close the stream. * @exception IOException */ public boolean isClosed() throws IOException { return _out == null; } /* ------------------------------------------------------------ */ /** Close the stream. * @exception IOException */ public void close() throws IOException { // Are we already closed? if (_out == null) return; _closing = true; // Close try { notify(OutputObserver.__CLOSING); OutputStream out = _out; _out = null; if (out != _bufferedOut) out.close(); else _bufferedOut.close(); notify(OutputObserver.__CLOSED); } catch (IOException e) { LogSupport.ignore(log, e); } } /* ------------------------------------------------------------ */ /** Output Notification. * Called by the internal Buffered Output and the event is passed on to * this streams observers. */ public void outputNotify(OutputStream out, int action, Object ignoredData) throws IOException { notify(action); } /* ------------------------------------------------------------ */ /* Notify observers of action. * @see OutputObserver * @param action the action. */ private void notify(int action) throws IOException { if (_observers != null) { for (int i = _observers.size(); i-- > 0;) { Object data = _observers.get(i--); ((OutputObserver) _observers.get(i)).outputNotify(this, action, data); } } } /* ------------------------------------------------------------ */ public void write(InputStream in, int len) throws IOException { IO.copy(in, this, len); } /* ------------------------------------------------------------ */ private Writer getISO8859Writer() throws IOException { if (_iso8859writer == null) _iso8859writer = new HttpWriter(StringUtil.__ISO_8859_1, getBufferSize()); return _iso8859writer; } /* ------------------------------------------------------------ */ private Writer getUTF8Writer() throws IOException { if (_utf8writer == null) _utf8writer = new HttpWriter("UTF-8", getBufferSize()); return _utf8writer; } /* ------------------------------------------------------------ */ private Writer getASCIIWriter() throws IOException { if (_asciiwriter == null) _asciiwriter = new HttpWriter("US-ASCII", getBufferSize()); return _asciiwriter; } /* ------------------------------------------------------------ */ public Writer getWriter(String encoding) throws IOException { if (encoding == null || StringUtil.__ISO_8859_1.equalsIgnoreCase(encoding) || "ISO8859_1".equalsIgnoreCase(encoding)) return getISO8859Writer(); if ("UTF-8".equalsIgnoreCase(encoding) || "UTF8".equalsIgnoreCase(encoding)) return getUTF8Writer(); if ("US-ASCII".equalsIgnoreCase(encoding)) return getASCIIWriter(); return new OutputStreamWriter(this, encoding); } /* ------------------------------------------------------------ */ public String toString() { return super.toString() + "\nout=" + _out + "\nrealOut=" + _realOut + "\nbufferedOut=" + _bufferedOut; } /* ------------------------------------------------------------ */ /* ------------------------------------------------------------ */ private class HttpWriter extends Writer { private OutputStreamWriter _writer = null; private boolean _writting = false; private byte[] _buf; private String _encoding; /* -------------------------------------------------------- */ HttpWriter(String encoding, int bufferSize) { _buf = ByteArrayPool.getByteArray(bufferSize); _encoding = encoding; } /* -------------------------------------------------------- */ public Object getLock() { return lock; } /* -------------------------------------------------------- */ public void write(char c) throws IOException { HttpOutputStream.this.prepareOutput(1); if (!_nulled) { if (_writting) _writer.write(c); else if (c >= 0 && c <= 0x7f) HttpOutputStream.this.write((int) c); else { char[] ca = { c }; writeEncoded(ca, 0, 1); } if (_bytes == _contentLength) flush(); } } /* ------------------------------------------------------------ */ public void write(char[] ca) throws IOException { this.write(ca, 0, ca.length); } /* ------------------------------------------------------------ */ public void write(char[] ca, int offset, int len) throws IOException { if (_writting) _writer.write(ca, offset, len); else { int s = 0; for (int i = 0; i < len; i++) { char c = ca[offset + i]; if (c >= 0 && c <= 0x7f) { _buf[s++] = (byte) c; if (s == _buf.length) { s = HttpOutputStream.this.prepareOutput(s); if (!_nulled) HttpOutputStream.this._out.write(_buf, 0, s); s = 0; } } else { if (s > 0) { s = HttpOutputStream.this.prepareOutput(s); if (!_nulled) HttpOutputStream.this._out.write(_buf, 0, s); s = 0; } writeEncoded(ca, offset + i, len - i); break; } } if (s > 0) { s = HttpOutputStream.this.prepareOutput(s); if (!_nulled) HttpOutputStream.this._out.write(_buf, 0, s); s = 0; } } if (!_nulled && _bytes == _contentLength) flush(); } /* ------------------------------------------------------------ */ public void write(String s) throws IOException { this.write(s, 0, s.length()); } /* ------------------------------------------------------------ */ public void write(String str, int offset, int len) throws IOException { if (_writting) _writer.write(str, offset, len); else { int s = 0; for (int i = 0; i < len; i++) { char c = str.charAt(offset + i); if (c >= 0 && c <= 0x7f) { _buf[s++] = (byte) c; if (s == _buf.length) { s = HttpOutputStream.this.prepareOutput(s); if (!_nulled) HttpOutputStream.this._out.write(_buf, 0, s); s = 0; } } else { if (s > 0) { s = HttpOutputStream.this.prepareOutput(s); if (!_nulled) HttpOutputStream.this._out.write(_buf, 0, s); s = 0; } char[] chars = str.toCharArray(); writeEncoded(chars, offset + i, len - i); break; } } if (s > 0) { s = HttpOutputStream.this.prepareOutput(s); if (!_nulled) HttpOutputStream.this._out.write(_buf, 0, s); s = 0; } } if (_bytes == _contentLength) flush(); } /* ------------------------------------------------------------ */ private void writeEncoded(char[] ca, int offset, int length) throws IOException { _writting = true; if (_writer == null) _writer = new OutputStreamWriter(HttpOutputStream.this, _encoding); try { HttpOutputStream.this._disableFlush = true; _writer.write(ca, offset, length); if (HttpOutputStream.this._contentLength >= 0) _writer.flush(); } finally { HttpOutputStream.this._disableFlush = false; } } /* ------------------------------------------------------------ */ public void flush() throws IOException { if (_writting) _writer.flush(); else HttpOutputStream.this.flush(); _writting = false; } /* ------------------------------------------------------------ */ public void close() throws IOException { _closing = true; if (_writting) _writer.flush(); HttpOutputStream.this.close(); _writting = false; } /* ------------------------------------------------------------ */ public void destroy() { ByteArrayPool.returnByteArray(_buf); _buf = null; _writer = null; _encoding = null; } } /** * @return Returns the disableFlush. */ }