org.apache.http.client.methods.HttpRequestWrapper Java Examples

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

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

@Override
public @Nullable String getRequestUrl(@Nullable HttpRequest request) {
    if (request == null) {
        return null;
    } 

    String uri = request.getRequestLine().getUri();

    if (request instanceof HttpRequestWrapper && uri.startsWith("/")) {
        HttpRequestWrapper wrapper = (HttpRequestWrapper) request;
        HttpHost target = wrapper.getTarget();
        if (target != null) {
            uri = wrapper.getTarget().toURI() + uri;
        }
    }
    
    return uri;
}
 

@DataProvider(value = {
    "http://foo.bar/some/path                       |   /some/path",
    "http://foo.bar/some/path?thing=stuff           |   /some/path",
    "/some/path                                     |   /some/path",
    "/some/path?thing=stuff                         |   /some/path",
    "http://foo.bar/                                |   /",
    "http://foo.bar/?thing=stuff                    |   /",
    "/                                              |   /",
    "/?thing=stuff                                  |   /",
}, splitBy = "\\|")
@Test
public void getRequestPath_works_as_expected_for_a_request_that_is_an_HttpRequestWrapper(
    String uriString, String expectedResult
) {
    // given
    HttpRequestWrapper requestWrapperMock = mock(HttpRequestWrapper.class);
    doReturn(URI.create(uriString)).when(requestWrapperMock).getURI();

    // when
    String result = implSpy.getRequestPath(requestWrapperMock);

    // then
    assertThat(result).isEqualTo(expectedResult);
}
 

GetRequestUrlScenario(
    boolean requestIsNull, boolean requestIsWrapper, Object baseUri, boolean targetIsNull,
    String targetUri, String expectedResult
) {
    this.expectedResult = expectedResult;
    HttpRequest request = null;

    if (!requestIsNull) {
        request = (requestIsWrapper) ? mock(HttpRequestWrapper.class) : mock(HttpRequest.class);
        RequestLine requestLine = mock(RequestLine.class);
        doReturn(requestLine).when(request).getRequestLine();
        doReturn(baseUri).when(requestLine).getUri();

        if (!targetIsNull) {
            HttpHost target = HttpHost.create(targetUri);
            doReturn(target).when((HttpRequestWrapper) request).getTarget();
        }
    }

    this.requestMock = request;
}
 

private String inferUri(HttpRequest request) {
  String inferredUri = request.getRequestLine().getUri();
  if (!isValidUrl(inferredUri)) { // Missing schema and domain name
    String host = getHost(request);
    String inferredScheme = "http";
    if (host.endsWith(":443")) {
      inferredScheme = "https";
    } else if ((request instanceof RequestWrapper) || (request instanceof HttpRequestWrapper)) {
      if (getOriginalRequestUri(request).startsWith("https")) {
        // This is for original URL, so if during redirects we go out of HTTPs, this might be a wrong guess
        inferredScheme = "https";
      }
    }

    if ("CONNECT".equals(request.getRequestLine().getMethod())) {
      inferredUri = String.format("%s://%s", inferredScheme, host);
    } else {
      inferredUri =
          String.format("%s://%s/%s", inferredScheme, host, inferredUri)
              .replaceAll("(?<!http(s)?:)//", "/");
    }
  }
  return inferredUri;
}
 

