package de.halbekunst.juplo.cachecontrol;
import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import javax.servlet.ServletOutputStream;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
+import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import javax.servlet.http.HttpServletResponseWrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Configurable;
+import org.springframework.beans.factory.annotation.Qualifier;
private final static Map<String,String> EMPTY = Collections.unmodifiableMap(new HashMap<String,String>());
+ public final static Integer DEFAULT_BUFFER_SIZE = 1024;
public final static String REQUEST_URI_ATTRIBUTE = "javax.servlet.include.request_uri";
public final static String RESPONSE_WRAPPER = AcceleratorFilter.class.getName() + ".RESPONSE_WRAPPER";
@Autowired CacheControl cacheControl;
- @Autowired(required=true) Integer buffer;
- @Autowired(required=true) String eTag;
- @Autowired(required=true) Boolean weak;
- @Autowired(required=true) Long lastModified;
- @Autowired(required=true) Integer cacheSeconds;
+ @Autowired(required=false) @Qualifier("defaultBufferSize") Integer defaultBufferSize = DEFAULT_BUFFER_SIZE;
+ @Autowired String eTag;
+ @Autowired Boolean weak;
+ @Autowired Long lastModified;
+ @Autowired Integer cacheSeconds;
@Override
return;
}
- /** Prüfen, ob es sich um eine Anfrage für einen JSP-Include handelt */
- if (request.getAttribute(REQUEST_URI_ATTRIBUTE) != null) {
- log.debug("Includes cannot be accelerated");
- chain.doFilter(request, response);
- return;
- }
-
HttpServletRequest httpRequest = (HttpServletRequest)request;
HttpServletResponse httpResponse = (HttpServletResponse)response;
AccelerationWrapper wrapper = new AccelerationWrapper(httpRequest, httpResponse);
httpRequest.setAttribute(RESPONSE_WRAPPER, wrapper);
cacheControl.init(wrapper);
- chain.doFilter(request, wrapper);
- /** Dekoration auslösen, falls sie bisher nicht ausgelöst wurde... */
- cacheControl.decorate(httpRequest, httpResponse, wrapper);
+ try {
+ chain.doFilter(request, wrapper);
+ wrapper.finish();
+ }
+ catch (NotModifiedException nm) {
+ log.trace("Not modified: {}", httpRequest.getRequestURI());
+ }
}
@Override
}
- class AccelerationWrapper extends HttpServletResponseWrapper implements CacheMethodHandle {
+ class AccelerationWrapper implements HttpServletResponse, CacheMethodHandle {
private final HttpServletRequest request;
private final HttpServletResponse response;
- boolean zipped; // CacheControll greift direkt auf dieses Flag zu!
+ private final AcceleratorServletOutputStream out;
- private CountingServletOutputStream out;
private ServletOutputStream stream;
private PrintWriter writer;
private boolean guessing = true;
+ protected boolean zipped = false; // << CacheControll greift direkt auf diese Variable zu!
private long now;
private int status;
private boolean weak;
private Map<String,String> cacheParams;
+ /** Für den AcceleratorOutputStream */
+ private boolean committed = false;
+ private OutputStream os = null;
+ private int bufferSize;
+ private byte[] buffer;
+ private int pos = 0;
+ private int size = 0;
+
+
AccelerationWrapper(HttpServletRequest request, HttpServletResponse response) throws IOException {
- super(response);
this.request = request;
this.response = response;
weak = AcceleratorFilter.this.weak;
cacheParams = new HashMap<String,String>();
- zipped = false;
Enumeration values = request.getHeaders(Headers.HEADER_ACCEPT_ENCODING);
while (values.hasMoreElements()) {
String value = (String) values.nextElement();
break;
}
}
- if (zipped)
- out = new GZIPServletOutputStream();
- else
- out = new WrappedServletOutputStream();
+
+ out = new AcceleratorServletOutputStream();
}
+ private void finish() throws IOException {
+ flushBuffer();
+ out.close();
+ }
+
@Override
public void setStatus(int sc) {
response.setStatus(sc);
status = sc;
- try {
- cacheControl.decorate(request, response, this);
- }
- catch (Exception e) {
- log.error("Error while decorating response", e);
- }
}
@Override
public void setStatus(int sc, String sm) {
response.setStatus(sc,sm);
status = sc;
- try {
- cacheControl.decorate(request, response, this);
- }
- catch (Exception e) {
- log.error("Error while decorating response", e);
- }
}
@Override
public void addDateHeader(String name, long value) {
if (!guessing) {
- super.addDateHeader(name, value);
+ response.addDateHeader(name, value);
return;
}
}
/** Unknown header: pass throug! */
- super.addDateHeader(name, value);
+ response.addDateHeader(name, value);
}
@Override
public void addHeader(String name, String value) {
if (!guessing) {
- super.addHeader(name, value);
+ response.addHeader(name, value);
return;
}
public void addIntHeader(String name, int value) {
if (!guessing) {
- super.addIntHeader(name, value);
+ response.addIntHeader(name, value);
return;
}
public void setDateHeader(String name, long value) {
if (!guessing) {
- super.setDateHeader(name, value);
+ response.setDateHeader(name, value);
return;
}
}
/** Unknown header: pass throug! */
- super.setDateHeader(name, value);
+ response.setDateHeader(name, value);
}
@Override
public void setHeader(String name, String value) {
if (!guessing) {
- super.setHeader(name, value);
+ response.setHeader(name, value);
return;
}
public void setIntHeader(String name, int value) {
if (!guessing) {
- super.setIntHeader(name, value);
+ response.setIntHeader(name, value);
return;
}
throw new IllegalStateException("ServletOutputStream and PrintWriter cannot be requested both!");
if (writer == null) {
- writer = new PrintWriter(out);
+ writer = new PrintWriter(new OutputStreamWriter(out, response.getCharacterEncoding()));
}
return writer;
}
@Override
- public void setBufferSize(int size) {
-
- out.setBuffer(size);
- response.setBufferSize(size);
+ public int getBufferSize() {
+ return bufferSize;
}
@Override
- public void flushBuffer() throws IOException {
-
- cacheControl.decorate(request, response, this);
- response.flushBuffer();
+ public void setBufferSize(int size) {
+ if (this.size > 0)
+ throw new IllegalStateException("cannot change buffer size, because content was already written!");
+ bufferSize = size;
+ buffer = new byte[size];
}
@Override
public void resetBuffer() {
-
- response.resetBuffer();
+ if (committed)
+ throw new IllegalStateException("cannot reset buffer, because response is already commited!");
+ pos = 0;
stream = null;
writer = null;
}
@Override
public void reset() {
-
+ if (committed)
+ throw new IllegalStateException("cannot reset response, because response is already commited!");
+ /**
+ * Da committed==false gilt, wurde die Dekoration noch nicht angestßen
+ * und muss entsprechend auch nicht rückgängig gemacht werden!
+ */
response.reset();
- try {
- if (zipped)
- out = new GZIPServletOutputStream();
- else
- out = new WrappedServletOutputStream();
- }
- catch (IOException e) {
- throw new IllegalStateException(e);
- }
+ pos = 0;
+ size = 0;
stream = null;
writer = null;
+ }
+
+ @Override
+ public void flushBuffer() throws IOException {
+ if (writer != null)
+ writer.flush();
+ else if (stream != null)
+ stream.flush();
+ }
+
+ @Override
+ public void addCookie(Cookie cookie) {
+ // TODO: Je nach Vary-Einstellung ETag anpassen?
+ response.addCookie(cookie);
+ }
+
+ @Override
+ public boolean containsHeader(String name) {
+ return response.containsHeader(name);
+ }
+
+ @Override
+ public String encodeURL(String url) {
+ return response.encodeURL(url);
+ }
+
+ @Override
+ public String encodeRedirectURL(String url) {
+ return response.encodeRedirectURL(url);
+ }
+
+ @Override
+ public String encodeUrl(String url) {
+ return response.encodeUrl(url);
+ }
+
+ @Override
+ public String encodeRedirectUrl(String url) {
+ return response.encodeRedirectUrl(url);
+ }
- /** Cookies has been cleared! Reinitialize decorator... */
- cacheControl.init(this);
+ @Override
+ public void sendError(int sc, String msg) throws IOException {
+ response.sendError(sc,msg);
+ }
+
+ @Override
+ public void sendError(int sc) throws IOException {
+ response.sendError(sc);
+ }
+
+ @Override
+ public void sendRedirect(String location) throws IOException {
+ response.sendRedirect(location);
+ }
+
+ @Override
+ public String getCharacterEncoding() {
+ return response.getCharacterEncoding();
+ }
+
+ @Override
+ public String getContentType() {
+ return response.getContentType();
+ }
+
+ @Override
+ public void setCharacterEncoding(String charset) {
+ // TODO: Je nach Vary-Einstellung ETag anpassen?
+ response.setCharacterEncoding(charset);
+ }
+
+ @Override
+ public void setContentType(String type) {
+ // TODO: Je nach Vary-Einstellung ETag anpassen?
+ response.setContentType(type);
+ }
+
+ @Override
+ public boolean isCommitted() {
+ return committed;
+ }
+
+ @Override
+ public void setLocale(Locale loc) {
+ // TODO: Je nach Vary-Einstellung ETag anpassen?
+ response.setLocale(loc);
+ }
+
+ @Override
+ public Locale getLocale() {
+ return getLocale();
}
@Override
public boolean isZipped() {
- return out.isZipped();
+ return zipped;
}
@Override
/** Pass header through, if no value from intrest was found */
if (overwrite)
- super.setHeader(name, value);
+ response.setHeader(name, value);
else
- super.addHeader(name, value);
+ response.addHeader(name, value);
}
private void calculateCacheSeconds() {
}
- abstract class CountingServletOutputStream extends ServletOutputStream {
-
- abstract void setBuffer(int size) throws IllegalStateException;
- abstract boolean isZipped();
- }
-
-
- final class GZIPServletOutputStream extends CountingServletOutputStream {
-
- final static int MINMAL_BUFFER_SIZE = 128;
-
+ private class AcceleratorServletOutputStream extends ServletOutputStream {
- private final GZIPOutputStream out;
- private int buffer, left;
- private boolean empty;
+ private final ServletOutputStream sos;
- public GZIPServletOutputStream() throws IOException {
- this.out = new GZIPOutputStream(response.getOutputStream());
- empty = true;
- setBuffer(AcceleratorFilter.this.buffer);
- left = buffer;
+ private AcceleratorServletOutputStream() throws IOException {
+ bufferSize = defaultBufferSize;
+ buffer = new byte[bufferSize];
+ sos = AccelerationWrapper.this.response.getOutputStream();
}
- @Override
- boolean isZipped() {
- return !empty;
+ private OutputStream out() throws IOException {
+ if (os == null)
+ os = zipped ? new GZIPOutputStream(sos) : sos;
+ return os;
}
@Override
- void setBuffer(int size) {
- if (!empty)
- throw new IllegalStateException("attemp to change buffer size after writing data to response!");
-
- if (size > MINMAL_BUFFER_SIZE) {
- buffer = size;
- left = buffer;
- }
- }
-
-
- @Override
- public void close() throws IOException {
- try {
- AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
- }
- catch (Exception e) {
- log.error("Error while guessing Cache-Header's", e);
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ public void write(int i) throws IOException {
+ if (pos == bufferSize) {
+ out().write(buffer);
+ committed = true;
+ /** Dekoration nur beim ersten Schreib-Schub anstoßen */
+ if (pos == size) {
+ if (!cacheControl.decorate(request, response)) {
+ zipped = false;
+ os = null;
+ pos = 0;
+ throw new NotModifiedException();
+ }
+ }
+ pos = 0;
}
-
- out.close();
+ buffer[pos++] = (byte) i;
+ size++;
}
@Override
public void flush() throws IOException {
- try {
- AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
- }
- catch (Exception e) {
- log.error("Error while guessing Cache-Header's", e);
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
- }
-
- out.flush();
- }
+ if (pos == 0)
+ return;
- @Override
- public void write(int i) throws IOException {
- if (left == 0) {
- try {
- AcceleratorFilter.this.cacheControl.decorate(AccelerationWrapper.this.request, response, AccelerationWrapper.this);
- }
- catch (Exception e) {
- log.error("Error while guessing Cache-Header's", e);
- response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+ committed = true;
+ /** Dekoration nur beim ersten Schreib-Schub anstoßen */
+ if (pos == size) {
+ if (!cacheControl.decorate(request, response)) {
+ zipped = false;
+ os = null;
+ pos = 0;
+ throw new NotModifiedException();
}
}
- empty = false;
- left--;
- out.write(i);
- }
- }
-
-
- final class WrappedServletOutputStream extends CountingServletOutputStream {
-
- private final ServletOutputStream out;
- private boolean empty;
-
-
- public WrappedServletOutputStream() throws IOException {
- this.out = response.getOutputStream();
- empty = true;
- }
-
-
- @Override
- boolean isZipped() {
- return false;
+ out().write(buffer, 0, pos);
+ out().flush();
+ pos = 0;
}
- @Override
- void setBuffer(int size) {
- if (!empty)
- throw new IllegalStateException("attemp to change buffer size after writing data to response!");
- }
-
-
@Override
public void close() throws IOException {
- out.close();
- }
-
- @Override
- public void flush() throws IOException {
- out.flush();
- }
-
- @Override
- public void write(int i) throws IOException {
- empty = false;
- out.write(i);
+ if (size == 0) {
+ committed = true;
+ zipped = false;
+ if (!cacheControl.decorate(request, response))
+ throw new NotModifiedException();
+ sos.close();
+ }
+ else {
+ flush();
+ out().close();
+ }
}
}
}
}
+
+class NotModifiedException extends IOException {}
\ No newline at end of file