org.springframework.http.client.ClientHttpRequest Java Examples

@Override
protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
    
    ClientHttpRequest req = super.createRequest(url, method);
    
    AuthenticatedUser loginUser = AuthenticationContextHolder.getCurrentUser();
    if(loginUser != null && StringUtils.isNotBlank(loginUser.getToken())){
        if (log.isDebugEnabled()) {
            log.debug("request {} with access token:{}", url.toString(), loginUser.getToken());
        }

        req.getHeaders().add(HttpHeaders.AUTHORIZATION,
                loginUser.getToken());
    }
    return req;
}
 

@SuppressWarnings("deprecation")
@Override
public ClientHttpResponse validateRequest(ClientHttpRequest request) throws IOException {
	RequestExpectation expectation = null;
	synchronized (this.requests) {
		if (this.requests.isEmpty()) {
			afterExpectationsDeclared();
		}
		try {
			// Try this first for backwards compatibility
			ClientHttpResponse response = validateRequestInternal(request);
			if (response != null) {
				return response;
			}
			else {
				expectation = matchRequest(request);
			}
		}
		finally {
			this.requests.add(request);
		}
	}
	return expectation.createResponse(request);
}
 

/**
 * Create the {@link RestTemplate} to use.
 * @return the {@link RestTemplate} to use.
 */
protected RestTemplate createTemplate() {

	ClientHttpRequestFactory requestFactory = this.requestFactory.get();

	LinkedHashMap<String, String> defaultHeaders = new LinkedHashMap<>(this.defaultHeaders);
	LinkedHashSet<RestTemplateRequestCustomizer<ClientHttpRequest>> requestCustomizers = new LinkedHashSet<>(
			this.requestCustomizers);

	RestTemplate restTemplate = VaultClients.createRestTemplate(this.endpointProvider,
			new RestTemplateBuilderClientHttpRequestFactoryWrapper(requestFactory, requestCustomizers));

	restTemplate.getInterceptors().add((httpRequest, bytes, clientHttpRequestExecution) -> {

		HttpHeaders headers = httpRequest.getHeaders();
		defaultHeaders.forEach((key, value) -> {
			if (!headers.containsKey(key)) {
				headers.add(key, value);
			}
		});

		return clientHttpRequestExecution.execute(httpRequest, bytes);
	});

	return restTemplate;
}
 

@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
    ClientHttpRequest request = delegate.createRequest(uri, httpMethod);

    String authorizationHeader = oAuthClient.getAuthorizationHeader();
    if (authorizationHeader != null) {
        request.getHeaders()
               .add(AUTHORIZATION_HEADER_KEY, authorizationHeader);
    }

    if (credentials != null && credentials.getProxyUser() != null) {
        request.getHeaders()
               .add(PROXY_USER_HEADER_KEY, credentials.getProxyUser());
    }

    return request;
}
 

@Override
public void doWithRequest(final AsyncClientHttpRequest request) throws IOException {
	if (this.adaptee != null) {
		this.adaptee.doWithRequest(new ClientHttpRequest() {
			@Override
			public ClientHttpResponse execute() throws IOException {
				throw new UnsupportedOperationException("execute not supported");
			}
			@Override
			public OutputStream getBody() throws IOException {
				return request.getBody();
			}
			@Override
			public HttpMethod getMethod() {
				return request.getMethod();
			}
			@Override
			public URI getURI() {
				return request.getURI();
			}
			@Override
			public HttpHeaders getHeaders() {
				return request.getHeaders();
			}
		});
	}
}
 

/**
 * Create a new {@link ClientHttpRequest} via this template's {@link ClientHttpRequestFactory}.
 * @param url the URL to connect to
 * @param method the HTTP method to exectute (GET, POST, etc.)
 * @return the created request
 * @throws IOException in case of I/O errors
 */