@Test
public void testProcess() throws Exception {
  URI testURI = new URIBuilder()
      .setPath("/1/statuses/update.json")
      .setParameter("include_entities", "true")
      .build();
  HttpPost testRequest = new HttpPost(testURI);
  testRequest.setEntity(new StringEntity("status="+security.encode("Hello Ladies + Gentlemen, a signed OAuth request!")));
  HttpHost host = new HttpHost("api.twitter.com", -1, "https");
  HttpRequestWrapper wrapper = HttpRequestWrapper.wrap(testRequest, host);
  TwitterOAuthConfiguration testOauthConfiguration = new TwitterOAuthConfiguration()
      .withConsumerKey("xvz1evFS4wEEPTGEFPHBog")
      .withConsumerSecret("kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw")
      .withAccessToken("370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb")
      .withAccessTokenSecret("LswwdoUaIvS8ltyTt5jkRh4J50vUPVVHtR2YPi5kE");
  TwitterOAuthRequestInterceptor interceptor = Mockito.spy(new TwitterOAuthRequestInterceptor(testOauthConfiguration));
  Mockito.when(interceptor.generateNonce()).thenReturn("kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg");
  Mockito.when(interceptor.generateTimestamp()).thenReturn("1318622958");
  interceptor.process(wrapper, new HttpCoreContext());
  assertEquals(1, wrapper.getHeaders("Authorization").length);
  String actual = wrapper.getFirstHeader("Authorization").getValue();
  String expected = "OAuth oauth_consumer_key=\"xvz1evFS4wEEPTGEFPHBog\", oauth_nonce=\"kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg\", oauth_signature=\"tnnArxj06cWHq44gCs1OSKk%2FjLY%3D\", oauth_signature_method=\"HMAC-SHA1\", oauth_timestamp=\"1318622958\", oauth_token=\"370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb\", oauth_version=\"1.0\"";
  assertEquals(expected, actual);
}
 

@Override
public Proxy determineProxy(HttpHost host, HttpRequest request, HttpContext context, IPPool ipPool,
        CrawlerSession crawlerSession) {
    HttpClientContext httpClientContext = HttpClientContext.adapt(context);

    Proxy proxy = (Proxy) crawlerSession.getExtInfo(VSCRAWLER_AVPROXY_KEY);
    if (proxy == null) {
        String accessUrl = null;
        if (request instanceof HttpRequestWrapper || request instanceof HttpGet) {
            accessUrl = HttpUriRequest.class.cast(request).getURI().toString();
        }
        if (!PoolUtil.isDungProxyEnabled(httpClientContext)) {
            log.info("{}不会被代理", accessUrl);
            return null;
        }
        proxy = ipPool.getIP(host.getHostName(), accessUrl);
        if (proxy == null) {
            return null;
        }
        crawlerSession.setExtInfo(VSCRAWLER_AVPROXY_KEY, proxy);
    }

    return proxy;
}
 

@Override
public CloseableHttpResponse execute(HttpRoute route, HttpRequestWrapper request, HttpClientContext clientContext,
        HttpExecutionAware execAware) throws IOException, HttpException {
    Proxy proxy = (Proxy) clientContext.getAttribute(VSCrawlerConstant.VSCRAWLER_AVPROXY_KEY);
    if (proxy != null) {
        proxy.recordUsage();
    }
    try {
        return delegate.execute(route, request, clientContext, execAware);
    } catch (IOException ioe) {
        if (proxy != null) {
            proxy.recordFailed();
        }
        throw ioe;
    }
}
 

@Advice.OnMethodEnter(suppress = Throwable.class)
private static void onBeforeExecute(@Advice.Argument(0) HttpRoute route,
                                    @Advice.Argument(1) HttpRequestWrapper request,
                                    @Advice.Local("span") Span span) {
    if (tracer == null || tracer.getActive() == null) {
        return;
    }
    final AbstractSpan<?> parent = tracer.getActive();
    span = HttpClientHelper.startHttpClientSpan(parent, request.getMethod(), request.getURI(), route.getTargetHost().getHostName());
    TextHeaderSetter<HttpRequest> headerSetter = headerSetterHelperClassManager.getForClassLoaderOfClass(HttpRequest.class);
    TextHeaderGetter<HttpRequest> headerGetter = headerGetterHelperClassManager.getForClassLoaderOfClass(HttpRequest.class);
    if (span != null) {
        span.activate();
        if (headerSetter != null) {
            span.propagateTraceContext(request, headerSetter);
        }
    } else if (headerGetter != null && !TraceContext.containsTraceContextTextHeaders(request, headerGetter)
        && headerSetter != null && parent != null) {
        // re-adds the header on redirects
        parent.propagateTraceContext(request, headerSetter);
    }
}
 

