* 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.
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <groupId>de.halbekunst</groupId>
+ <artifactId>fotos</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ <name>Fotos</name>
+ <packaging>pom</packaging>
+ <url>http://www.halbekunst.de</url>
+
+ <prerequisites>
+ <maven>2.0.6</maven>
+ </prerequisites>
+
+ <developers>
+ <developer>
+ <id>kai</id>
+ <name>Kai Moritz</name>
+ <email>kai@ich-geh-kaputt.de</email>
+ </developer>
+ </developers>
+
+ <modules>
+ <module>web</module>
+ </modules>
+
+ <properties>
+
+ <!-- Zeichensatz -->
+ <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+
+ <!-- Verwendete Versionen -->
+ <junit.version>4.8.1</junit.version>
+ <log4j.version>1.2.15</log4j.version>
+ <servlet-api.version>2.5</servlet-api.version>
+ <slf4j.version>1.5.11</slf4j.version>
+ <springframework.version>3.0.4.RELEASE</springframework.version>
+
+ </properties>
+
+ <dependencies>
+
+ <!-- Logging -->
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-api</artifactId>
+ <version>${slf4j.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>jcl-over-slf4j</artifactId>
+ <version>${slf4j.version}</version>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.slf4j</groupId>
+ <artifactId>slf4j-log4j12</artifactId>
+ <version>${slf4j.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>log4j</groupId>
+ <artifactId>log4j</artifactId>
+ </exclusion>
+ </exclusions>
+ <scope>runtime</scope>
+ </dependency>
+ <dependency>
+ <groupId>log4j</groupId>
+ <artifactId>log4j</artifactId>
+ <version>${log4j.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>javax.mail</groupId>
+ <artifactId>mail</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>javax.jms</groupId>
+ <artifactId>jms</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>com.sun.jdmk</groupId>
+ <artifactId>jmxtools</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>com.sun.jmx</groupId>
+ <artifactId>jmxri</artifactId>
+ </exclusion>
+ </exclusions>
+ <scope>runtime</scope>
+ </dependency>
+
+ <!-- Test -->
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>${junit.version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ </dependencies>
+
+ <repositories>
+ <!-- For JSR 303, Hibernate Validator and other Hibernate-Stuff - Encourage JBoss to publish these artifacts to Maven Central! -->
+ <repository>
+ <id>org.jboss.repository.maven</id>
+ <url>http://repository.jboss.org/maven2</url>
+ <snapshots><enabled>false</enabled></snapshots>
+ </repository>
+ </repositories>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.6</source>
+ <target>1.6</target>
+ <encoding>utf8</encoding>
+ <showWarnings>true</showWarnings>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>install</id>
+ <phase>install</phase>
+ <goals>
+ <goal>sources</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+
+ <reporting>
+ <plugins>
+ <plugin>
+ <artifactId>maven-changes-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>cobertura-maven-plugin</artifactId>
+ <version>2.0</version>
+ </plugin>
+ <plugin>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <artifactId>maven-jxr-plugin</artifactId>
+ </plugin>
+ <plugin>
+ <artifactId>maven-pmd-plugin</artifactId>
+ <configuration>
+ <linkXref>true</linkXref>
+ <targetJdk>1.5</targetJdk>
+ </configuration>
+ </plugin>
+ <plugin>
+ <artifactId>maven-surefire-report-plugin</artifactId>
+ </plugin>
+ </plugins>
+ </reporting>
+
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>de.halbekunst</groupId>
+ <artifactId>fotos</artifactId>
+ <version>1.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>fotos-web</artifactId>
+ <packaging>jar</packaging>
+ <name>Fotos - Webanwendung</name>
+
+ <dependencies>
+
+ <!-- Spring -->
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-webmvc</artifactId>
+ <version>${springframework.version}</version>
+ </dependency>
+
+ <!-- Servlet -->
+ <dependency>
+ <groupId>javax.servlet</groupId>
+ <artifactId>servlet-api</artifactId>
+ <version>${servlet-api.version}</version>
+ <scope>provided</scope>
+ </dependency>
+
+ </dependencies>
+
+</project>
--- /dev/null
+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 <code>false</code> zurückliefert, werden von
+ * {@link CachingDispatcherServlet#isRessourceModified(HttpServletRequest, HttpServletResponse, Cacheable)}
+ * keinerlei HTTP/1.1-Cache-Header in den Response eingebaut.
+ * <p>
+ * Ü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 <code>true</code>, wenn Caching-Header in den Response geschrieben
+ * werden sollen, sonst <code>false</code>.
+ * @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.
+ * <ul>
+ * <li>Wenn die Methode den Wert <code>0</code> (oder einen anderen Wert
+ * kleiner <code>1</code>) zurückliefert, werden Cache-Header erzeugt, die das
+ * Cachen der Antwort für HTTP/1.0 und HTTP/1.1 vollständig untersagen,</li>
+ * <li>Wenn die Methode einen Wert größer <code>0</code> zurückliefert, wird
+ * ein für HTTP/1.0-Clients ein <code>Expires</code>-Header generiert und für
+ * HTTP/1.1-Clients ein <code>Cache-Controll</code>-Header mit einem
+ * entsprechenden <code>max-age</code>-Eintrag. Dies reicht in Kombination mit
+ * einem sinnvollen Rückgabewert der Methode
+ * {@link #getLastModified(javax.servlet.http.HttpServletRequest)} vollständig
+ * für ein einfaches Caching aus.</li>
+ * </ul>
+ * <p>
+ * <strong>Zu beachten:</strong> Wenn die Methode
+ * {@link #getCacheControll(javax.servlet.http.HttpServletRequest)} weitere
+ * Schlüssel-Wert-Paare für den <code>Cache-Controll</code>-Header liefert,
+ * werden diese ergänzt. Wenn in der Rückgabe ein Wert für
+ * <code>max-age</code> 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 <code>0</code>, wenn
+ * Caching aktiv unterbunden werden soll bzw. einen Wert kleiner
+ * <code>0</code>, wenn kein <code>Expires</code>-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.
+ * <p>
+ * <strong>Zu beachten:</strong>
+ * <ul>
+ * <li>Diese Methode wird nicht aufgerufen, wenn
+ * {@link #getCacheSeconds(javax.servlet.http.HttpServletRequest)}
+ * <code>0</code> liefert.</li>
+ * </ul>
+ *
+ * @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:
+ * <ul>
+ * <li><code>"24afh2w3848adf"</code>
+ * <li><code>W/"839482"</code>
+ * <li><code>""</code>
+ * </ul>
+ * <strong>Merke:</strong> Der wert ist immer in doppelte Anführungszeichen
+ * einzuschließen!
+ * <p>
+ * <strong>Zu beachten:</strong>
+ * <ul>
+ * <li>Diese Methode wird nicht aufgerufen, wenn
+ * {@link #getCacheSeconds(javax.servlet.http.HttpServletRequest)}
+ * <code>0</code> liefert.</li>
+ * </ul>
+ *
+ * @see #getCacheSeconds(javax.servlet.http.HttpServletRequest)
+ * @param request
+ * Der aktuelle HTTP-Request
+ * @return Das zu verwendende ETag, oder <code>null</code>, 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 <code>Cache-Controll</code> (s. {@plainlink
+ * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3 RFC2616,
+ * Abschnitt 14.9.3}).
+ * <p>
+ * <strong>Zu beachten:</strong>
+ * <ul>
+ * <li>Die Methode darf nie <code>null</code> zurückliefern!</li>
+ * <li>Ein Wert für den Schlüssel <code>max-age</code> wird überschrieben,
+ * wenn die Methode
+ * {@link #getCacheSeconds(javax.servlet.http.HttpServletRequest)} einen Wert
+ * größer <code>0</code> zurückliefert.</li>
+ * <li>Diese Methode wird nicht aufgerufen, wenn
+ * {@link #getCacheSeconds(javax.servlet.http.HttpServletRequest)}
+ * <code>0</code> liefert.</li>
+ * </ul>
+ *
+ * @see #getCacheSeconds(javax.servlet.http.HttpServletRequest)
+ * @param request
+ * Der aktuelle HTTP-Request
+ * @return Eine <code>Map</code> mit den Schlüssel-Wert-Paaren für den
+ * <code>Cache-Controll</code>-Header.
+ * @throws IllegalArgumentException
+ * Wenn zu dem Request keine Ressource existiert.
+ */
+ public Map<String, String> getCacheControll(HttpServletRequest request) throws IllegalArgumentException;
+}
--- /dev/null
+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<String, String> cacheControl = new HashMap<String, String>(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 <code>false</code>
+ * zurückgeliefert werden!
+ *
+ * Den Wert als <code>max-age</code> zu den Schlüssel-Wert-Paaren für den
+ * <code>Cache-Controll</code>-Header hinzufügen und einen entsprechenden
+ * <code>Expires</code>-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<String, String> 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 {}
+}
projects / percentcodec / commitdiff