protected ClientHttpRequest createRequest(URI url, HttpMethod method) throws IOException {
	ClientHttpRequest request = getRequestFactory().createRequest(url, method);
	if (logger.isDebugEnabled()) {
		logger.debug("Created " + method.name() + " request for \"" + url + "\"");
	}
	return request;
}
 

@Override
public void doWithRequest(final AsyncClientHttpRequest request) throws IOException {
	if (this.adaptee != null) {
		this.adaptee.doWithRequest(new ClientHttpRequest() {
			@Override
			public ClientHttpResponse execute() throws IOException {
				throw new UnsupportedOperationException("execute not supported");
			}
			@Override
			public OutputStream getBody() throws IOException {
				return request.getBody();
			}
			@Override
			public HttpMethod getMethod() {
				return request.getMethod();
			}
			@Override
			public URI getURI() {
				return request.getURI();
			}
			@Override
			public HttpHeaders getHeaders() {
				return request.getHeaders();
			}
		});
	}
}
 

@Override
public void doWithRequest(ClientHttpRequest request) throws IOException {
	if (this.responseType != null) {
		Class<?> responseClass = null;
		if (this.responseType instanceof Class) {
			responseClass = (Class<?>) this.responseType;
		}
		List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
		for (HttpMessageConverter<?> converter : getMessageConverters()) {
			if (responseClass != null) {
				if (converter.canRead(responseClass, null)) {
					allSupportedMediaTypes.addAll(getSupportedMediaTypes(converter));
				}
			}
			else if (converter instanceof GenericHttpMessageConverter) {
				GenericHttpMessageConverter<?> genericConverter = (GenericHttpMessageConverter<?>) converter;
				if (genericConverter.canRead(this.responseType, null, null)) {
					allSupportedMediaTypes.addAll(getSupportedMediaTypes(converter));
				}
			}
		}
		if (!allSupportedMediaTypes.isEmpty()) {
			MediaType.sortBySpecificity(allSupportedMediaTypes);
			if (logger.isDebugEnabled()) {
				logger.debug("Setting request Accept header to " + allSupportedMediaTypes);
			}
			request.getHeaders().setAccept(allSupportedMediaTypes);
		}
	}
}
 

/**
 * Execute the given method on the provided URI.
 * <p>The {@link ClientHttpRequest} is processed using the {@link RequestCallback};
 * the response with the {@link ResponseExtractor}.
 * @param url the fully-expanded URL to connect to
 * @param method the HTTP method to execute (GET, POST, etc.)
 * @param requestCallback object that prepares the request (can be {@code null})
 * @param responseExtractor object that extracts the return value from the response (can be {@code null})
 * @return an arbitrary object, as returned by the {@link ResponseExtractor}
 */
protected <T> T doExecute(URI url, HttpMethod method, RequestCallback requestCallback,
		ResponseExtractor<T> responseExtractor) throws RestClientException {

	Assert.notNull(url, "'url' must not be null");
	Assert.notNull(method, "'method' must not be null");
	ClientHttpResponse response = null;
	try {
		ClientHttpRequest request = createRequest(url, method);
		if (requestCallback != null) {
			requestCallback.doWithRequest(request);
		}
		response = request.execute();
		handleResponse(url, method, response);
		if (responseExtractor != null) {
			return responseExtractor.extractData(response);
		}
		else {
			return null;
		}
	}
	catch (IOException ex) {
		String resource = url.toString();
		String query = url.getRawQuery();
		resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
		throw new ResourceAccessException("I/O error on " + method.name() +
				" request for \"" + resource + "\": " + ex.getMessage(), ex);
	}
	finally {
		if (response != null) {
			response.close();
		}
	}
}
 

@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
    ClientHttpRequest request = requestFactory.createRequest(uri, httpMethod);
    HttpHeaders requestHeaders = request.getHeaders();
    if (!requestHeaders.containsKey(HttpHeaders.AUTHORIZATION)) {
        requestHeaders.add(HttpHeaders.AUTHORIZATION, "Bearer " + computeAuthorizationToken());
    }
    return request;
}
 