protected final String buildMessage(String nonce, long timestamp, HttpRequestWrapper request)
    throws IOException {
  URI uri = request.getURI();
  String canonicalUrl = uri.getRawPath();
  if (uri.getQuery() != null) {
    canonicalUrl += "?" + uri.getRawQuery();
  }

  String body = "";
  // PATCH,POST,PUT
  if (request.getOriginal() instanceof WechatPayUploadHttpPost) {
    body = ((WechatPayUploadHttpPost) request.getOriginal()).getMeta();
  } else if (request instanceof HttpEntityEnclosingRequest) {
    body = EntityUtils.toString(((HttpEntityEnclosingRequest) request).getEntity());
  }

  return request.getRequestLine().getMethod() + "\n"
      + canonicalUrl + "\n"
      + timestamp + "\n"
      + nonce + "\n"
      + body + "\n";
}
 

private CloseableHttpResponse executeWithSignature(HttpRoute route, HttpRequestWrapper request,
    HttpClientContext context, HttpExecutionAware execAware) throws IOException, HttpException {
  // 上传类不需要消耗两次故不做转换
  if (!(request.getOriginal() instanceof WechatPayUploadHttpPost)) {
    convertToRepeatableRequestEntity(request);
  }
  // 添加认证信息
  request.addHeader("Authorization",
      credentials.getSchema() + " " + credentials.getToken(request));

  // 执行
  CloseableHttpResponse response = mainExec.execute(route, request, context, execAware);

  // 对成功应答验签
  StatusLine statusLine = response.getStatusLine();
  if (statusLine.getStatusCode() >= 200 && statusLine.getStatusCode() < 300) {
    convertToRepeatableResponseEntity(response);
    if (!validator.validate(response)) {
      throw new HttpException("应答的微信支付签名验证失败");
    }
  }
  return response;
}
 

@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 final String getToken(HttpRequestWrapper request) throws IOException {
  String nonceStr = generateNonceStr();
  long timestamp = generateTimestamp();

  String message = buildMessage(nonceStr, timestamp, request);
  log.debug("authorization message=[{}]", message);

  Signer.SignatureResult signature = signer.sign(message.getBytes(StandardCharsets.UTF_8));

  String token = "mchid=\"" + getMerchantId() + "\","
      + "nonce_str=\"" + nonceStr + "\","
      + "timestamp=\"" + timestamp + "\","
      + "serial_no=\"" + signature.certificateSerialNumber + "\","
      + "signature=\"" + signature.sign + "\"";
  log.debug("authorization token=[{}]", token);

  return token;
}
 

private static URI getOriginalRequestUri(final HttpRequest request) {
    if (request instanceof HttpRequestWrapper) {
        return extractRequestUri(HttpRequestWrapper.class.cast(request).getOriginal());
    } else if (request instanceof HttpUriRequest) {
        return HttpUriRequest.class.cast(request).getURI();
    } else {
        return extractRequestUri(request);
    }
}
 

@Test
public void curlWithDefaultUserAgent () {
    this.curl ("https://put.anything.in.this.url:1337",
            context ->
                    assertEquals (Curl.class.getPackage ().getName () + "/" + Curl.getVersion () +
                                    VersionInfo.getUserAgent (", Apache-HttpClient",
                                            "org.apache.http.client", CurlFakeTest.class),
                            ((HttpRequestWrapper)
                                    context.getAttribute ("http.request"))
                                    .getLastHeader ("User-Agent").getValue ()));
}
 

@Override
public void process(HttpRequest request, HttpContext context) throws HttpException,
IOException {
  log.info("Intercepted params: {}", context);

  HttpRequestWrapper wrapper = (HttpRequestWrapper) request;
  URIBuilder uribuilder = new URIBuilder(wrapper.getURI());
  uribuilder.addParameter("b", "\u4321");
  try {
    wrapper.setURI(uribuilder.build());
  } catch (URISyntaxException ex) {
    throw new HttpException("Invalid request URI", ex);
  }
}
 

