private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) { // If there's no cache entry, we're done. if (entry == null) { return; } if (entry.etag != null) { // 设置 If-None-Match headers.put("If-None-Match", entry.etag); } if (entry.lastModified > 0) { Date refTime = new Date(entry.lastModified); // 设置 If-Modified-Since headers.put("If-Modified-Since", DateUtils.formatDate(refTime)); } }
private boolean revalidationResponseIsTooOld(final HttpResponse backendResponse, final HttpCacheEntry cacheEntry) { final Header entryDateHeader = cacheEntry.getFirstHeader(HTTP.DATE_HEADER); final Header responseDateHeader = backendResponse.getFirstHeader(HTTP.DATE_HEADER); if (entryDateHeader != null && responseDateHeader != null) { try { final Date entryDate = DateUtils.parseDate(entryDateHeader.getValue()); final Date respDate = DateUtils.parseDate(responseDateHeader.getValue()); if (respDate.before(entryDate)) { return true; } } catch (final DateParseException e) { // either backend response or cached entry did not have a valid // Date header, so we can't tell if they are out of order // according to the origin clock; thus we can skip the // unconditional retry recommended in 13.2.6 of RFC 2616. } } return false; }
@Test public void execute() throws ClientProtocolException, IOException { EtagAnswer answer = new EtagAnswer(); Mockito.when(httpClient.execute(Matchers.any(HttpUriRequest.class), Matchers.any(HttpContext.class))).then(answer); EtagCachingHttpClient client = new EtagCachingHttpClient(httpClient); HttpResponse response = client.execute(prepareRequest(null, null)); checkResponse(response, DateUtils.formatDate(answer.getLastModified())); Assert.assertTrue(answer.isModified()); response = client.execute(prepareRequest(null, null)); checkResponse(response, DateUtils.formatDate(answer.getLastModified())); Assert.assertFalse(answer.isModified()); }
@Test public void executeWithModifiedSince() throws ClientProtocolException, IOException { EtagAnswer answer = new EtagAnswer(); Mockito.when(httpClient.execute(Matchers.any(HttpUriRequest.class), Matchers.any(HttpContext.class))).then(answer); EtagCachingHttpClient client = new EtagCachingHttpClient(httpClient); HttpResponse response = client.execute(prepareRequest(null, null)); checkResponse(response, DateUtils.formatDate(answer.getLastModified())); Assert.assertTrue(answer.isModified()); Header lastModifiedHeader = response.getFirstHeader(HeaderConstants.LAST_MODIFIED); String lastModified = lastModifiedHeader.getValue(); response = client.execute(prepareRequest(null, lastModified)); checkResponse(response, lastModified); Assert.assertFalse(answer.isModified()); }
private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) { // If there's no cache entry, we're done. if (entry == null) { return; } if (entry.etag != null) { headers.put("If-None-Match", entry.etag); } if (entry.serverDate > 0) { Date refTime = new Date(entry.serverDate); headers.put("If-Modified-Since", DateUtils.formatDate(refTime)); } }
protected void checkVetoHeaders(HttpResponse response, boolean checkExpires) throws Exception { Header head = response.getFirstHeader("Cache-Control"); assertNotNull("We got no Cache-Control header", head); assertTrue("We got no no-cache in the Cache-Control header ["+head+"]", head.getValue().contains("no-cache")); assertTrue("We got no no-store in the Cache-Control header ["+head+"]", head.getValue().contains("no-store")); head = response.getFirstHeader("Pragma"); assertNotNull("We got no Pragma header", head); assertEquals("no-cache", head.getValue()); if (checkExpires) { head = response.getFirstHeader("Expires"); assertNotNull("We got no Expires header:" + Arrays.asList(response.getAllHeaders()), head); Date d = DateUtils.parseDate(head.getValue()); assertTrue("We got no Expires header far in the past", System .currentTimeMillis() - d.getTime() > 100000); } }
private boolean entryDateHeaderNewerThenResponse(HttpCacheEntry entry, HttpResponse response) { try { Date entryDate = DateUtils.parseDate(entry.getFirstHeader( HTTP.DATE_HEADER).getValue()); Date responseDate = DateUtils.parseDate(response.getFirstHeader( HTTP.DATE_HEADER).getValue()); if (!entryDate.after(responseDate)) { return false; } } catch (DateParseException e) { return false; } return true; }
private boolean alreadyHaveNewerCacheEntry(HttpHost target, HttpRequest request, HttpResponse backendResponse) throws IOException { HttpCacheEntry existing = null; try { existing = responseCache.getCacheEntry(target, request); } catch (IOException ioe) { // nop } if (existing == null) return false; Header entryDateHeader = existing.getFirstHeader("Date"); if (entryDateHeader == null) return false; Header responseDateHeader = backendResponse.getFirstHeader("Date"); if (responseDateHeader == null) return false; try { Date entryDate = DateUtils.parseDate(entryDateHeader.getValue()); Date responseDate = DateUtils.parseDate(responseDateHeader .getValue()); return responseDate.before(entryDate); } catch (DateParseException e) { } return false; }
/** * Parse date in RFC1123 format, and return its value as epoch */ public static long parseDateAsEpoch(String dateStr) { try { // Parse date in RFC1123 format if this header contains one return DateUtils.parseDate(dateStr).getTime(); } catch (DateParseException e) { // Date in invalid format, fallback to 0 return 0; } }
private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) { // If there's no cache entry, we're done. if (entry == null) { return; } if (entry.etag != null) { headers.put("If-None-Match", entry.etag); } if (entry.lastModified > 0) { Date refTime = new Date(entry.lastModified); headers.put("If-Modified-Since", DateUtils.formatDate(refTime)); } }
private void addCacheHeaders(Map<String, String> headers, Entry entry) { // If there's no cache entry, we're done. if (entry == null) { return; } if (entry.etag != null) { headers.put("If-None-Match", entry.etag); } if (entry.lastModified > 0) { Date refTime = new Date(entry.lastModified); headers.put("If-Modified-Since", DateUtils.formatDate(refTime)); } }
public static long parseDateAsEpoch(String dateStr) { try { return DateUtils.parseDate(dateStr).getTime(); } catch (DateParseException e) { return 0; } }
private void addCacheHeaders(Map<String, String> headers, Entry entry) { if (entry != null) { if (entry.etag != null) { headers.put("If-None-Match", entry.etag); } if (entry.lastModified > 0) { headers.put("If-Modified-Since", DateUtils.formatDate(new Date(entry.lastModified))); } } }
protected void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) { if (entry != null) { if (entry.etag != null) { headers.put("If-None-Match", entry.etag); } if (entry.serverDate > 0L) { Date refTime = new Date(entry.serverDate); headers.put("If-Modified-Since", DateUtils.formatDate(refTime)); } } }
public static long parseDateAsEpoch(String dateStr) { try { return DateUtils.parseDate(dateStr).getTime(); } catch (DateParseException var2) { return 0L; } }