Java 类org.apache.http.impl.cookie.DateParseException 实例源码

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

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

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

public static long parseDateAsEpoch(String dateStr) {
    try {
        return DateUtils.parseDate(dateStr).getTime();
    } catch (DateParseException e) {
        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;
    }
}

/**
 * 将指定字符串转换成日期
 *
 * @param date        String 日期字符串
 * @return Date
 */
public static Date getFormatDate8(String date) throws DateParseException {
    if(date == null || date.length() == 0) return null;
    date = date.replaceAll("[-\\s/:]+","");

    if(date.length()<8) throw new DateParseException("日期格式错误");
    if(date.length()>8) date = date.substring(0,8);

    SimpleDateFormat sd = new SimpleDateFormat("yyyyMMdd");
    return sd.parse(date, new java.text.ParsePosition(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;
    }
}

protected Date parseDate(final String expires) {
    try {
        return DateUtils.parseDate(expires);
    } catch (DateParseException e) {
        throw MechanizeExceptionFactory.newException(e);
    }
}

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

private boolean alreadyHaveNewerCacheEntry(final HttpHost target, final HttpRequest request,
        final HttpResponse backendResponse) {
    HttpCacheEntry existing = null;
    try {
        existing = responseCache.getCacheEntry(target, request);
    } catch (final IOException ioe) {
        // nop
    }
    if (existing == null) {
        return false;
    }
    final Header entryDateHeader = existing.getFirstHeader(HTTP.DATE_HEADER);
    if (entryDateHeader == null) {
        return false;
    }
    final Header responseDateHeader = backendResponse.getFirstHeader(HTTP.DATE_HEADER);
    if (responseDateHeader == null) {
        return false;
    }
    try {
        final Date entryDate = DateUtils.parseDate(entryDateHeader.getValue());
        final Date responseDate = DateUtils.parseDate(responseDateHeader.getValue());
        return responseDate.before(entryDate);
    } catch (final DateParseException e) {
        // Empty on Purpose
    }
    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;
    }
}

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

private static long parseDateAsEpoch(String paramString)
{
  try
  {
    long l = DateUtils.parseDate(paramString).getTime();
    return l;
  }
  catch (DateParseException localDateParseException) {}
  return 0L;
}

private static long zzg(String paramString)
{
  try
  {
    long l = DateUtils.parseDate(paramString).getTime();
    return l;
  }
  catch (DateParseException localDateParseException) {}
  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;
    }
}