@Test
public void curlVerifyUserAgentAndAOptionTogether () {
    this.curl ("-H 'User-Agent: toto' -A titi https://put.anything.in.this.url:1337",
            context ->
                    assertEquals ("toto",
                            ((HttpRequestWrapper)
                                    context.getAttribute ("http.request"))
                                    .getLastHeader ("User-Agent").getValue ()));
}
 

private void setRequestUri(HttpRequest request, URI uri) {
    if (request instanceof HttpRequestWrapper) {
        setRequestUri(((HttpRequestWrapper) request).getOriginal(), uri);
    } else if (request instanceof RequestWrapper) {
        setRequestUri(((RequestWrapper) request).getOriginal(), uri);
    } else {
        ((HttpRequestBase) request).setURI(uri);
    }
}
 

@Override
public CloseableHttpResponse execute(HttpRoute route, HttpRequestWrapper request,
                                     HttpClientContext clientContext,
                                     HttpExecutionAware execAware) throws IOException, HttpException {
    capturedSpan = Tracer.getInstance().getCurrentSpan();
    
    doReturn(statusLineMock).when(response).getStatusLine();
    
    if (exceptionToThrow != null) {
        throw exceptionToThrow;
    }
    // Return a graceful 500 from the response
    doReturn(500).when(statusLineMock).getStatusCode();
    return response;
}
 

@SuppressWarnings("deprecation")
private static String getOriginalRequestUri(HttpRequest request) {
  if (request instanceof HttpRequestWrapper) {
    return ((HttpRequestWrapper) request).getOriginal().getRequestLine().getUri();
  } else if (request instanceof RequestWrapper) {
    return ((RequestWrapper) request).getOriginal().getRequestLine().getUri();
  } else {
    throw new IllegalArgumentException("Unsupported request class type: " + request.getClass());
  }
}
 

private Multimap<String, String> params(HttpRequest request) throws IOException {
    final String rawQuery = ((HttpRequestWrapper) request).getURI().getRawQuery();
    if (Strings.isNullOrEmpty(rawQuery))
        return ImmutableListMultimap.of();

    return params(URLDecoder.decode(rawQuery, StandardCharsets.UTF_8.name()));
}
 

private Optional<byte[]> body(HttpRequest request) throws IOException {
    final HttpRequest original = ((HttpRequestWrapper) request).getOriginal();
    if (! HttpEntityEnclosingRequest.class.isAssignableFrom(original.getClass())) {
        return Optional.absent();
    }
    return Optional.fromNullable(((HttpEntityEnclosingRequest) original).getEntity()).transform(TO_BYTE_ARRAY);
}
 

@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 void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
    MethodInterceptResult result) throws Throwable {
    HttpContext context = CONTEXT_LOCAL.get();
    CONTEXT_LOCAL.remove();
    if (context == null) {
        return;
    }
    final ContextCarrier contextCarrier = new ContextCarrier();
    HttpRequestWrapper requestWrapper = (HttpRequestWrapper) context.getAttribute(HttpClientContext.HTTP_REQUEST);
    HttpHost httpHost = (HttpHost) context.getAttribute(HttpClientContext.HTTP_TARGET_HOST);

    RequestLine requestLine = requestWrapper.getRequestLine();
    String uri = requestLine.getUri();
    String operationName = uri.startsWith("http") ? new URL(uri).getPath() : uri;
    int port = httpHost.getPort();
    AbstractSpan span = ContextManager.createExitSpan(operationName, contextCarrier, httpHost.getHostName() + ":" + (port == -1 ? 80 : port));
    span.setComponent(ComponentsDefine.HTTP_ASYNC_CLIENT);
    Tags.URL.set(span, requestWrapper.getOriginal().getRequestLine().getUri());
    Tags.HTTP.METHOD.set(span, requestLine.getMethod());
    SpanLayer.asHttp(span);
    CarrierItem next = contextCarrier.items();
    while (next.hasNext()) {
        next = next.next();
        requestWrapper.setHeader(next.getHeadKey(), next.getHeadValue());
    }
}
 

