1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
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 setBufferSize(int bufferSize) {
208         _bufferSize = bufferSize;
209     }
210 
211     public void setContentType(String contentType) {
212         _contentType = contentType;
213 
214         super.setContentType(contentType);
215     }
216 
217     public void setDateHeader(String name, long value) {
218         List<Header> values = new ArrayList<Header>();
219 
220         _headers.put(name, values);
221 
222         Header header = new Header();
223 
224         header.setType(Header.DATE_TYPE);
225         header.setDateValue(value);
226 
227         values.add(header);
228     }
229 
230     public void setHeader(String name, String value) {
231         List<Header> values = new ArrayList<Header>();
232 
233         _headers.put(name, values);
234 
235         Header header = new Header();
236 
237         header.setType(Header.STRING_TYPE);
238         header.setStringValue(value);
239 
240         values.add(header);
241 
242         if (name.equals(HttpHeaders.CONTENT_TYPE)) {
243             setContentType(value);
244         }
245     }
246 
247     public void setIntHeader(String name, int value) {
248         List<Header> values = new ArrayList<Header>();
249 
250         _headers.put(name, values);
251 
252         Header header = new Header();
253 
254         header.setType(Header.INTEGER_TYPE);
255         header.setIntValue(value);
256 
257         values.add(header);
258     }
259 
260     public void setStatus(int status) {
261         _status = status;
262 
263         super.setStatus(status);
264     }
265 
266     public byte[] unsafeGetData() {
267         finishResponse();
268 
269         return _ubaos.unsafeGetByteArray();
270     }
271 
272     protected CacheResponseStream createOutputStream() {
273         return new CacheResponseStream(_ubaos);
274     }
275 
276     private int _bufferSize;
277     private String _contentType;
278     private String _encoding;
279     private Map<String, List<Header>> _headers =
280         new HashMap<String, List<Header>>();
281     private int _status = HttpServletResponse.SC_OK;
282     private CacheResponseStream _stream;
283     private UnsyncByteArrayOutputStream _ubaos =
284         new UnsyncByteArrayOutputStream();
285     private PrintWriter _writer;
286 
287 }