/**
 * Return details of executed requests.
 */
protected String getRequestDetails() {
	StringBuilder sb = new StringBuilder();
	sb.append(this.requests.size()).append(" request(s) executed");
	if (!this.requests.isEmpty()) {
		sb.append(":\n");
		for (ClientHttpRequest request : this.requests) {
			sb.append(request.toString()).append("\n");
		}
	}
	else {
		sb.append(".\n");
	}
	return sb.toString();
}
 

/**
 * {@inheritDoc}
 */
@Override
public void doWithRequest(ClientHttpRequest request) throws IOException {
  orgCallback.doWithRequest(request);
  CseClientHttpRequest req = (CseClientHttpRequest) request;
  req.setResponseType(overrideResponseType());

  if (!CseHttpEntity.class.isInstance(requestBody)) {
    return;
  }

  CseHttpEntity<?> entity = (CseHttpEntity<?>) requestBody;
  req.setContext(entity.getContext());
}
 

/**
 * Assert the request content type is compatible with the given
 * content type as defined by {@link MediaType#isCompatibleWith(MediaType)}.
 */
public RequestMatcher contentTypeCompatibleWith(final MediaType contentType) {
	return new RequestMatcher() {
		@Override
		public void match(ClientHttpRequest request) throws IOException, AssertionError {
			MediaType actualContentType = request.getHeaders().getContentType();
			assertTrue("Content type not set", actualContentType != null);
			assertTrue("Content type [" + actualContentType + "] is not compatible with [" + contentType + "]",
					actualContentType.isCompatibleWith(contentType));
		}
	};
}
 

/**
 * Assert request header values with the given Hamcrest matcher.
 */
@SuppressWarnings("unchecked")
public static RequestMatcher header(final String name, final Matcher<? super String>... matchers) {
	return new RequestMatcher() {
		@Override
		public void match(ClientHttpRequest request) {
			assertHeaderValueCount(name, request.getHeaders(), matchers.length);
			for (int i = 0 ; i < matchers.length; i++) {
				assertThat("Request header", request.getHeaders().get(name).get(i), matchers[i]);
			}
		}
	};
}
 

/**
 * Assert the request content type as a {@link MediaType}.
 */
public RequestMatcher contentType(final MediaType expectedContentType) {
	return new RequestMatcher() {
		@Override
		public void match(ClientHttpRequest request) throws IOException, AssertionError {
			MediaType actualContentType = request.getHeaders().getContentType();
			assertTrue("Content type not set", actualContentType != null);
			assertEquals("Content type", expectedContentType, actualContentType);
		}
	};
}
 

@SuppressWarnings("deprecation")
private ClientHttpRequest createRequest(HttpMethod method, String url) {
	try {
		return new org.springframework.mock.http.client.MockAsyncClientHttpRequest(method,  new URI(url));
	}
	catch (URISyntaxException ex) {
		throw new IllegalStateException(ex);
	}
}
 

/**
 * Execute the given method on the provided URI.
 * <p>The {@link ClientHttpRequest} is processed using the {@link RequestCallback};
 * the response with the {@link ResponseExtractor}.
 * @param url the fully-expanded URL to connect to
 * @param method the HTTP method to execute (GET, POST, etc.)
 * @param requestCallback object that prepares the request (can be {@code null})
 * @param responseExtractor object that extracts the return value from the response (can be {@code null})
 * @return an arbitrary object, as returned by the {@link ResponseExtractor}
 */
