1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17   * SOFTWARE.
18   */
19  
20  package com.liferay.util.servlet.filters;
21  
22  import com.liferay.portal.kernel.servlet.HttpHeaders;
23  import com.liferay.portal.kernel.util.ByteArrayMaker;
24  import com.liferay.util.servlet.Header;
25  
26  import java.io.IOException;
27  import java.io.OutputStreamWriter;
28  import java.io.PrintWriter;
29  
30  import java.util.ArrayList;
31  import java.util.HashMap;
32  import java.util.List;
33  import java.util.Map;
34  
35  import javax.servlet.ServletOutputStream;
36  import javax.servlet.http.HttpServletResponse;
37  import javax.servlet.http.HttpServletResponseWrapper;
38  
39  /**
40   * <a href="CacheResponse.java.html"><b><i>View Source</i></b></a>
41   *
42   * @author Alexander Chow
43   *
44   */
45  public class CacheResponse extends HttpServletResponseWrapper {
46  
47      public CacheResponse(HttpServletResponse response, String encoding) {
48          super(response);
49  
50          _encoding = encoding;
51      }
52  
53      public void addDateHeader(String name, long value) {
54          List<Header> values = _headers.get(name);
55  
56          if (values == null) {
57              values = new ArrayList<Header>();
58  
59              _headers.put(name, values);
60          }
61  
62          Header header = new Header();
63  
64          header.setType(Header.DATE_TYPE);
65          header.setDateValue(value);
66  
67          values.add(header);
68      }
69  
70      public void addHeader(String name, String value) {
71          List<Header> values = _headers.get(name);
72  
73          if (values == null) {
74              values = new ArrayList<Header>();
75  
76              _headers.put(name, values);
77          }
78  
79          Header header = new Header();
80  
81          header.setType(Header.STRING_TYPE);
82          header.setStringValue(value);
83  
84          values.add(header);
85  
86          if (name.equals(HttpHeaders.CONTENT_TYPE)) {
87              _contentType = value;
88          }
89      }
90  
91      public void addIntHeader(String name, int value) {
92          List<Header> values = _headers.get(name);
93  
94          if (values == null) {
95              values = new ArrayList<Header>();
96  
97              _headers.put(name, values);
98          }
99  
100         Header header = new Header();
101 
102         header.setType(Header.INTEGER_TYPE);
103         header.setIntValue(value);
104 
105         values.add(header);
106     }
107 
108     public String getHeader(String name) {
109         List<Header> values = _headers.get(name);
110 
111         if ((values == null) || values.isEmpty()) {
112             return null;
113         }
114 
115         Header header = values.get(0);
116 
117         return header.toString();
118     }
119 
120     public void finishResponse() {
121         try {
122             if (_writer != null) {
123                 _writer.close();
124             }
125             else if (_stream != null) {
126                 _stream.close();
127             }
128         }
129         catch (IOException e) {
130         }
131     }
132 
133     public void flushBuffer() throws IOException {
134         if (_stream != null) {
135             _stream.flush();
136         }
137     }
138 
139     public String getContentType() {
140         return _contentType;
141     }
142 
143     public byte[] getData() {
144         finishResponse();
145 
146         return _bam.toByteArray();
147     }
148 
149     public Map<String, List<Header>> getHeaders() {
150         return _headers;
151     }
152 
153     public ServletOutputStream getOutputStream() {
154         if (_writer != null) {
155             throw new IllegalStateException();
156         }
157 
158         if (_stream == null) {
159             _stream = createOutputStream();
160         }
161 
162         return _stream;
163     }
164 
165     public PrintWriter getWriter() throws IOException {
166         if (_writer != null) {
167             return _writer;
168         }
169 
170         if (_stream != null) {
171             throw new IllegalStateException();
172         }
173 
174         _stream = createOutputStream();
175 
176         _writer = new PrintWriter(new OutputStreamWriter(
177             //_stream, _res.getCharacterEncoding()));
178             _stream, _encoding));
179 
180         return _writer;
181     }
182 
183     public boolean isCommitted() {
184         if (_writer != null) {
185             return true;
186         }
187 
188         if ((_stream != null) && _stream.isClosed()) {
189             return true;
190         }
191 
192         return super.isCommitted();
193     }
194 
195     public void setContentType(String contentType) {
196         _contentType = contentType;
197 
198         super.setContentType(contentType);
199     }
200 
201     public void setDateHeader(String name, long value) {
202         List<Header> values = new ArrayList<Header>();
203 
204         _headers.put(name, values);
205 
206         Header header = new Header();
207 
208         header.setType(Header.DATE_TYPE);
209         header.setDateValue(value);
210 
211         values.add(header);
212     }
213 
214     public void setHeader(String name, String value) {
215         List<Header> values = new ArrayList<Header>();
216 
217         _headers.put(name, values);
218 
219         Header header = new Header();
220 
221         header.setType(Header.STRING_TYPE);
222         header.setStringValue(value);
223 
224         values.add(header);
225     }
226 
227     public void setIntHeader(String name, int value) {
228         List<Header> values = new ArrayList<Header>();
229 
230         _headers.put(name, values);
231 
232         Header header = new Header();
233 
234         header.setType(Header.INTEGER_TYPE);
235         header.setIntValue(value);
236 
237         values.add(header);
238     }
239 
240     protected CacheResponseStream createOutputStream() {
241         return new CacheResponseStream(_bam);
242     }
243 
244     private String _encoding;
245     private ByteArrayMaker _bam = new ByteArrayMaker();
246     private CacheResponseStream _stream;
247     private PrintWriter _writer;
248     private String _contentType;
249     private Map<String, List<Header>> _headers =
250         new HashMap<String, List<Header>>();
251 
252 }