1   /**
2    * Copyright (c) 2000-2010 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   *
12   *
13   */
14  
15  package com.liferay.util.servlet.filters;
16  
17  import com.liferay.portal.kernel.io.unsync.UnsyncByteArrayOutputStream;
18  import com.liferay.portal.kernel.servlet.HttpHeaders;
19  import com.liferay.util.servlet.Header;
20  
21  import java.io.IOException;
22  import java.io.OutputStreamWriter;
23  import java.io.PrintWriter;
24  
25  import java.util.ArrayList;
26  import java.util.HashMap;
27  import java.util.List;
28  import java.util.Map;
29  
30  import javax.servlet.ServletOutputStream;
31  import javax.servlet.http.HttpServletResponse;
32  import javax.servlet.http.HttpServletResponseWrapper;
33  
34  /**
35   * <a href="CacheResponse.java.html"><b><i>View Source</i></b></a>
36   *
37   * @author Alexander Chow
38   */
39  public class CacheResponse extends HttpServletResponseWrapper {
40  
41      public CacheResponse(HttpServletResponse response, String encoding) {
42          super(response);
43  
44          _encoding = encoding;
45      }
46  
47      public void addDateHeader(String name, long value) {
48          List<Header> values = _headers.get(name);
49  
50          if (values == null) {
51              values = new ArrayList<Header>();
52  
53              _headers.put(name, values);
54          }
55  
56          Header header = new Header();
57  
58          header.setType(Header.DATE_TYPE);
59          header.setDateValue(value);
60  
61          values.add(header);
62      }
63  
64      public void addHeader(String name, String value) {
65          List<Header> values = _headers.get(name);
66  
67          if (values == null) {
68              values = new ArrayList<Header>();
69  
70              _headers.put(name, values);
71          }
72  
73          Header header = new Header();
74  
75          header.setType(Header.STRING_TYPE);
76          header.setStringValue(value);
77  
78          values.add(header);
79  
80          if (name.equals(HttpHeaders.CONTENT_TYPE)) {
81              setContentType(value);
82          }
83      }
84  
85      public void addIntHeader(String name, int value) {
86          List<Header> values = _headers.get(name);
87  
88          if (values == null) {
89              values = new ArrayList<Header>();
90  
91              _headers.put(name, values);
92          }
93  
94          Header header = new Header();
95  
96          header.setType(Header.INTEGER_TYPE);
97          header.setIntValue(value);
98  
99          values.add(header);
100     }
101 
102     public void finishResponse() {
103         try {
104             if (_writer != null) {
105                 _writer.close();
106             }
107             else if (_stream != null) {
108                 _stream.close();
109             }
110         }
111         catch (IOException e) {
112         }
113     }
114 
115     public void flushBuffer() throws IOException {
116         if (_stream != null) {
117             _stream.flush();
118         }
119     }
120 
121     public int getBufferSize() {
122         return _bufferSize;
123     }
124 
125     public int getContentLength() {
126         return _ubaos.size();
127     }
128 
129     public String getContentType() {
130         return _contentType;
131     }
132 
133     public String getHeader(String name) {
134         List<Header> values = _headers.get(name);
135 
136         if ((values == null) || values.isEmpty()) {
137             return null;
138         }
139 
140         Header header = values.get(0);
141 
142         return header.toString();
143     }
144 
145     public Map<String, List<Header>> getHeaders() {
146         return _headers;
147     }
148 
149     public ServletOutputStream getOutputStream() {
150         if (_writer != null) {
151             throw new IllegalStateException();
152         }
153 
154         if (_stream == null) {
155             _stream = createOutputStream();
156         }
157 
158         return _stream;
159     }
160 
161     public int getStatus() {
162         return _status;
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 sendError(int status) throws IOException {
196         _status = status;
197 
198         super.sendError(status);
199     }
200 
201     public void sendError(int status, String msg) throws IOException {
202         _status = status;
203 
204         super.sendError(status, msg);
205     }
206 
207     public void sendRedirect(String location) throws IOException {
208         super.sendRedirect(location);
209 
210         _status = SC_MOVED_TEMPORARILY;
211     }
212 
213     public void setBufferSize(int bufferSize) {
214         _bufferSize = bufferSize;
215     }
216 
217     public void setContentType(String contentType) {
218         _contentType = contentType;
219 
220         super.setContentType(contentType);
221     }
222 
223     public void setDateHeader(String name, long value) {
224         List<Header> values = new ArrayList<Header>();
225 
226         _headers.put(name, values);
227 
228         Header header = new Header();
229 
230         header.setType(Header.DATE_TYPE);
231         header.setDateValue(value);
232 
233         values.add(header);
234     }
235 
236     public void setHeader(String name, String value) {
237         List<Header> values = new ArrayList<Header>();
238 
239         _headers.put(name, values);
240 
241         Header header = new Header();
242 
243         header.setType(Header.STRING_TYPE);
244         header.setStringValue(value);
245 
246         values.add(header);
247 
248         if (name.equals(HttpHeaders.CONTENT_TYPE)) {
249             setContentType(value);
250         }
251     }
252 
253     public void setIntHeader(String name, int value) {
254         List<Header> values = new ArrayList<Header>();
255 
256         _headers.put(name, values);
257 
258         Header header = new Header();
259 
260         header.setType(Header.INTEGER_TYPE);
261         header.setIntValue(value);
262 
263         values.add(header);
264     }
265 
266     public void setStatus(int status) {
267         _status = status;
268 
269         super.setStatus(status);
270     }
271 
272     public byte[] unsafeGetData() {
273         finishResponse();
274 
275         return _ubaos.unsafeGetByteArray();
276     }
277 
278     protected CacheResponseStream createOutputStream() {
279         return new CacheResponseStream(_ubaos);
280     }
281 
282     private int _bufferSize;
283     private String _contentType;
284     private String _encoding;
285     private Map<String, List<Header>> _headers =
286         new HashMap<String, List<Header>>();
287     private int _status = HttpServletResponse.SC_OK;
288     private CacheResponseStream _stream;
289     private UnsyncByteArrayOutputStream _ubaos =
290         new UnsyncByteArrayOutputStream();
291     private PrintWriter _writer;
292 
293 }