@Nullable
protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
		@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {

	Assert.notNull(url, "URI is required");
	Assert.notNull(method, "HttpMethod is required");
	ClientHttpResponse response = null;
	try {
		ClientHttpRequest request = createRequest(url, method);
		if (requestCallback != null) {
			requestCallback.doWithRequest(request);
		}
		response = request.execute();
		handleResponse(url, method, response);
		return (responseExtractor != null ? responseExtractor.extractData(response) : null);
	}
	catch (IOException ex) {
		String resource = url.toString();
		String query = url.getRawQuery();
		resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
		throw new ResourceAccessException("I/O error on " + method.name() +
				" request for \"" + resource + "\": " + ex.getMessage(), ex);
	}
	finally {
		if (response != null) {
			response.close();
		}
	}
}
 

/**
 * Return a matching expectation, or {@code null} if none match.
 */
@Nullable
public RequestExpectation findExpectation(ClientHttpRequest request) throws IOException {
	for (RequestExpectation expectation : this.expectations) {
		try {
			expectation.match(request);
			return expectation;
		}
		catch (AssertionError error) {
			// We're looking to find a match or return null..
		}
	}
	return null;
}
 

/**
 * Compare the body of the request to the given byte array.
 */
public RequestMatcher bytes(final byte[] expectedContent) {
	return new RequestMatcher() {
		@Override
		public void match(ClientHttpRequest request) throws IOException, AssertionError {
			MockClientHttpRequest mockRequest = (MockClientHttpRequest) request;
			assertEquals("Request content", expectedContent, mockRequest.getBodyAsBytes());
		}
	};
}
 

@Override
public RequestExpectation matchRequest(ClientHttpRequest request) throws IOException {
	RequestExpectation expectation = this.remainingExpectations.findExpectation(request);
	if (expectation == null) {
		throw createUnexpectedRequestError(request);
	}
	this.remainingExpectations.update(expectation);
	return expectation;
}
 

@Override
public final void match(ClientHttpRequest request) throws IOException, AssertionError {
	try {
		MockClientHttpRequest mockRequest = (MockClientHttpRequest) request;
		matchInternal(mockRequest);
	}
	catch (Exception e) {
		throw new AssertionError("Failed to parse XML request content: " + e.getMessage());
	}
}
 

/**
 * Expect a request to the given URI.
 * @param uri the expected URI
 * @return the request matcher
 */
public static RequestMatcher requestTo(final URI uri) {
	Assert.notNull(uri, "'uri' must not be null");
	return new RequestMatcher() {
		@Override
		public void match(ClientHttpRequest request) throws IOException, AssertionError {
			AssertionErrors.assertEquals("Unexpected request", uri, request.getURI());
		}
	};
}
 

/**
 * Get the body of the request as a UTF-8 string and appply the given {@link Matcher}.
 */
public RequestMatcher string(final Matcher<? super String> matcher) {
	return new RequestMatcher() {
		@Override
		public void match(ClientHttpRequest request) throws IOException, AssertionError {
			MockClientHttpRequest mockRequest = (MockClientHttpRequest) request;
			assertThat("Request content", mockRequest.getBodyAsString(), matcher);
		}
	};
}
 

@Override
public final void match(ClientHttpRequest request) throws IOException, AssertionError {
	try {
		MockClientHttpRequest mockRequest = (MockClientHttpRequest) request;
		matchInternal(mockRequest);
	}
	catch (Exception ex) {
		throw new AssertionError("Failed to parse XML request content", ex);
	}
}
 

@Override
public void doWithRequest(ClientHttpRequest request) throws IOException {
    request.getHeaders().putAll(getRequestHttpHeaders());

    if (null != targetRequestCallback) {
        targetRequestCallback.doWithRequest(request);
    }
}
 

@Test
public void interceptShouldAddHeader() throws Exception {
	SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
	ClientHttpRequest request = requestFactory.createRequest(new URI("http://example.com"), HttpMethod.GET);
	ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.class);
	byte[] body = new byte[] {};
	new BasicAuthorizationInterceptor("spring", "boot").intercept(request, body,
			execution);
	verify(execution).execute(request, body);
	assertEquals("Basic c3ByaW5nOmJvb3Q=", request.getHeaders().getFirst("Authorization"));
}
 

