01: /*
02: * Copyright (c) 2002-2003 by OpenSymphony
03: * All rights reserved.
04: */
05: package com.opensymphony.oscache.web.filter;
06:
07: import java.io.IOException;
08: import java.io.OutputStream;
09:
10: import javax.servlet.ServletOutputStream;
11:
12: /**
13: * Extends the base <code>ServletOutputStream</code> class so that
14: * the stream can be captured as it gets written. This is achieved
15: * by overriding the <code>write()</code> methods and outputting
16: * the data to two streams - the original stream and a secondary stream
17: * that is designed to capture the written data.
18: *
19: * @version $Revision: 393 $
20: * @author <a href="mailto:sergek@lokitech.com">Serge Knystautas</a>
21: */
22: public class SplitServletOutputStream extends ServletOutputStream {
23: OutputStream captureStream = null;
24: OutputStream passThroughStream = null;
25:
26: /**
27: * Constructs a split output stream that both captures and passes through
28: * the servlet response.
29: *
30: * @param captureStream The stream that will be used to capture the data.
31: * @param passThroughStream The pass-through <code>ServletOutputStream</code>
32: * that will write the response to the client as originally intended.
33: */
34: public SplitServletOutputStream(OutputStream captureStream,
35: OutputStream passThroughStream) {
36: this .captureStream = captureStream;
37: this .passThroughStream = passThroughStream;
38: }
39:
40: /**
41: * Writes the incoming data to both the output streams.
42: *
43: * @param value The int data to write.
44: * @throws IOException
45: */
46: public void write(int value) throws IOException {
47: captureStream.write(value);
48: passThroughStream.write(value);
49: }
50:
51: /**
52: * Writes the incoming data to both the output streams.
53: *
54: * @param value The bytes to write to the streams.
55: * @throws IOException
56: */
57: public void write(byte[] value) throws IOException {
58: captureStream.write(value);
59: passThroughStream.write(value);
60: }
61:
62: /**
63: * Writes the incoming data to both the output streams.
64: *
65: * @param b The bytes to write out to the streams.
66: * @param off The offset into the byte data where writing should begin.
67: * @param len The number of bytes to write.
68: * @throws IOException
69: */
70: public void write(byte[] b, int off, int len) throws IOException {
71: captureStream.write(b, off, len);
72: passThroughStream.write(b, off, len);
73: }
74:
75: /**
76: * Flushes both the output streams.
77: * @throws IOException
78: */
79: public void flush() throws IOException {
80: super .flush();
81: captureStream.flush(); //why not?
82: passThroughStream.flush();
83: }
84:
85: /**
86: * Closes both the output streams.
87: * @throws IOException
88: */
89: public void close() throws IOException {
90: super.close();
91: captureStream.close();
92: passThroughStream.close();
93: }
94:
95: }
|