From 576bdc0cc542da20480d0ea34ec2bb42011ec4f5 Mon Sep 17 00:00:00 2001 From: Kai Moritz Date: Sun, 20 Jun 2010 20:17:07 +0200 Subject: [PATCH 1/1] CachingInterceptor implementiert MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit * Interface Cacheable eingeführt. * CachingInterceptor implementiert und konfiguriert, der die HTTP/1.1-Caching-Header wie gewünscht setzt, wenn der Handler das Interface Cacheable implementiert. --- pom.xml | 174 +++++++++++++++++ web/pom.xml | 36 ++++ .../fotos/web/interceptors/Cacheable.java | 153 +++++++++++++++ .../web/interceptors/CachingInterceptor.java | 180 ++++++++++++++++++ 4 files changed, 543 insertions(+) create mode 100644 pom.xml create mode 100644 web/pom.xml create mode 100644 web/src/main/java/de/halbekunst/fotos/web/interceptors/Cacheable.java create mode 100644 web/src/main/java/de/halbekunst/fotos/web/interceptors/CachingInterceptor.java diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..b837bd96 --- /dev/null +++ b/pom.xml @@ -0,0 +1,174 @@ + + + + 4.0.0 + + de.halbekunst + fotos + 1.0-SNAPSHOT + Fotos + pom + http://www.halbekunst.de + + + 2.0.6 + + + + + kai + Kai Moritz + kai@ich-geh-kaputt.de + + + + + web + + + + + + UTF-8 + + + 4.8.1 + 1.2.15 + 2.5 + 1.5.11 + 3.0.4.RELEASE + + + + + + + + org.slf4j + slf4j-api + ${slf4j.version} + + + org.slf4j + jcl-over-slf4j + ${slf4j.version} + runtime + + + org.slf4j + slf4j-log4j12 + ${slf4j.version} + + + log4j + log4j + + + runtime + + + log4j + log4j + ${log4j.version} + + + javax.mail + mail + + + javax.jms + jms + + + com.sun.jdmk + jmxtools + + + com.sun.jmx + jmxri + + + runtime + + + + + junit + junit + ${junit.version} + test + + + + + + + + org.jboss.repository.maven + http://repository.jboss.org/maven2 + false + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + 1.6 + 1.6 + utf8 + true + + + + org.apache.maven.plugins + maven-dependency-plugin + + + install + install + + sources + + + + + + + + + + + maven-changes-plugin + + + maven-checkstyle-plugin + + + org.codehaus.mojo + cobertura-maven-plugin + 2.0 + + + maven-javadoc-plugin + + + maven-jxr-plugin + + + maven-pmd-plugin + + true + 1.5 + + + + maven-surefire-report-plugin + + + + + diff --git a/web/pom.xml b/web/pom.xml new file mode 100644 index 00000000..85e5bb42 --- /dev/null +++ b/web/pom.xml @@ -0,0 +1,36 @@ + + + + 4.0.0 + + + de.halbekunst + fotos + 1.0-SNAPSHOT + + + fotos-web + jar + Fotos - Webanwendung + + + + + + org.springframework + spring-webmvc + ${springframework.version} + + + + + javax.servlet + servlet-api + ${servlet-api.version} + provided + + + + + diff --git a/web/src/main/java/de/halbekunst/fotos/web/interceptors/Cacheable.java b/web/src/main/java/de/halbekunst/fotos/web/interceptors/Cacheable.java new file mode 100644 index 00000000..7cbb9433 --- /dev/null +++ b/web/src/main/java/de/halbekunst/fotos/web/interceptors/Cacheable.java @@ -0,0 +1,153 @@ +package de.halbekunst.fotos.web.interceptors; + + +import java.util.Map; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + + +/** + * Wenn ein Handler (i.A. eine Impelementierung von {@Controller}), + * dieses Interface implementiert, dann schreibt + * {@link CachingInterceptor} HTTP/1.1-Caching-Header nach + * {@linkplain http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html RFC 2616} + * in den Response. + * + * @see CachingInterceptor + * @author kai + */ +public interface Cacheable { + public boolean accepts(HttpServletRequest request); + + /** + * Wenn die Methode false zurückliefert, werden von + * {@link CachingDispatcherServlet#isRessourceModified(HttpServletRequest, HttpServletResponse, Cacheable)} + * keinerlei HTTP/1.1-Cache-Header in den Response eingebaut. + *

