juplo.de Git - percentcodec/blob - cachecontrol/src/main/java/de/halbekunst/juplo/cachecontrol/CacheControlInterceptor.java

   1 package de.halbekunst.juplo.cachecontrol;
   2
   3 import java.util.Date;
   4 import java.util.HashMap;
   5 import java.util.Map;
   6 import java.util.Map.Entry;
   7 import javax.servlet.http.HttpServletRequest;
   8 import javax.servlet.http.HttpServletResponse;
   9 import org.slf4j.Logger;
  10 import org.slf4j.LoggerFactory;
  11 import org.springframework.web.servlet.HandlerInterceptor;
  12 import org.springframework.web.servlet.ModelAndView;
  13
  14 /**
  15  *
  16  * @author kai
  17  */
  18 public class CacheControlInterceptor implements HandlerInterceptor {
  19   private final static Logger log = LoggerFactory.getLogger(CacheControlInterceptor.class);
  20
  21   public static final String HEADER_DATE = "Date";
  22   public static final String HEADER_CACHE_CONTROL = "Cache-Control";
  23   public static final String HEADER_LAST_MODIFIED = "Last-Modified";
  24   public static final String HEADER_ETAG = "ETag";
  25   public static final String HEADER_EXPIRES = "Expires";
  26   public static final String HEADER_PRAGMA = "Pragma";
  27   public static final String HEADER_IF_MODIFIED_SINCE = "If-Modified-Since";
  28   public static final String HEADER_IF_NONE_MATCH = "If-None-Match";
  29
  30
  31   @Override
  32   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  33     if (!(handler instanceof Cacheable))
  34       return true;
  35
  36     Cacheable cacheable = (Cacheable) handler;
  37
  38     long now = System.currentTimeMillis();
  39
  40     /**
  41      * Alle Antworten (insbesondere auch 304) sollen nach dem {@plainlink
  42      * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18 RFC 2616,
  43      * Abschnitt 14.18} einen Date-Header enthalten
  44      */
  45     response.setDateHeader(HEADER_DATE, now);
  46
  47     /** Prüfen, ob der Handler willig ist, den Request zu verarbeiten */
  48     if (!cacheable.accepts(request)) {
  49       response.sendError(HttpServletResponse.SC_NOT_FOUND);
  50       return false;
  51     }
  52
  53     /** Nichts weiter unternehmen, wenn der Handler dies nicht will */
  54     if (!cacheable.isGenerateCacheHeaders(request))
  55       return true;
  56
  57     String url = null;
  58     if (log.isDebugEnabled()) {
  59       if (request.getQueryString() == null) {
  60         url = request.getRequestURI();
  61       }
  62       else {
  63         StringBuilder builder = new StringBuilder();
  64         builder.append(request.getRequestURI());
  65         builder.append('?');
  66         builder.append(request.getQueryString());
  67         url = builder.toString();
  68       }
  69     }
  70
  71     int cacheSeconds = cacheable.getCacheSeconds(request);
  72     if (cacheSeconds < 0) {
  73       log.debug("{}: caching disabled!", url);
  74       response.setDateHeader(HEADER_DATE, now);
  75       response.setDateHeader(HEADER_EXPIRES, 0);
  76       response.addHeader(HEADER_PRAGMA, "no-cache");
  77       response.addHeader(HEADER_CACHE_CONTROL, "private");
  78       response.addHeader(HEADER_CACHE_CONTROL, "no-cache");
  79       response.addHeader(HEADER_CACHE_CONTROL, "no-store");
  80       response.addHeader(HEADER_CACHE_CONTROL, "max-age=0");
  81       response.addHeader(HEADER_CACHE_CONTROL, "s-max-age=0");
  82       return true;
  83     }
  84
  85     long ifModifiedSince = -1;
  86     try {
  87       ifModifiedSince = request.getDateHeader(HEADER_IF_MODIFIED_SINCE);
  88     }
  89     catch (Exception e) {
  90       log.error("Exception while fetching If-Modified-Since: {}", e);
  91     }
  92
  93     long lastModified = cacheable.getLastModified(request);
  94
  95     /**
  96      * Sicherstellen, dass der Wert keine Millisekunden enthält, da die
  97      * Zeitangabe aus dem Modified-Since-Header keine Millisekunden enthalten
  98      * kann und der Test unten dann stets fehlschlagen würde!
  99      */
 100     lastModified = lastModified - (lastModified % 1000);
 101
 102     /**
 103      * Cache-Control für HTTP/1.1-Clients generieren und setzen
 104      *
 105      * Nach {@plainlink http://tools.ietf.org/html/draft-ietf-httpbis-p4-conditional-18#section-4.1
 106      * "HTTP/1.1, part 4: Conditional Requests",
 107      * Abschnitt 4.1 "304 Not Modified" (Achtung: Entwurf -> work in progress!)}
 108      * <strong>müssen</strong> die folgenden Felder in einer 304-Antwort
 109      * enthalten sein, wenn sie auch in der ursprünglichen Antwort enthalten
 110      * waren:
 111      * <ul>
 112      * <li>Cache-Control</li>
 113      * <li>ETag</li>
 114      * <li>Expires</li>
 115      * <li>Last-Modified</li>
 116      * <li>Vary</li>
 117      * </ul>
 118      */
 119
 120     /**
 121      * Der Last-Modified-Header sollte (darf?) eventuell eigntlich nur für
 122      * 200-Antworten gesetzt werden
 123      * (s. http://webmasters.stackexchange.com/questions/25520/should-30)
 124      *
 125      * Da Squid sonst scheinbar nicht korrekt cached (und per if-not-modified
 126      * aktualisiert) wird der Header aber trotzdem erst mal weiter erzeugt!
 127      * (Ggf. noch mal prüfen, ob es eine Sinnestäuschung war, dass Squid
 128      * Resourcen öfter als nötig komplett neu holt, wenn dieser Header fehlt!)
 129      */
 130     response.setDateHeader(HEADER_LAST_MODIFIED, lastModified);
 131
 132     Map<String, String> cacheControl = new HashMap<String, String>(cacheable.getCacheControl(request));
 133
 134     /**
 135      * Wenn eins JSESSIONID in der URL enthalten ist, darf die Anfrage nur vom
 136      * Browser gecached werden!
 137      */
 138     if (request.isRequestedSessionIdFromURL())
 139       cacheControl.put("private", null);
 140
 141     if (cacheControl.containsKey("private")) {
 142       /**
 143        * HTTP/1.0 Caches davon abhalten, die Ressource zu cachen (vgl.: RFC
 144        * 2616, {@plainlink
 145        * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3
 146        * Abschnitt 14.9.3} und {@plainlink
 147        * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.32
 148        * Abschnitt 14.32})
 149        */
 150       response.setDateHeader(HEADER_EXPIRES, 0l);
 151       /** response.addHeader(HEADER_PRAGMA, "no-cache"); */
 152     } else {
 153       /**
 154        * Hier muss nicht geprüft werden, ob cacheSeconds > 0 gilt, da in diesem
 155        * Fall oben bereits No-Cache-Header generiert und <code>false</code>
 156        * zurückgeliefert werden!
 157        *
 158        * Den Wert als <code>max-age</code> zu den Schlüssel-Wert-Paaren für den
 159        * <code>Cache-Control</code>-Header hinzufügen und einen entsprechenden
 160        * <code>Expires</code>-Header für HTTP/1.0-Clients setzen.
 161        */
 162       cacheControl.put("max-age", Integer.toString(cacheSeconds));
 163       response.setDateHeader(HEADER_EXPIRES, (now + (long) cacheSeconds * 1000));
 164     }
 165
 166     StringBuilder builder = new StringBuilder();
 167     for (Entry<String, String> entry : cacheControl.entrySet()) {
 168       builder.setLength(0);
 169       builder.append(entry.getKey());
 170       if (entry.getValue() != null) {
 171         builder.append('=');
 172         builder.append(entry.getValue());
 173       }
 174       response.addHeader(HEADER_CACHE_CONTROL, builder.toString());
 175     }
 176
 177
 178     String ifNoneMatch = request.getHeader(HEADER_IF_NONE_MATCH);
 179     String eTag = cacheable.getETag(request);
 180
 181     /**
 182      * 304-Antworten sollen nach dem {@plainlink
 183      * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5 RFC
 184      * 2616, Abschnitt 10.3.5} einen ETag-Header enthalten, wenn auch die
 185      * 200-Antwort einen enthalten hätte.
 186      */
 187     if (eTag != null)
 188       response.setHeader(HEADER_ETAG, eTag);
 189
 190
 191     if (ifModifiedSince >= lastModified && lastModified > 0) {
 192       /**
 193        * request.getDateHeader liefert die Zeit als long, oder -1, wenn der
 194        * Header nicht existiert. D.h., wenn "If-Modified-Since" nicht gesetzt
 195        * ist, wird die komplette Seite ausgeliefert.
 196        * Der zusätzliche Test, ob lastModified größer 0 ist, ist nötig, um
 197        * Fehler auszuschließen, wenn die Implementierung von Cachable
 198        * negative Werte für Last-Modified zurückliefert.
 199        */
 200       if (log.isDebugEnabled())
 201         log.debug("{}: Not modified since {}", url, new Date(ifModifiedSince));
 202
 203       if (ifNoneMatch == null) {
 204         /** Neue Anfrage oder HTTP/1.0 Client! */
 205         log.debug("{}: ETag nicht gesetzt -> 304", url);
 206         response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
 207         return false;
 208       }
 209     }
 210
 211     if (ifNoneMatch != null && ifNoneMatch.equals(eTag)) {
 212       log.debug("{}: ETag {} not changed -> 304 ", url, ifNoneMatch);
 213       response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
 214       return false;
 215     }
 216
 217
 218     log.debug("{}: first up!", url);
 219
 220     return true;
 221   }
 222
 223   @Override
 224   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}
 225
 226   @Override
 227   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
 228 }