@Before
public void setup() {
	requestFactory = mock(ClientHttpRequestFactory.class);
	request = mock(ClientHttpRequest.class);
	response = mock(ClientHttpResponse.class);
	errorHandler = mock(ResponseErrorHandler.class);
	converter = mock(HttpMessageConverter.class);
	template = new RestTemplate(Collections.singletonList(converter));
	template.setRequestFactory(requestFactory);
	template.setErrorHandler(errorHandler);
}
 

@Override
public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod) throws IOException {
    ClientHttpRequest request = super.createRequest(uri, httpMethod);
    HttpHeaders headers = request.getHeaders();
    headers.add("User-Agent", "Mozilla/5.0 (X11; Linux x86_64; rv:33.0) Gecko/20100101 Firefox/33.0");
    headers.add("Connection", "keep-alive");
    return request;
}
 

@Test
public void failFast() throws Exception {
	ClientHttpRequestFactory requestFactory = Mockito
			.mock(ClientHttpRequestFactory.class);
	ClientHttpRequest request = Mockito.mock(ClientHttpRequest.class);
	ClientHttpResponse response = Mockito.mock(ClientHttpResponse.class);
	Mockito.when(requestFactory.createRequest(Mockito.any(URI.class),
			Mockito.any(HttpMethod.class))).thenReturn(request);
	RestTemplate restTemplate = new RestTemplate(requestFactory);
	ConfigClientProperties defaults = new ConfigClientProperties(this.environment);
	defaults.setFailFast(true);
	this.locator = new ConfigServicePropertySourceLocator(defaults);
	Mockito.when(request.getHeaders()).thenReturn(new HttpHeaders());
	Mockito.when(request.execute()).thenReturn(response);
	HttpHeaders headers = new HttpHeaders();
	headers.setContentType(MediaType.APPLICATION_JSON);
	Mockito.when(response.getHeaders()).thenReturn(headers);
	Mockito.when(response.getStatusCode())
			.thenReturn(HttpStatus.INTERNAL_SERVER_ERROR);
	Mockito.when(response.getBody())
			.thenReturn(new ByteArrayInputStream("{}".getBytes()));
	this.locator.setRestTemplate(restTemplate);
	this.expected
			.expectCause(IsInstanceOf.instanceOf(IllegalArgumentException.class));
	this.expected.expectMessage("fail fast property is set");
	this.locator.locateCollection(this.environment);
}
 

/**
 * Execute the given method on the provided URI.
 * <p>The {@link ClientHttpRequest} is processed using the {@link RequestCallback};
 * the response with the {@link ResponseExtractor}.
 * @param url the fully-expanded URL to connect to
 * @param method the HTTP method to execute (GET, POST, etc.)
 * @param requestCallback object that prepares the request (can be {@code null})
 * @param responseExtractor object that extracts the return value from the response (can be {@code null})
 * @return an arbitrary object, as returned by the {@link ResponseExtractor}
 */
@Nullable
protected <T> T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback,
		@Nullable ResponseExtractor<T> responseExtractor) throws RestClientException {

	Assert.notNull(url, "URI is required");
	Assert.notNull(method, "HttpMethod is required");
	ClientHttpResponse response = null;
	try {
		ClientHttpRequest request = createRequest(url, method);
		if (requestCallback != null) {
			requestCallback.doWithRequest(request);
		}
		response = request.execute();
		handleResponse(url, method, response);
		return (responseExtractor != null ? responseExtractor.extractData(response) : null);
	}
	catch (IOException ex) {
		String resource = url.toString();
		String query = url.getRawQuery();
		resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
		throw new ResourceAccessException("I/O error on " + method.name() +
				" request for \"" + resource + "\": " + ex.getMessage(), ex);
	}
	finally {
		if (response != null) {
			response.close();
		}
	}
}