+ * Über diese Methode kann z.B. gesteuert werden, dass für eine bestimmte + * HTTP-Methode (z.B. POST) keine Cache-Header generiert werden. + * + * @see CachingDispatcherServlet + * @param request + * Der aktuelle HTTP-Request + * @return true, wenn Caching-Header in den Response geschrieben + * werden sollen, sonst false. + * @throws IllegalArgumentException + * Wenn zu dem Request keine Ressource existiert. + */ + public boolean isGenerateCacheHeaders(HttpServletRequest request) throws IllegalArgumentException; + + /** + * Diese Methode ermöglicht eine einfache, zentrale Steuerung des + * Caching-Verhaltens. + *

+ *

+ * Zu beachten: Wenn die Methode + * {@link #getCacheControll(javax.servlet.http.HttpServletRequest)} weitere + * Schlüssel-Wert-Paare für den Cache-Controll-Header liefert, + * werden diese ergänzt. Wenn in der Rückgabe ein Wert für + * max-age enthalten ist, wir er allerdings von dem durch diese + * Methode vorgegebenen Wert überschrieben! + * + * @see #getLastModified(javax.servlet.http.HttpServletRequest) + * @see #getCacheControll(javax.servlet.http.HttpServletRequest) + * @param request + * Der aktuelle HTTP-Request + * @return Die gewünschte Cache-Zeit in Sekunden, oder 0, wenn + * Caching aktiv unterbunden werden soll bzw. einen Wert kleiner + * 0, wenn kein Expires-Header generiert + * werden soll. + * @throws IllegalArgumentException + * Wenn zu dem Request keine Ressource existiert. + */ + public int getCacheSeconds(HttpServletRequest request) throws IllegalArgumentException; + + /** + * Zeitpunkt, zu dem die Ressource zuletzt verändert wurde. Erwartet wird eine + * Zeitangabe in Millisekunden seit dem Unix-0-Zeitpunkt, wie sie von + * {@link HttpServletResponse#setDateHeader(String, long)} erwartet wird. + *

+ * Zu beachten: + *

+ * + * @see #getCacheSeconds(javax.servlet.http.HttpServletRequest) + * @param request + * Der aktuelle HTTP-Request + * @return Zeitstempel, zu dem die Ressource zuletzt modifiziert wurde. + * @throws IllegalArgumentException + * Wenn zu dem Request keine Ressource existiert. + */ + public long getLastModified(HttpServletRequest request) throws IllegalArgumentException; + + /** + * Frei wählbares ETag nach {@linkplain http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.19 RFC 2616, + * Abschnitt 14.19 ETag}. Der ETag wird unverändert übernommen und muss den + * Bedingungen aus dem RFC 2616 entsprechen. Beispiele für erlaubte Werte: + * + * Merke: Der wert ist immer in doppelte Anführungszeichen + * einzuschließen! + *

+ * Zu beachten: + *

+ * + * @see #getCacheSeconds(javax.servlet.http.HttpServletRequest) + * @param request + * Der aktuelle HTTP-Request + * @return Das zu verwendende ETag, oder null, wenn der Header + * nicht generiert werden soll. + * @throws IllegalArgumentException + * Wenn zu dem Request keine Ressource existiert. + */ + public String getETag(HttpServletRequest request) throws IllegalArgumentException; + + /** + * Diese Methode liefert eine Map mit Schlüssel-Wert-Paaren für den + * HTTP/1.1-Header Cache-Controll (s. {@plainlink + * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3 RFC2616, + * Abschnitt 14.9.3}). + *

+ * Zu beachten: + *

+ * + * @see #getCacheSeconds(javax.servlet.http.HttpServletRequest) + * @param request + * Der aktuelle HTTP-Request + * @return Eine Map mit den Schlüssel-Wert-Paaren für den + * Cache-Controll-Header. + * @throws IllegalArgumentException + * Wenn zu dem Request keine Ressource existiert. + */ + public Map getCacheControll(HttpServletRequest request) throws IllegalArgumentException; +} diff --git a/web/src/main/java/de/halbekunst/fotos/web/interceptors/CachingInterceptor.java b/web/src/main/java/de/halbekunst/fotos/web/interceptors/CachingInterceptor.java new file mode 100644 index 00000000..00b093e3 --- /dev/null +++ b/web/src/main/java/de/halbekunst/fotos/web/interceptors/CachingInterceptor.java @@ -0,0 +1,180 @@ +package de.halbekunst.fotos.web.interceptors; + +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.web.servlet.HandlerInterceptor; +import org.springframework.web.servlet.ModelAndView; + +/** + * + * @author kai + */ +public class CachingInterceptor implements HandlerInterceptor { + private final static Logger log = LoggerFactory.getLogger(CachingInterceptor.class); + + public static final String HEADER_DATE = "Date"; + public static final String HEADER_CACHE_CONTROL = "Cache-Control"; + public static final String HEADER_LAST_MODIFIED = "Last-Modified"; + public static final String HEADER_ETAG = "ETag"; + public static final String HEADER_EXPIRES = "Expires"; + public static final String HEADER_PRAGMA = "Pragma"; + public static final String HEADER_IF_MODIFIED_SINCE = "If-Modified-Since"; + public static final String HEADER_IF_NONE_MATCH = "If-None-Match"; + + + @Override + public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { + try { + Cacheable cacheable = (Cacheable)handler; + + long now = System.currentTimeMillis(); + + /** + * Alle Antworten (insbesondere auch 304) sollen nach dem {@plainlink + * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18 RFC 2616, + * Abschnitt 14.18} einen Date-Header enthalten + */ + response.setDateHeader(HEADER_DATE, now); + + /** Prüfen, ob der Handler willig ist, den Request zu verarbeiten */ + if (!cacheable.accepts(request)) { + response.sendError(HttpServletResponse.SC_NOT_FOUND); + return false; + } + + /** Nichts weiter unternehmen, wenn der Handler dies nicht will */ + if (!cacheable.isGenerateCacheHeaders(request)) + return true; + + int cacheSeconds = cacheable.getCacheSeconds(request); + if (cacheSeconds == 0) { + response.setDateHeader(HEADER_DATE, now); + response.setDateHeader(HEADER_EXPIRES, 0); + response.addHeader(HEADER_PRAGMA, "no-cache"); + response.addHeader(HEADER_CACHE_CONTROL, "private"); + response.addHeader(HEADER_CACHE_CONTROL, "no-cache"); + response.addHeader(HEADER_CACHE_CONTROL, "no-store"); + response.addHeader(HEADER_CACHE_CONTROL, "max-age=0"); + response.addHeader(HEADER_CACHE_CONTROL, "s-max-age=0"); + return true; + } + + long ifModifiedSince = request.getDateHeader(HEADER_IF_MODIFIED_SINCE); + long lastModified = cacheable.getLastModified(request); + + /** + * Sicherstellen, dass der Wert keine Millisekunden enthält, da die + * Zeitangabe aus dem Modified-Since-Header keine Millisekunden enthalten + * kann und der Test unten dann stets fehlschlagen würde! + */ + lastModified = lastModified - (lastModified % 1000); + + String ifNoneMatch = request.getHeader(HEADER_IF_NONE_MATCH); + String eTag = cacheable.getETag(request); + + /** + * 304-Antworten sollen nach dem {@plainlink + * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5 RFC + * 2616, Abschnitt 10.3.5} einen ETag-Header enthalten, wenn auch die + * 200-Antwort einen enthalten hätte. + */ + if (eTag != null) { + response.setHeader(HEADER_ETAG, eTag); + } + + + if (ifModifiedSince >= lastModified) { + /** + * request.getDateHeader liefert die Zeit als long, oder -1, wenn der + * Header nicht existiert. D.h., wenn "If-Modified-Since" nicht gesetzt + * ist, wird die komplette Seite ausgeliefert. + */ + if (log.isDebugEnabled()) + log.debug("Not modified since {}: {}", new Date(ifModifiedSince), request.getRequestURI()); + + if (ifNoneMatch == null) { + /** Neue Anfrage oder HTTP/1.0 Client! */ + log.debug("ETag nicht gesetzt: 304 {}", request.getRequestURI()); + response.setStatus(HttpServletResponse.SC_NOT_MODIFIED); + return false; + } + else { + if (ifNoneMatch.equals(eTag)) { + log.debug("ETag {} not changed: 304 {}", ifNoneMatch, request.getRequestURI()); + response.setStatus(HttpServletResponse.SC_NOT_MODIFIED); + return false; + } + } + } + + /** HTTP/1.1-Caching-Header richtig setzen!! */ + response.setDateHeader(HEADER_LAST_MODIFIED, lastModified); + + /** Cache-Control für HTTP/1.1-Clients generieren */ + Map cacheControl = new HashMap(cacheable.getCacheControll(request)); + + /** + * Wenn eins JSESSIONID in der URL enthalten ist, darf die Anfrage nur vom + * Browser gecached werden! + */ + if (request.isRequestedSessionIdFromURL()) { + cacheSeconds = 0; + cacheControl.put("private", null); + } + + if (cacheControl.containsKey("private")) { + /** + * HTTP/1.0 Caches davon abhalten, die Ressource zu cachen (vgl.: RFC + * 2616, {@plainlink + * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3 + * Abschnitt 14.9.3} und {@plainlink + * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.32 + * Abschnitt 14.32}) + */ + response.setDateHeader(HEADER_EXPIRES, 0l); + response.addHeader(HEADER_PRAGMA, "no-cache"); + } + else { + /** + * Hier muss nicht geprüft werden, ob cacheSeconds > 0 gilt, da in diesem + * Fall oben bereits No-Cache-Header generiert und false + * zurückgeliefert werden! + * + * Den Wert als max-age zu den Schlüssel-Wert-Paaren für den + * Cache-Controll-Header hinzufügen und einen entsprechenden + * Expires-Header für HTTP/1.0-Clients setzen. + */ + cacheControl.put("max-age", Integer.toString(cacheSeconds)); + response.setDateHeader(HEADER_EXPIRES, (now + cacheSeconds * 1000)); + } + + StringBuilder builder = new StringBuilder(); + for (Entry entry : cacheControl.entrySet()) { + builder.setLength(0); + builder.append(entry.getKey()); + if (entry.getValue() != null) { + builder.append('='); + builder.append(entry.getValue()); + } + response.addHeader(HEADER_CACHE_CONTROL, builder.toString()); + } + + return true; + } + catch (ClassCastException e) { + return true; + } + } + + @Override + public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {} + + @Override + public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {} +} -- 2.20.1