下面列出了怎么用org.apache.http.ProtocolException的API类实例代码及写法，或者点击链接到github查看源代码。
@Override
public HttpUriRequest getRedirect(final HttpRequest request, final HttpResponse response, final HttpContext context)
throws ProtocolException
{
final String method = request.getRequestLine().getMethod();
HttpUriRequest redirect = super.getRedirect(request, response, context);
if (HttpPost.METHOD_NAME.equalsIgnoreCase(method))
{
HttpPost httpPostRequest = new HttpPost(redirect.getURI());
if (request instanceof HttpEntityEnclosingRequest)
{
httpPostRequest.setEntity(((HttpEntityEnclosingRequest) request).getEntity());
}
return httpPostRequest;
}
return redirect;
}
@Override
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
URI uri = getLocationURI(request, response, context);
String method = request.getRequestLine().getMethod();
if (HttpConstants.POST.equalsIgnoreCase(method)) {
try {
HttpRequestWrapper httpRequestWrapper = (HttpRequestWrapper) request;
httpRequestWrapper.setURI(uri);
httpRequestWrapper.removeHeaders("Content-Length");
return httpRequestWrapper;
} catch (Exception e) {
e.printStackTrace();
}
return new HttpPost(uri);
} else {
return new HttpGet(uri);
}
}
@Override
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
URI uri = getLocationURI(request, response, context);
String method = request.getRequestLine().getMethod();
if ("post".equalsIgnoreCase(method)) {
try {
HttpRequestWrapper httpRequestWrapper = (HttpRequestWrapper) request;
httpRequestWrapper.setURI(uri);
httpRequestWrapper.removeHeaders("Content-Length");
return httpRequestWrapper;
} catch (Exception e) {
log.error("强转为HttpRequestWrapper出错");
}
return new HttpPost(uri);
} else {
return new HttpGet(uri);
}
}
public RequestEntityRestStorageService(final S3Session session, final HttpClientBuilder configuration) {
super(null, new PreferencesUseragentProvider().get(), null, toProperties(session.getHost(), session.getSignatureVersion()));
this.session = session;
this.properties = this.getJetS3tProperties();
// Client configuration
configuration.disableContentCompression();
configuration.setRetryHandler(new S3HttpRequestRetryHandler(this, preferences.getInteger("http.connections.retry")));
configuration.setRedirectStrategy(new DefaultRedirectStrategy() {
@Override
public HttpUriRequest getRedirect(final HttpRequest request, final HttpResponse response, final HttpContext context) throws ProtocolException {
if(response.containsHeader("x-amz-bucket-region")) {
final String host = ((HttpUriRequest) request).getURI().getHost();
if(!StringUtils.equals(session.getHost().getHostname(), host)) {
regionEndpointCache.putRegionForBucketName(
StringUtils.split(StringUtils.removeEnd(((HttpUriRequest) request).getURI().getHost(), session.getHost().getHostname()), ".")[0],
response.getFirstHeader("x-amz-bucket-region").getValue());
}
}
return super.getRedirect(request, response, context);
}
});
this.setHttpClient(configuration.build());
}
@Override
public HttpUriRequest getRedirect(
final HttpRequest request, final HttpResponse response, final HttpContext context)
throws ProtocolException {
final URI uri = getLocationURI(request, response, context);
final String method = request.getRequestLine().getMethod();
if (method.equalsIgnoreCase(HttpHead.METHOD_NAME)) {
return new HttpHead(uri);
} else if (method.equalsIgnoreCase(HttpGet.METHOD_NAME)) {
return new HttpGet(uri);
} else {
final int status = response.getStatusLine().getStatusCode();
if (status == HttpStatus.SC_TEMPORARY_REDIRECT
|| status == HttpStatus.SC_MOVED_PERMANENTLY
|| status == HttpStatus.SC_MOVED_TEMPORARILY) {
return RequestBuilder.copy(request).setUri(uri).build();
}
return new HttpGet(uri);
}
}
@Override
public boolean isRedirected(final HttpRequest request, final HttpResponse response, final HttpContext context)
throws ProtocolException {
Args.notNull(request, "HTTP request");
Args.notNull(response, "HTTP response");
final int statusCode = response.getStatusLine().getStatusCode();
final String method = request.getRequestLine().getMethod();
final Header locationHeader = response.getFirstHeader("location");
switch (statusCode) {
case HttpStatus.SC_MOVED_TEMPORARILY:
return isRedirectable(method) && locationHeader != null;
case HttpStatus.SC_MOVED_PERMANENTLY:
case HttpStatus.SC_TEMPORARY_REDIRECT:
case 308: // Ensure that HTTP 308 is redirected as well
return isRedirectable(method);
case HttpStatus.SC_SEE_OTHER:
return true;
default:
return false;
} // end of switch
}
/**
* @see DefaultRedirectStrategy#getRedirect(HttpRequest, HttpResponse, HttpContext)
*/
@Override
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context)
throws ProtocolException {
// Code from DefaultRedirectStrategy
// To ensure usage of the local getLocationURI implementation.
final URI uri = getLocationURI(request, response, context);
final String method = request.getRequestLine().getMethod();
if (method.equalsIgnoreCase(HttpHead.METHOD_NAME)) {
return new HttpHead(uri);
} else if (method.equalsIgnoreCase(HttpGet.METHOD_NAME)) {
return new HttpGet(uri);
} else {
final int status = response.getStatusLine().getStatusCode();
if (status == HttpStatus.SC_TEMPORARY_REDIRECT) {
return RequestBuilder.copy(request).setUri(uri).build();
} else {
return new HttpGet(uri);
}
}
}
/**
* For local redirects, converts to relative urls.
*
* @param request
* must be an {@link OutgoingRequest}.
*/
@Override
public URI getLocationURI(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
URI uri = this.redirectStrategy.getLocationURI(request, response, context);
String resultingPageUrl = uri.toString();
DriverRequest driverRequest = ((OutgoingRequest) request).getOriginalRequest();
// Remove context if present
if (StringUtils.startsWith(resultingPageUrl, driverRequest.getVisibleBaseUrl())) {
resultingPageUrl =
"/"
+ StringUtils.stripStart(
StringUtils.replace(resultingPageUrl, driverRequest.getVisibleBaseUrl(), ""), "/");
}
resultingPageUrl = ResourceUtils.getHttpUrlWithQueryString(resultingPageUrl, driverRequest, false);
return UriUtils.createURI(ResourceUtils.getHttpUrlWithQueryString(resultingPageUrl, driverRequest, false));
}
protected void rewriteRequestURI(
final RequestWrapper request,
final HttpRoute route) throws ProtocolException {
try {
URI uri = request.getURI();
if (route.getProxyHost() != null && !route.isTunnelled()) {
// Make sure the request URI is absolute
if (!uri.isAbsolute()) {
HttpHost target = route.getTargetHost();
uri = URIUtils.rewriteURI(uri, target);
request.setURI(uri);
}
} else {
// Make sure the request URI is relative
if (uri.isAbsolute()) {
uri = URIUtils.rewriteURI(uri, null);
request.setURI(uri);
}
}
} catch (URISyntaxException ex) {
throw new ProtocolException("Invalid URI: "
+ request.getRequestLine().getUri(), ex);
}
}
/**
* Check whether we need to redirect.
* @param request the initial request
* @param response the response containing the location param for
* redirect.
* @param context the http context.
* @return should we redirect.
* @throws ProtocolException
*/
public boolean isRedirected(
final HttpRequest request,
final HttpResponse response,
final HttpContext context)
throws ProtocolException
{
Header locationHeader = response.getFirstHeader("location");
if(handler != null
&& locationHeader != null
&& handler.hasParams(locationHeader.getValue()))
{
//we will cancel this redirect and will schedule new redirect
handler.handleRedirect(locationHeader.getValue(), parameters);
return false;
}
return super.isRedirected(request, response, context);
}
/**
* If the {@link HttpRequest} is non-compliant but 'fixable' we go ahead and
* fix the request here. Returning the updated one.
*
* @param request
* the request to check for compliance
* @return the updated request
* @throws ProtocolException
* when we have trouble making the request compliant
*/
public HttpRequest makeRequestCompliant(HttpRequest request)
throws ProtocolException {
if (requestMustNotHaveEntity(request)) {
((HttpEntityEnclosingRequest) request).setEntity(null);
}
verifyRequestWithExpectContinueFlagHas100continueHeader(request);
verifyOPTIONSRequestWithBodyHasContentType(request);
decrementOPTIONSMaxForwardsIfGreaterThen0(request);
if (requestVersionIsTooLow(request)) {
return upgradeRequestTo(request, HttpVersion.HTTP_1_1);
}
if (requestMinorVersionIsTooHighMajorVersionsMatch(request)) {
return downgradeRequestTo(request, HttpVersion.HTTP_1_1);
}
return request;
}
@Override
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
URI uri = getLocationURI(request, response, context);
String method = request.getRequestLine().getMethod();
if ("post".equalsIgnoreCase(method)) {
try {
HttpRequestWrapper httpRequestWrapper = (HttpRequestWrapper) request;
httpRequestWrapper.setURI(uri);
httpRequestWrapper.removeHeaders("Content-Length");
return httpRequestWrapper;
} catch (Exception e) {
logger.error("强转为HttpRequestWrapper出错");
}
return new HttpPost(uri);
} else {
return new HttpGet(uri);
}
}
@Test
void testGetRedirect() throws ProtocolException
{
mockHeader();
when(statusLine.getStatusCode()).thenReturn(STATUS_CODE);
when(httpResponse.getStatusLine()).thenReturn(statusLine);
HttpEntityEnclosingRequest httpRequest = new HttpPost(URI);
StringEntity requestStringEntity = new StringEntity("{key:value}", StandardCharsets.UTF_8);
httpRequest.setEntity(requestStringEntity);
HttpEntityEnclosingRequest actualRedirect = (HttpEntityEnclosingRequest) redirectStrategy
.getRedirect(httpRequest, httpResponse, httpContext);
assertEquals(REDIRECT_URI, actualRedirect.getRequestLine().getUri());
assertEquals(requestStringEntity, actualRedirect.getEntity());
}
@Test
void testGetRedirectHeadRequest() throws ProtocolException
{
mockHeader();
HttpHead httpRequest = new HttpHead(URI);
HttpUriRequest actualRedirect = redirectStrategy.getRedirect(httpRequest, httpResponse, httpContext);
assertEquals(REDIRECT_URI, actualRedirect.getURI().toString());
}
private TestHttpClient createHttpClient() {
TestHttpClient client = new TestHttpClient();
client.setRedirectStrategy(new DefaultRedirectStrategy() {
@Override
public boolean isRedirected(final HttpRequest request, final HttpResponse response, final HttpContext context) throws ProtocolException {
if (response.getStatusLine().getStatusCode() == StatusCodes.FOUND) {
return true;
}
return super.isRedirected(request, response, context);
}
});
return client;
}
@Override
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
final String method = request.getRequestLine().getMethod();
if(method.equalsIgnoreCase(HttpPut.METHOD_NAME)) {
return this.copyEntity(new HttpPut(this.getLocationURI(request, response, context)), request);
}
return super.getRedirect(request, response, context);
}
@Override
public boolean isRedirected(final HttpRequest request, final HttpResponse response, final HttpContext context) throws ProtocolException {
if (super.isRedirected(request, response, context))
return true;
int statusCode = response.getStatusLine().getStatusCode();
return isRedirected(statusCode);
}
@Override
public HttpRoute determineRoute(final HttpHost host, final HttpRequest request, final HttpContext context) throws HttpException {
Args.notNull(request, "Request");
if (host == null) {
throw new ProtocolException("Target host is not specified");
}
final HttpClientContext clientContext = HttpClientContext.adapt(context);
final RequestConfig config = clientContext.getRequestConfig();
int remotePort;
if (host.getPort() <= 0) {
try {
remotePort = schemePortResolver.resolve(host);
} catch (final UnsupportedSchemeException e) {
throw new HttpException(e.getMessage());
}
} else
remotePort = host.getPort();
final Tuple<Inet4Address, Inet6Address> remoteAddresses = IpAddressTools.getRandomAddressesFromHost(host);
final Tuple<InetAddress, InetAddress> addresses = determineAddressPair(remoteAddresses);
final HttpHost target = new HttpHost(addresses.r, host.getHostName(), remotePort, host.getSchemeName());
final HttpHost proxy = config.getProxy();
final boolean secure = target.getSchemeName().equalsIgnoreCase("https");
clientContext.setAttribute(CHOSEN_IP_ATTRIBUTE, addresses.l);
log.debug("Setting route context attribute to {}", addresses.l);
if (proxy == null) {
return new HttpRoute(target, addresses.l, secure);
} else {
return new HttpRoute(target, addresses.l, proxy, secure);
}
}
@Override
public HttpUriRequest getRedirect(HttpRequest request, HttpResponse response, HttpContext context) throws ProtocolException {
URI uri = getLocationURI(request, response, context);
String method = request.getRequestLine().getMethod();
if (HttpPost.METHOD_NAME.equalsIgnoreCase(method)&& request instanceof HttpRequestWrapper) {
HttpRequestWrapper httpRequestWrapper = (HttpRequestWrapper) request;
httpRequestWrapper.setURI(uri);
httpRequestWrapper.removeHeaders("Content-Length");
return httpRequestWrapper;
} else {
return super.getRedirect(request,response,context);
}
}
@Override
public boolean isRedirected(
final HttpRequest request,
final HttpResponse response,
final HttpContext context) throws ProtocolException {
if (request == null) {
throw new IllegalArgumentException("HTTP request may not be null");
}
if (response == null) {
throw new IllegalArgumentException("HTTP response may not be null");
}
int statusCode = response.getStatusLine().getStatusCode();
String method = request.getRequestLine().getMethod();
Header locationHeader = response.getFirstHeader("location");
switch (statusCode) {
case HttpStatus.SC_MOVED_TEMPORARILY:
return isRedirectable(method) && locationHeader != null;
case HttpStatus.SC_MOVED_PERMANENTLY:
case HttpStatus.SC_TEMPORARY_REDIRECT:
return isRedirectable(method);
case HttpStatus.SC_SEE_OTHER:
return true;
default:
return false;
} //end of switch
}
@Override
public HttpUriRequest getRedirect(
final HttpRequest request,
final HttpResponse response,
final HttpContext context) throws ProtocolException {
URI uri = null;
try {
uri = getLocationURI(request, response, context);
} catch (URISyntaxException ex) {
Logger.getLogger(CustomRedirectStrategy.class.getName()).log(Level.SEVERE, null, ex);
}
String method = request.getRequestLine().getMethod();
if (method.equalsIgnoreCase(HttpHead.METHOD_NAME)) {
return new HttpHead(uri);
} else if (method.equalsIgnoreCase(HttpGet.METHOD_NAME)) {
return new HttpGet(uri);
} else {
int status = response.getStatusLine().getStatusCode();
if (status == HttpStatus.SC_TEMPORARY_REDIRECT) {
if (method.equalsIgnoreCase(HttpPost.METHOD_NAME)) {
return copyEntity(new HttpPost(uri), request);
} else if (method.equalsIgnoreCase(HttpPut.METHOD_NAME)) {
return copyEntity(new HttpPut(uri), request);
} else if (method.equalsIgnoreCase(HttpDelete.METHOD_NAME)) {
return new HttpDelete(uri);
} else if (method.equalsIgnoreCase(HttpTrace.METHOD_NAME)) {
return new HttpTrace(uri);
} else if (method.equalsIgnoreCase(HttpOptions.METHOD_NAME)) {
return new HttpOptions(uri);
} else if (method.equalsIgnoreCase(HttpPatch.METHOD_NAME)) {
return copyEntity(new HttpPatch(uri), request);
}
}
return new HttpGet(uri);
}
}
private RequestWrapper wrapRequest(
final HttpRequest request) throws ProtocolException {
if (request instanceof HttpEntityEnclosingRequest) {
return new EntityEnclosingRequestWrapper(
(HttpEntityEnclosingRequest) request);
} else {
return new RequestWrapper(
request);
}
}
private HttpRequest upgradeRequestTo(HttpRequest request,
ProtocolVersion version) throws ProtocolException {
RequestWrapper newRequest = new RequestWrapper(request);
newRequest.setProtocolVersion(version);
return newRequest;
}
private HttpRequest downgradeRequestTo(HttpRequest request,
ProtocolVersion version) throws ProtocolException {
RequestWrapper newRequest = new RequestWrapper(request);
newRequest.setProtocolVersion(version);
return newRequest;
}
/**
* When a {@link HttpCacheEntry} is stale but 'might' be used as a response
* to an {@link HttpRequest} we will attempt to revalidate the entry with
* the origin. Build the origin {@link HttpRequest} here and return it.
*
* @param request
* the original request from the caller
* @param cacheEntry
* the entry that needs to be revalidated
* @return the wrapped request
* @throws ProtocolException
* when I am unable to build a new origin request.
*/
public HttpRequest buildConditionalRequest(HttpRequest request,
HttpCacheEntry cacheEntry) throws ProtocolException {
RequestWrapper wrapperRequest = new RequestWrapper(request);
wrapperRequest.resetHeaders();
Header eTag = cacheEntry.getFirstHeader(HeaderConstants.ETAG);
if (eTag != null) {
wrapperRequest.setHeader(HeaderConstants.IF_NONE_MATCH,
eTag.getValue());
}
Header lastModified = cacheEntry
.getFirstHeader(HeaderConstants.LAST_MODIFIED);
if (lastModified != null) {
wrapperRequest.setHeader(HeaderConstants.IF_MODIFIED_SINCE,
lastModified.getValue());
}
boolean mustRevalidate = false;
for (Header h : cacheEntry.getHeaders(HeaderConstants.CACHE_CONTROL)) {
for (HeaderElement elt : h.getElements()) {
if (HeaderConstants.CACHE_CONTROL_MUST_REVALIDATE
.equalsIgnoreCase(elt.getName())
|| HeaderConstants.CACHE_CONTROL_PROXY_REVALIDATE
.equalsIgnoreCase(elt.getName())) {
mustRevalidate = true;
break;
}
}
}
if (mustRevalidate) {
wrapperRequest.addHeader("Cache-Control", "max-age=0");
}
return wrapperRequest;
}
/**
* When a {@link HttpCacheEntry} does not exist for a specific
* {@link HttpRequest} we attempt to see if an existing
* {@link HttpCacheEntry} is appropriate by building a conditional
* {@link HttpRequest} using the variants' ETag values. If no such values
* exist, the request is unmodified
*
* @param request
* the original request from the caller
* @param cacheEntry
* the entry that needs to be revalidated
* @return the wrapped request
* @throws ProtocolException
* when I am unable to build a new origin request.
*/
public HttpRequest buildConditionalRequestFromVariants(HttpRequest request,
Set<HttpCacheEntry> variantEntries) throws ProtocolException {
RequestWrapper wrapperRequest = new RequestWrapper(request);
wrapperRequest.resetHeaders();
// we do not support partial content so all etags are used
StringBuilder etags = new StringBuilder();
boolean first = true;
for (HttpCacheEntry entry : variantEntries) {
Header etagHeader = entry.getFirstHeader(HeaderConstants.ETAG);
if (etagHeader != null) {
if (first) {
etags.append(etagHeader.getValue());
first = false;
} else {
etags.append(",").append(etagHeader.getValue());
}
}
}
// if first is still true than no variants had a cache entry, return
// unmodified wrapped request
if (first) {
return wrapperRequest;
}
wrapperRequest.setHeader(HeaderConstants.IF_NONE_MATCH,
etags.toString());
return wrapperRequest;
}
@Override
public boolean isRedirected(final HttpRequest request, final HttpResponse response,
final HttpContext context) throws ProtocolException {
return super.isRedirected(request, response, context) && response.getFirstHeader("location") != null;
}
@Override
protected URI createLocationURI(final String location) throws ProtocolException {
return super.createLocationURI(StringUtils.replaceAll(location, " ", "%20"));
}
@Override
public URI getLocationURI(HttpResponse httpResponse, HttpContext httpContext) throws ProtocolException {
return null;
}
@Override
public boolean isRedirected(final HttpRequest request, final HttpResponse response, final HttpContext context)
throws ProtocolException
{
if (super.isRedirected(request, response, context)) {
// code below comes from DefaultRedirectStrategy, as method super.getLocationURI cannot be used
// since it modifies context state, and would result in false circular reference detection
final Header locationHeader = response.getFirstHeader(LOCATION);
if (locationHeader == null) {
// got a redirect response, but no location header
throw new ProtocolException("Received redirect response " + response.getStatusLine() +
" but no location present");
}
// Some complication here as it appears that something may be null, but its not clear what was null
final URI sourceUri = ((HttpUriRequest) request).getURI();
final String sourceScheme = schemeOf(sourceUri);
final String sourceHost = hostOf(sourceUri);
final URI targetUri = createLocationURI(locationHeader.getValue());
final String targetScheme = schemeOf(targetUri);
final String targetHost = hostOf(targetUri);
// FIXME: sourceUri might be relative while targetUri is always absolute, which can lead to
// false-positive logging because the source scheme (null) differs from the target ("http")
// One way to fix this is to resolve the relative sourceUri against the original proxy URL,
// but this relies on access to the original configuration.
// nag about redirection peculiarities, in any case
if (!Objects.equals(sourceScheme, targetScheme)) {
if (HTTP.equals(targetScheme)) {
// security risk: HTTPS > HTTP downgrade, you are not safe as you think!
log.debug("Downgrade from HTTPS to HTTP during redirection {} -> {}", sourceUri, targetUri);
}
else if ("https".equals(targetScheme) && Objects.equals(sourceHost, targetHost)) {
// misconfiguration: your repository configured with wrong protocol and causes performance problems?
log.debug("Protocol upgrade during redirection on same host {} -> {}", sourceUri, targetUri);
}
}
// this logic below should trigger only for content fetches made by RRS retrieveItem
// hence, we do this ONLY if the HttpRequest is "marked" as such request
if (Boolean.TRUE == context.getAttribute(CONTENT_RETRIEVAL_MARKER_KEY)) {
if (targetUri.getPath().endsWith("/")) {
log.debug("Not following redirection to index {} -> {}", sourceUri, targetUri);
return false;
}
}
log.debug("Following redirection {} -> {}", sourceUri, targetUri);
return true;
}
return false;
}