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     String ifNoneMatch = request.getHeader(HEADER_IF_NONE_MATCH);
 103     String eTag = cacheable.getETag(request);
 104
 105     /**
 106      * 304-Antworten sollen nach dem {@plainlink
 107      * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5 RFC
 108      * 2616, Abschnitt 10.3.5} einen ETag-Header enthalten, wenn auch die
 109      * 200-Antwort einen enthalten hätte.
 110      */
 111     if (eTag != null)
 112       response.setHeader(HEADER_ETAG, eTag);
 113
 114
 115     if (ifModifiedSince >= lastModified && lastModified > 0) {
 116       /**
 117        * request.getDateHeader liefert die Zeit als long, oder -1, wenn der
 118        * Header nicht existiert. D.h., wenn "If-Modified-Since" nicht gesetzt
 119        * ist, wird die komplette Seite ausgeliefert.
 120        * Der zusätzliche Test, ob lastModified größer 0 ist, ist nötig, um
 121        * Fehler auszuschließen, wenn die Implementierung von Cachable
 122        * negative Werte für Last-Modified zurückliefert.
 123        */
 124       if (log.isDebugEnabled())
 125         log.debug("{}: Not modified since {}", url, new Date(ifModifiedSince));
 126
 127       if (ifNoneMatch == null) {
 128         /** Neue Anfrage oder HTTP/1.0 Client! */
 129         log.debug("{}: ETag nicht gesetzt -> 304", url);
 130         response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
 131         return false;
 132       }
 133     }
 134
 135     if (ifNoneMatch != null && ifNoneMatch.equals(eTag)) {
 136       log.debug("{}: ETag {} not changed -> 304 ", url, ifNoneMatch);
 137       response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
 138       return false;
 139     }
 140
 141
 142     log.debug("{}: first up!", url);
 143
 144     /** HTTP/1.1-Caching-Header richtig setzen!! */
 145     response.setDateHeader(HEADER_LAST_MODIFIED, lastModified);
 146
 147     /** Cache-Control für HTTP/1.1-Clients generieren */
 148     Map<String, String> cacheControl = new HashMap<String, String>(cacheable.getCacheControl(request));
 149
 150     /**
 151      * Wenn eins JSESSIONID in der URL enthalten ist, darf die Anfrage nur vom
 152      * Browser gecached werden!
 153      */
 154     if (request.isRequestedSessionIdFromURL())
 155       cacheControl.put("private", null);
 156
 157     if (cacheControl.containsKey("private")) {
 158       /**
 159        * HTTP/1.0 Caches davon abhalten, die Ressource zu cachen (vgl.: RFC
 160        * 2616, {@plainlink
 161        * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3
 162        * Abschnitt 14.9.3} und {@plainlink
 163        * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.32
 164        * Abschnitt 14.32})
 165        */
 166       response.setDateHeader(HEADER_EXPIRES, 0l);
 167       response.addHeader(HEADER_PRAGMA, "no-cache");
 168     } else {
 169       /**
 170        * Hier muss nicht geprüft werden, ob cacheSeconds > 0 gilt, da in diesem
 171        * Fall oben bereits No-Cache-Header generiert und <code>false</code>
 172        * zurückgeliefert werden!
 173        *
 174        * Den Wert als <code>max-age</code> zu den Schlüssel-Wert-Paaren für den
 175        * <code>Cache-Control</code>-Header hinzufügen und einen entsprechenden
 176        * <code>Expires</code>-Header für HTTP/1.0-Clients setzen.
 177        */
 178       cacheControl.put("max-age", Integer.toString(cacheSeconds));
 179       response.setDateHeader(HEADER_EXPIRES, (now + (long) cacheSeconds * 1000));
 180     }
 181
 182     StringBuilder builder = new StringBuilder();
 183     for (Entry<String, String> entry : cacheControl.entrySet()) {
 184       builder.setLength(0);
 185       builder.append(entry.getKey());
 186       if (entry.getValue() != null) {
 187         builder.append('=');
 188         builder.append(entry.getValue());
 189       }
 190       response.addHeader(HEADER_CACHE_CONTROL, builder.toString());
 191     }
 192
 193     return true;
 194   }
 195
 196   @Override
 197   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}
 198
 199   @Override
 200   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}
 201 }