org.apache.http.impl.cookie.DateParseException Java Examples

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;
}
 

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;
}
 

/**
 * 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;
    }
}
 

protected void consumeWarnDate() {
	int curr = offs;
	Matcher m = WARN_DATE_PATTERN.matcher(src.substring(offs));
	if (!m.lookingAt())
		parseError();
	offs += m.end();
	try {
		warnDate = DateUtils.parseDate(src.substring(curr + 1, offs - 1));
	} catch (DateParseException e) {
		throw new IllegalStateException("couldn't parse a parseable date");
	}
}
 

private boolean hasValidDateField(HttpRequest request, String headerName) {
	for (Header h : request.getHeaders(headerName)) {
		try {
			DateUtils.parseDate(h.getValue());
			return true;
		} catch (DateParseException dpe) {
			// ignore malformed dates
		}
	}
	return false;
}
 

protected Date getExpirationDate(final HttpCacheEntry entry) {
	Header expiresHeader = entry.getFirstHeader(HeaderConstants.EXPIRES);
	if (expiresHeader == null)
		return null;
	try {
		return DateUtils.parseDate(expiresHeader.getValue());
	} catch (DateParseException dpe) {
		// malformed expires header
	}
	return null;
}
 

protected Date getLastModifiedValue(final HttpCacheEntry entry) {
	Header dateHdr = entry.getFirstHeader(HeaderConstants.LAST_MODIFIED);
	if (dateHdr == null)
		return null;
	try {
		return DateUtils.parseDate(dateHdr.getValue());
	} catch (DateParseException dpe) {
		// ignore malformed date
	}
	return null;
}
 

protected Date getDateValue(final HttpCacheEntry entry) {
	Header dateHdr = entry.getFirstHeader(HTTP.DATE_HEADER);
	if (dateHdr == null)
		return null;
	try {
		return DateUtils.parseDate(dateHdr.getValue());
	} catch (DateParseException dpe) {
		// ignore malformed date
	}
	return null;
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

public static long parseDateAsEpoch(String dateStr) {
    try {
        return DateUtils.parseDate(dateStr).getTime();
    } catch (DateParseException var2) {
        return 0L;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * Parse date in RFC1123 format, and return its value as epoch
 */
/*
 * 解析时间，将 RFC1123 的时间格式，解析成 epoch 时间
 */
public static long parseDateAsEpoch(String dateStr) {
    try {
        // Parse date in RFC1123 format if this header contains one
        // 耦合了 Apache 的时间工具类
        return DateUtils.parseDate(dateStr).getTime();
    } catch (DateParseException e) {
        // Date in invalid format, fallback to 0
        return 0;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * 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;
    }
}
 

/**
 * Determines if an HttpResponse can be cached.
 * 
 * @param httpMethod
 *            What type of request was this, a GET, PUT, other?
 * @param response
 *            The origin response
 * @return <code>true</code> if response is cacheable
 */
public boolean isResponseCacheable(String httpMethod, HttpResponse response) {
	boolean cacheable = false;

	if (!HeaderConstants.GET_METHOD.equals(httpMethod)) {
		log.debug("Response was not cacheable.");
		return false;
	}

	switch (response.getStatusLine().getStatusCode()) {
	case HttpStatus.SC_OK:
	case HttpStatus.SC_NON_AUTHORITATIVE_INFORMATION:
	case HttpStatus.SC_MULTIPLE_CHOICES:
	case HttpStatus.SC_MOVED_PERMANENTLY:
	case HttpStatus.SC_GONE:
		// these response codes MAY be cached
		cacheable = true;
		log.debug("Response was cacheable");
		break;
	case HttpStatus.SC_PARTIAL_CONTENT:
		// we don't implement Range requests and hence are not
		// allowed to cache partial content
		log.debug("Response was not cacheable (Partial Content)");
		return cacheable;

	default:
		// If the status code is not one of the recognized
		// available codes in HttpStatus Don't Cache
		log.debug("Response was not cacheable (Unknown Status code)");
		return cacheable;
	}

	Header contentLength = response.getFirstHeader(HTTP.CONTENT_LEN);
	if (contentLength != null) {
		int contentLengthValue = Integer.parseInt(contentLength.getValue());
		if (contentLengthValue > this.maxObjectSizeBytes)
			return false;
	}

	Header[] ageHeaders = response.getHeaders(HeaderConstants.AGE);

	if (ageHeaders.length > 1)
		return false;

	Header[] expiresHeaders = response.getHeaders(HeaderConstants.EXPIRES);

	if (expiresHeaders.length > 1)
		return false;

	Header[] dateHeaders = response.getHeaders(HTTP.DATE_HEADER);

	if (dateHeaders.length != 1)
		return false;

	try {
		DateUtils.parseDate(dateHeaders[0].getValue());
	} catch (DateParseException dpe) {
		return false;
	}

	for (Header varyHdr : response.getHeaders(HeaderConstants.VARY)) {
		for (HeaderElement elem : varyHdr.getElements()) {
			if ("*".equals(elem.getName())) {
				return false;
			}
		}
	}

	if (isExplicitlyNonCacheable(response))
		return false;

	return (cacheable || isExplicitlyCacheable(response));
}