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

   1 package de.halbekunst.juplo.cachecontrol;
   2
   3 import de.halbekunst.juplo.cachecontrol.annotations.CacheSeconds;
   4 import de.halbekunst.juplo.cachecontrol.annotations.Accepts;
   5 import de.halbekunst.juplo.cachecontrol.annotations.LastModified;
   6 import de.halbekunst.juplo.cachecontrol.annotations.ETag;
   7 import java.lang.annotation.Annotation;
   8 import java.lang.reflect.Method;
   9 import java.util.Date;
  10 import java.util.Map;
  11 import java.util.Map.Entry;
  12 import java.util.TreeMap;
  13 import javax.servlet.http.HttpServletRequest;
  14 import javax.servlet.http.HttpServletResponse;
  15 import org.slf4j.Logger;
  16 import org.slf4j.LoggerFactory;
  17
  18 /**
  19  *
  20  * @author kai
  21  */
  22 public class CacheControl {
  23   private final static Logger log = LoggerFactory.getLogger(CacheControl.class);
  24
  25   private static final ThreadLocal<CacheMethodHandle> tl = new ThreadLocal<CacheMethodHandle>();
  26
  27   private Integer defaultCacheSeconds;
  28   private Long defaultLastModified;
  29
  30
  31   public void init(CacheMethodHandle handle) {
  32     CacheControl.tl.set(handle);
  33   }
  34
  35   public void init(Object handler) throws NoSuchMethodException {
  36     CacheControl.tl.set(new ReflectionCacheMethodHandle(handler));
  37   }
  38
  39   public boolean decorate(
  40       HttpServletRequest request,
  41       HttpServletResponse response,
  42       Object handler
  43       )
  44   {
  45     try {
  46     CacheMethodHandle controller = CacheControl.tl.get();
  47
  48     /** Doppelte Ausführung verhindern... */
  49     if (controller == null) {
  50       /** Dekoration wurde bereits durchgeführt! */
  51       return true;
  52     }
  53
  54     /**
  55      * Alle Antworten (insbesondere auch 304) sollen nach dem {@plainlink
  56      * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.18 RFC 2616,
  57      * Abschnitt 14.18} einen Date-Header enthalten
  58      */
  59     response.setDateHeader(HeaderNames.HEADER_DATE, controller.getTimestamp());
  60
  61     /** Besondere Maßnahmen für besondere HTTP-Status-Codes ?!? */
  62     int status = controller.accepts(request);
  63     switch (status) {
  64       case HttpServletResponse.SC_OK: // 200
  65       case HttpServletResponse.SC_NO_CONTENT: // 204
  66       case HttpServletResponse.SC_PARTIAL_CONTENT: // 206
  67         /** Normale Antwort! Antwort dekorieren... */
  68         break;
  69       case HttpServletResponse.SC_BAD_REQUEST: // 400
  70       case HttpServletResponse.SC_UNAUTHORIZED: // 401
  71       case HttpServletResponse.SC_PAYMENT_REQUIRED: // 402
  72       case HttpServletResponse.SC_FORBIDDEN: // 403
  73       case HttpServletResponse.SC_NOT_FOUND: // 404
  74       case HttpServletResponse.SC_METHOD_NOT_ALLOWED: // 405
  75       case HttpServletResponse.SC_NOT_ACCEPTABLE: // 406
  76       case HttpServletResponse.SC_PROXY_AUTHENTICATION_REQUIRED: // 407
  77       case HttpServletResponse.SC_REQUEST_TIMEOUT: // 408
  78       case HttpServletResponse.SC_CONFLICT: // 409
  79       case HttpServletResponse.SC_GONE: // 410
  80       case HttpServletResponse.SC_LENGTH_REQUIRED: // 411
  81       case HttpServletResponse.SC_PRECONDITION_FAILED: // 412
  82       case HttpServletResponse.SC_REQUEST_ENTITY_TOO_LARGE: // 413
  83       case HttpServletResponse.SC_REQUEST_URI_TOO_LONG: // 414
  84       case HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE: // 415
  85       case HttpServletResponse.SC_REQUESTED_RANGE_NOT_SATISFIABLE: // 416
  86       case HttpServletResponse.SC_INTERNAL_SERVER_ERROR: // 500
  87       case HttpServletResponse.SC_NOT_IMPLEMENTED: // 501
  88       case HttpServletResponse.SC_SERVICE_UNAVAILABLE: // 503
  89       case HttpServletResponse.SC_HTTP_VERSION_NOT_SUPPORTED: // 505
  90         return true;
  91       default:
  92         /**
  93          * Es ist nicht klar, was der Handler noch machen wird/muss:
  94          * Antwort nicht dekorieren und Kontroller an den Handler übergeben...
  95          */
  96         return false;
  97     }
  98
  99     String url = null;
 100     if (log.isDebugEnabled()) {
 101       if (request.getQueryString() == null) {
 102         url = request.getRequestURI();
 103       }
 104       else {
 105         StringBuilder builder = new StringBuilder();
 106         builder.append(request.getRequestURI());
 107         builder.append('?');
 108         builder.append(request.getQueryString());
 109         url = builder.toString();
 110       }
 111     }
 112
 113     int cacheSeconds = controller.getCacheSeconds(request);
 114     if (cacheSeconds < 1) {
 115       log.debug("{}: caching disabled!", url);
 116       response.setDateHeader(HeaderNames.HEADER_DATE, controller.getTimestamp());
 117       response.setDateHeader(HeaderNames.HEADER_EXPIRES, 0);
 118       response.addHeader(HeaderNames.HEADER_PRAGMA, "no-cache");
 119       response.addHeader(HeaderNames.HEADER_CACHE_CONTROL, "private");
 120       response.addHeader(HeaderNames.HEADER_CACHE_CONTROL, "no-cache");
 121       response.addHeader(HeaderNames.HEADER_CACHE_CONTROL, "no-store");
 122       response.addHeader(HeaderNames.HEADER_CACHE_CONTROL, "max-age=0");
 123       response.addHeader(HeaderNames.HEADER_CACHE_CONTROL, "s-max-age=0");
 124       return true;
 125     }
 126
 127     long ifModifiedSince = -1;
 128     try {
 129       ifModifiedSince = request.getDateHeader(HeaderNames.HEADER_IF_MODIFIED_SINCE);
 130     }
 131     catch (Exception e) {
 132       log.error("Exception while fetching If-Modified-Since: {}", e);
 133     }
 134
 135     long lastModified = controller.getLastModified(request);
 136
 137     /**
 138      * Sicherstellen, dass der Wert keine Millisekunden enthält, da die
 139      * Zeitangabe aus dem Modified-Since-Header keine Millisekunden enthalten
 140      * kann und der Test unten dann stets fehlschlagen würde!
 141      */
 142     lastModified = lastModified - (lastModified % 1000);
 143
 144     String ifNoneMatch = request.getHeader(HeaderNames.HEADER_IF_NONE_MATCH);
 145     String eTag = controller.getETag(request);
 146
 147     /**
 148      * 304-Antworten sollen nach dem {@plainlink
 149      * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5 RFC
 150      * 2616, Abschnitt 10.3.5} einen ETag-Header enthalten, wenn auch die
 151      * 200-Antwort einen enthalten hätte.
 152      */
 153     if (eTag != null) {
 154       StringBuilder builder = new StringBuilder();
 155       if (controller.isETagWeak())
 156         builder.append("W/");
 157       builder.append('"');
 158       builder.append(eTag);
 159       builder.append('"');
 160       response.setHeader(HeaderNames.HEADER_ETAG, builder.toString());
 161     }
 162
 163
 164     if (ifModifiedSince >= lastModified && lastModified > 0) {
 165       /**
 166        * request.getDateHeader liefert die Zeit als long, oder -1, wenn der
 167        * Header nicht existiert. D.h., wenn "If-Modified-Since" nicht gesetzt
 168        * ist, wird die komplette Seite ausgeliefert.
 169        * Der zusätzliche Test, ob lastModified größer 0 ist, ist nötig, um
 170        * Fehler auszuschließen, wenn die Implementierung von Cachable
 171        * negative Werte für Last-Modified zurückliefert.
 172        */
 173       if (log.isDebugEnabled())
 174         log.debug("{}: Not modified since {}", url, new Date(ifModifiedSince));
 175
 176       if (ifNoneMatch == null) {
 177         /** Neue Anfrage oder HTTP/1.0 Client! */
 178         log.debug("{}: ETag nicht gesetzt -> 304", url);
 179         response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
 180         return false;
 181       }
 182     }
 183
 184     if (ifNoneMatch != null) {
 185       boolean weak = false;
 186       if (ifNoneMatch.startsWith("W/")) {
 187         weak = true;
 188         ifNoneMatch = ifNoneMatch.substring(3, ifNoneMatch.length() - 1);
 189       }
 190       else {
 191         ifNoneMatch = ifNoneMatch.substring(1, ifNoneMatch.length() - 1);
 192       }
 193
 194       if (!weak || (request.getMethod().equals("GET") && request.getHeader(HeaderNames.HEADER_RANGE) == null)) {
 195         /**
 196          * Die Gleichheit gilt nur, wenn die ETag's der Anfrage _und_ der
 197          * Antwort stark sind (starke Gleichheit!), oder wenn die Antwort nur
 198          * schwache Gleichheit fordert...
 199          */
 200         if (ifNoneMatch.equals(eTag) && (controller.isETagWeak() || !weak)) {
 201           log.debug("{}: ETag {} not changed -> 304 ", url, ifNoneMatch);
 202           response.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
 203           return false;
 204         }
 205       }
 206       else {
 207         log.warn("{}: ignoring weak ETag W/\"{}\", because the request was no GET-request or the Range-Header was present!", url, ifNoneMatch);
 208       }
 209     }
 210
 211
 212     log.debug("{}: first up!", url);
 213
 214     /** HTTP/1.1-Caching-Header richtig setzen!! */
 215     response.setDateHeader(HeaderNames.HEADER_LAST_MODIFIED, lastModified);
 216
 217     /** Cache-Control für HTTP/1.1-Clients generieren */
 218     Map<String, String> cacheControl = new TreeMap<String, String>();
 219
 220     /**
 221      * Wenn eins JSESSIONID in der URL enthalten ist, darf die Anfrage nur vom
 222      * Browser gecached werden!
 223      */
 224     if (request.isRequestedSessionIdFromURL()) {
 225       cacheControl.put("private", null);
 226     }
 227     else {
 228       /**
 229        * Hier muss nicht geprüft werden, ob cacheSeconds > 0 gilt, da in diesem
 230        * Fall oben bereits No-Cache-Header generiert und <code>false</code>
 231        * zurückgeliefert werden!
 232        *
 233        * Den Wert als <code>max-age</code> zu den Schlüssel-Wert-Paaren für den
 234        * <code>Cache-Control</code>-Header hinzufügen und einen entsprechenden
 235        * <code>Expires</code>-Header für HTTP/1.0-Clients setzen.
 236        */
 237       cacheControl.put("max-age", Integer.toString(cacheSeconds));
 238       response.setDateHeader(HeaderNames.HEADER_EXPIRES, (controller.getTimestamp() + (long) cacheSeconds * 1000));
 239     }
 240
 241     /** Dem Handler die Gelegenheit geben, den Cache-Controll-Header anzupassen */
 242     controller.cacheControl(request, cacheControl);
 243
 244
 245     if (cacheControl.containsKey("private")) {
 246       /**
 247        * HTTP/1.0 Caches davon abhalten, die Ressource zu cachen (vgl.: RFC
 248        * 2616, {@plainlink
 249        * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.3
 250        * Abschnitt 14.9.3} und {@plainlink
 251        * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.32
 252        * Abschnitt 14.32})
 253        */
 254       response.setDateHeader(HeaderNames.HEADER_EXPIRES, 0l);
 255       response.addHeader(HeaderNames.HEADER_PRAGMA, "no-cache");
 256     }
 257
 258     StringBuilder builder = new StringBuilder();
 259     for (Entry<String, String> entry : cacheControl.entrySet()) {
 260       builder.setLength(0);
 261       builder.append(entry.getKey());
 262       if (entry.getValue() != null) {
 263         builder.append('=');
 264         builder.append(entry.getValue());
 265       }
 266       response.addHeader(HeaderNames.HEADER_CACHE_CONTROL, builder.toString());
 267     }
 268
 269     return true;
 270     }
 271     finally {
 272       /**
 273        * Thread-Locale-Variable zurücksetzen, damit
 274        * 1.) ein doppelter Aufruf dieser Methode pro Request erkannt werden kann
 275        * 2.) der nächste Request nicht mit dem selben Handle weiterarbeitet
 276        */
 277       CacheControl.tl.set(null);
 278     }
 279   }
 280
 281   public void release() {
 282     CacheControl.tl.set(null);
 283   }
 284
 285
 286   public interface CacheMethodHandle {
 287     long getTimestamp();
 288     int accepts(HttpServletRequest request);
 289     int getCacheSeconds(HttpServletRequest request);
 290     long getLastModified(HttpServletRequest request);
 291     String getETag(HttpServletRequest request);
 292     boolean isETagWeak();
 293     void cacheControl(HttpServletRequest request, Map<String, String> cacheControlMap);
 294   }
 295
 296
 297   class ReflectionCacheMethodHandle implements CacheMethodHandle {
 298
 299     private Object handler;
 300     private long now = System.currentTimeMillis();
 301     private Integer cacheSeconds;
 302     private Long lastModified;
 303     private String eTag;
 304     private Method acceptsMethod;
 305     private Method cacheSecondsMethod;
 306     private Method lastModifiedMethod;
 307     private Method eTagMethod;
 308     private Method cacheControlMethod;
 309     private boolean isAcceptsMethodDefined;
 310     private boolean isCacheSecondsMethodDefined;
 311     private boolean isLastModifiedMethodDefined;
 312     private boolean isETagMethodDefined;
 313     private boolean isCacheControlMethodDefined;
 314     private boolean weak;
 315
 316
 317     ReflectionCacheMethodHandle(Object handler) throws NoSuchMethodException {
 318
 319       this.handler = handler;
 320
 321       cacheSeconds = CacheControl.this.defaultCacheSeconds;
 322       lastModified = CacheControl.this.defaultLastModified;
 323       eTag = "";
 324
 325       /** Class-Level-Annotations auslesen */
 326       for (Annotation annotation : handler.getClass().getAnnotations()) {
 327         if (annotation.annotationType().equals(CacheSeconds.class)) {
 328           cacheSeconds = ((CacheSeconds)annotation).value();
 329           isCacheSecondsMethodDefined = true;
 330           continue;
 331         }
 332         if (annotation.annotationType().equals(LastModified.class)) {
 333           lastModified = ((LastModified)annotation).value();
 334           if (lastModified < 1) {
 335             /**
 336              * Ein Last-Modified-Header wurde angefordert, aber es wurde kein
 337              * statischer Wert spezifiziert:
 338              * globalen statischen Default-Wert benutzen!
 339              */
 340             lastModified = defaultLastModified;
 341           }
 342           isLastModifiedMethodDefined = true;
 343           continue;
 344         }
 345         if (annotation.annotationType().equals(ETag.class)) {
 346           ETag eTagAnnotation = (ETag)annotation;
 347           eTag = eTagAnnotation.value();
 348           weak = eTagAnnotation.weak();
 349           isETagMethodDefined = true;
 350           continue;
 351         }
 352       }
 353
 354       /** Method-Level-Annotations auslesen */
 355       for (Method method : handler.getClass().getMethods()) {
 356         for (Annotation annotation : method.getAnnotations()) {
 357           if (annotation.annotationType().equals(Accepts.class)) {
 358             if (isAcceptsMethodDefined)
 359               throw new IllegalArgumentException("Die Annotation @Accept wurde in der Klasse " + handler.getClass().getSimpleName() + " mehrfach verwendet!");
 360             acceptsMethod = method;
 361             isAcceptsMethodDefined = true;
 362             continue;
 363           }
 364           if (annotation.annotationType().equals(CacheSeconds.class)) {
 365             if (isCacheSecondsMethodDefined)
 366               throw new IllegalArgumentException("Die Annotation @CacheSeconds wurde in der Klasse " + handler.getClass().getSimpleName() + " mehrfach verwendet!");
 367             cacheSecondsMethod = method;
 368             isCacheSecondsMethodDefined = true;
 369             continue;
 370           }
 371           if (annotation.annotationType().equals(LastModified.class)) {
 372             if (isLastModifiedMethodDefined)
 373               throw new IllegalArgumentException("Die Annotation @LastModified wurde in der Klasse " + handler.getClass().getSimpleName() + " mehrfach verwendet!");
 374             lastModifiedMethod = method;
 375             isLastModifiedMethodDefined = true;
 376             continue;
 377           }
 378           if (annotation.annotationType().equals(ETag.class)) {
 379             if (isETagMethodDefined)
 380               throw new IllegalArgumentException("Die Annotation @ETag wurde in der Klasse " + handler.getClass().getSimpleName() + " mehrfach verwendet!");
 381             eTagMethod = method;
 382             weak = ((ETag)annotation).weak();
 383             isETagMethodDefined = true;
 384             continue;
 385           }
 386           if (annotation.annotationType().equals(de.halbekunst.juplo.cachecontrol.annotations.CacheControl.class)) {
 387             if (isCacheControlMethodDefined)
 388               throw new IllegalArgumentException("Die Annotation @CacheControl wurde in der Klasse " + handler.getClass().getSimpleName() + " mehrfach verwendet!");
 389             cacheControlMethod = method;
 390             isCacheControlMethodDefined = true;
 391             continue;
 392           }
 393         }
 394       }
 395     }
 396
 397
 398     @Override
 399     public long getTimestamp() {
 400       return now;
 401     }
 402
 403     @Override
 404     public int accepts(HttpServletRequest request) throws IllegalArgumentException {
 405       if (acceptsMethod == null) {
 406         return HttpServletResponse.SC_OK;
 407       }
 408       else {
 409         try {
 410           return (Integer)acceptsMethod.invoke(handler, request);
 411         }
 412         catch (Exception e) {
 413           throw new IllegalArgumentException(e);
 414         }
 415       }
 416     }
 417
 418     @Override
 419     public int getCacheSeconds(HttpServletRequest request) throws IllegalArgumentException {
 420       if (cacheSecondsMethod == null) {
 421         return cacheSeconds;
 422       }
 423       else {
 424         try {
 425           return (Integer)cacheSecondsMethod.invoke(handler, request);
 426         }
 427         catch (Exception e) {
 428           throw new IllegalArgumentException(e);
 429         }
 430       }
 431     }
 432
 433     @Override
 434     public long getLastModified(HttpServletRequest request) throws IllegalArgumentException {
 435       if (lastModifiedMethod == null) {
 436         return lastModified;
 437       }
 438       else {
 439         try {
 440           return (Long)lastModifiedMethod.invoke(handler, request);
 441         }
 442         catch (Exception e) {
 443           throw new IllegalArgumentException(e);
 444         }
 445       }
 446     }
 447
 448     @Override
 449     public String getETag(HttpServletRequest request) throws IllegalArgumentException {
 450       if (eTagMethod == null) {
 451         return eTag;
 452       }
 453       else {
 454         try {
 455           return (String)eTagMethod.invoke(handler, request);
 456         }
 457         catch (Exception e) {
 458           throw new IllegalArgumentException(e);
 459         }
 460       }
 461     }
 462
 463     @Override
 464     public boolean isETagWeak() {
 465       return weak;
 466     }
 467
 468     @Override
 469     public void cacheControl(
 470         HttpServletRequest request,
 471         Map<String, String> cacheControlMap
 472         )
 473         throws IllegalArgumentException
 474     {
 475       if (cacheControlMethod != null) {
 476         try {
 477           cacheControlMethod.invoke(handler, request, cacheControlMap);
 478         }
 479         catch (Exception e) {
 480           throw new IllegalArgumentException(e);
 481         }
 482       }
 483     }
 484   }
 485
 486
 487   public void setDefaultCacheSeconds(Integer defaultCacheSeconds) {
 488     this.defaultCacheSeconds = defaultCacheSeconds;
 489   }
 490
 491   public void setDefaultLastModified(Long defaultLastModified) {
 492     this.defaultLastModified = defaultLastModified;
 493   }
 494 }