/**
 * Checks if request is intended for Gerrit host.
 */
private boolean isForGerritHost(HttpRequest request) {
    if (!(request instanceof HttpRequestWrapper)) return false;
    HttpRequest originalRequest = ((HttpRequestWrapper) request).getOriginal();
    if (!(originalRequest instanceof HttpRequestBase)) return false;
    URI uri = ((HttpRequestBase) originalRequest).getURI();
    URI authDataUri = URI.create(authData.getHost());
    if (uri == null || uri.getHost() == null) return false;
    boolean hostEquals = uri.getHost().equals(authDataUri.getHost());
    boolean portEquals = uri.getPort() == authDataUri.getPort();
    return hostEquals && portEquals;
}
 

/**
 * Decorate with fetch event managements
 * 
 * @param wrapped
 * @return the decorated ClientExecChain
 */
private ClientExecChain addFetchEvent(final ClientExecChain wrapped) {
    return new ClientExecChain() {

        @Override
        public CloseableHttpResponse execute(HttpRoute route, HttpRequestWrapper request,
                HttpClientContext httpClientContext, HttpExecutionAware execAware) throws IOException,
                HttpException {
            OutgoingRequestContext context = OutgoingRequestContext.adapt(httpClientContext);
            // Create request event
            FetchEvent fetchEvent = new FetchEvent(context, request);

            eventManager.fire(EventManager.EVENT_FETCH_PRE, fetchEvent);

            if (fetchEvent.isExit()) {
                if (fetchEvent.getHttpResponse() == null) {
                    // Provide an error page in order to avoid a NullPointerException
                    fetchEvent.setHttpResponse(HttpErrorPage.generateHttpResponse(
                            HttpStatus.SC_INTERNAL_SERVER_ERROR,
                            "An extension stopped the processing of the request without providing a response"));
                }
            } else {
                try {
                    fetchEvent.setHttpResponse(wrapped.execute(route, request, context, execAware));
                    eventManager.fire(EventManager.EVENT_FETCH_POST, fetchEvent);
                } catch (IOException | HttpException e) {
                    fetchEvent.setHttpResponse(HttpErrorPage.generateHttpResponse(e));
                    // Usually we want to render and cache the exception but we let an extension decide
                    fetchEvent.setExit(true);
                    eventManager.fire(EventManager.EVENT_FETCH_POST, fetchEvent);
                    if (!fetchEvent.isExit())
                        throw e; // Throw the exception and let http client process it (may retry)
                }
            }

            return fetchEvent.getHttpResponse();
        }
    };

}
 

@Override
public CloseableHttpResponse execute(HttpHost target, HttpRequest request) throws IOException, ClientProtocolException {
  HttpRequestWrapper wrap = HttpRequestWrapper.wrap(request, target);
  adviseRobotsTxt(wrap.getURI());
  wrap.setURI(applyPHP(wrap.getURI()));
  return client.execute(wrap);
}
 

protected void convertToRepeatableRequestEntity(HttpRequestWrapper request) throws IOException {
  if (request instanceof HttpEntityEnclosingRequest) {
    HttpEntity entity = ((HttpEntityEnclosingRequest) request).getEntity();
    if (entity != null) {
      ((HttpEntityEnclosingRequest) request).setEntity(new BufferedHttpEntity(entity));
    }
  }
}
 

@Override
public CloseableHttpResponse execute(HttpRoute route, HttpRequestWrapper request,
    HttpClientContext context, HttpExecutionAware execAware) throws IOException, HttpException {
  if (request.getURI().getHost().endsWith(".mch.weixin.qq.com")) {
    return executeWithSignature(route, request, context, execAware);
  } else {
    return mainExec.execute(route, request, context, execAware);
  }
}