Java Examples for org.springframework.http.client.ClientHttpRequestInterceptor

@Bean
public RestTemplate restTemplate() {
    List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
    interceptors.add(new ClientLogInterceptor());
    RestTemplate restTemplate = new RestTemplate(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()));
    restTemplate.setInterceptors(interceptors);
    return restTemplate;
}

/** {@inheritDoc} */
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    // RestTemplate et getInterceptors() existent depuis spring-web 3.1.0.RELEASE
    if (REST_TEMPLATE_INTERCEPTOR_AVAILABLE && bean instanceof RestTemplate) {
        final RestTemplate restTemplate = (RestTemplate) bean;
        final List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>(restTemplate.getInterceptors());
        for (final ClientHttpRequestInterceptor interceptor : interceptors) {
            if (interceptor instanceof SpringRestTemplateInterceptor) {
                return bean;
            }
        }
        interceptors.add(SpringRestTemplateInterceptor.SINGLETON);
        restTemplate.setInterceptors(interceptors);
    }
    return bean;
}

private void addHeaders(final RestRequestHeader[] requestHeaders) {
    final ClientHttpRequestInterceptor interceptor = new ClientHttpRequestInterceptor() {

        @Override
        public ClientHttpResponse intercept(final HttpRequest request, final byte[] body, final ClientHttpRequestExecution execution) throws IOException {
            for (final RestRequestHeader requestHeader : requestHeaders) {
                request.getHeaders().add(requestHeader.getKey(), requestHeader.getValue());
            }
            return execution.execute(request, body);
        }
    };
    restTemplate.setInterceptors(Collections.singletonList(interceptor));
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof RestTemplate) {
        if (this.interceptor == null) {
            this.interceptor = this.context.getBean(MetricsClientHttpRequestInterceptor.class);
        }
        RestTemplate restTemplate = (RestTemplate) bean;
        // create a new list as the old one may be unmodifiable (ie Arrays.asList())
        ArrayList<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
        interceptors.add(interceptor);
        interceptors.addAll(restTemplate.getInterceptors());
        restTemplate.setInterceptors(interceptors);
    }
    return bean;
}

@Test
public void getInterceptors() throws Exception {
    TestInterceptingHttpAccessor accessor = new TestInterceptingHttpAccessor();
    List<ClientHttpRequestInterceptor> interceptors = Arrays.asList(new SecondClientHttpRequestInterceptor(), new ThirdClientHttpRequestInterceptor(), new FirstClientHttpRequestInterceptor());
    accessor.setInterceptors(interceptors);
    assertThat(accessor.getInterceptors().get(0), Matchers.instanceOf(FirstClientHttpRequestInterceptor.class));
    assertThat(accessor.getInterceptors().get(1), Matchers.instanceOf(SecondClientHttpRequestInterceptor.class));
    assertThat(accessor.getInterceptors().get(2), Matchers.instanceOf(ThirdClientHttpRequestInterceptor.class));
}

private RestTemplate createRestTemplate() {
    RestTemplate rest = new RestTemplate();
    //		IProxyService proxyService = GettingStartedActivator.getDefault().getProxyService();
    //		if (proxyService!=null && proxyService.isProxiesEnabled()) {
    //			final IProxyData[] existingProxies = proxyService.getProxyData();
    //			if (existingProxies != null && existingProxies.length>0) {
    //				//TODO: Do some magic to configure proxies on the http request based on its url.
    //
    //				//some interesting code in here:
    //				//org.cloudfoundry.ide.eclipse.internal.server.core.CloudFoundryClientFactory.getProxy(URL)
    //			}
    //		}
    //Add authentication
    rest = credentials.apply(rest);
    //Add json parsing capability using Jackson mapper.
    List<HttpMessageConverter<?>> messageConverters = new ArrayList<>();
    messageConverters.add(new Spring3MappingJacksonHttpMessageConverter());
    rest.setMessageConverters(messageConverters);
    //Add rate limit logging
    if (LOG_GITHUB_RATE_LIMIT) {
        rest.getInterceptors().add(new ClientHttpRequestInterceptor() {

            //@Override
            public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
                ClientHttpResponse res = execution.execute(request, body);
                System.out.println("==== Github: " + request.getURI() + "  =========");
                for (Entry<String, List<String>> header : res.getHeaders().entrySet()) {
                    if (header.getKey().contains("RateLimit")) {
                        System.out.print(header.getKey() + ":");
                        for (String value : header.getValue()) {
                            System.out.print(" " + value);
                        }
                        System.out.println();
                    }
                }
                System.out.println("======================= ");
                return res;
            }
        });
    }
    return rest;
}

private static RestTemplate createRestTemplate(String host, String username, String password, Set<ClientHttpRequestInterceptor> interceptors) throws GeneralSecurityException {
    CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(new AuthScope(host, 25555), new UsernamePasswordCredentials(username, password));
    SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustSelfSignedStrategy()).useTLS().build();
    SSLConnectionSocketFactory connectionFactory = new SSLConnectionSocketFactory(sslContext, new AllowAllHostnameVerifier());
    HttpClient httpClient = HttpClientBuilder.create().disableRedirectHandling().setDefaultCredentialsProvider(credentialsProvider).setSSLSocketFactory(connectionFactory).build();
    RestTemplate restTemplate = new RestTemplate(new HttpComponentsClientHttpRequestFactory(httpClient));
    restTemplate.getInterceptors().addAll(interceptors);
    return restTemplate;
}

public ClientHttpResponse execute() throws IOException {
    ClientHttpResponse response = delegate.execute();
    if (response.getStatusCode() == HttpStatus.UNAUTHORIZED) {
        logger.info("Token is invalid (got 401 response). Trying get a new token using the refresh token");
        String newToken = callback.refreshToken();
        if (newToken == null) {
            return response;
        } else {
            logger.info("New token obtained, retrying the request with it");
            // reflectively set the new token at the oauth2 interceptor (no nicer way, alas)
            for (ClientHttpRequestInterceptor interceptor : requestInterceptors) {
                if (interceptor.getClass().getName().equals("org.springframework.social.oauth2.OAuth2RequestInterceptor")) {
                    Field field = ReflectionUtils.findField(interceptor.getClass(), "accessToken");
                    field.setAccessible(true);
                    ReflectionUtils.setField(field, interceptor, newToken);
                }
            }
            // create a new request, using the new token, but don't go through the refreshing factory again
            // because it may cause an endless loop if all tokens are invalid
            ClientHttpRequest newRequest = TokenRefreshingClientHttpRequestFactory.this.delegate.createRequest(delegate.getURI(), delegate.getMethod());
            return newRequest.execute();
        }
    }
    return response;
}

@Bean
@ConditionalOnMissingBean
public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) {
    return new RestTemplateCustomizer() {

        @Override
        public void customize(RestTemplate restTemplate) {
            List<ClientHttpRequestInterceptor> list = new ArrayList<>(restTemplate.getInterceptors());
            list.add(loadBalancerInterceptor);
            restTemplate.setInterceptors(list);
        }
    };
}

@PostConstruct
void customizeRestTemplate() {
    this.restTemplate.getInterceptors().add(new ClientHttpRequestInterceptor() {

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            String clientName = request.getURI().getHost();
            ZookeeperDependency dependencyForAlias = DependencyRestTemplateAutoConfiguration.this.zookeeperDependencies.getDependencyForAlias(clientName);
            HttpHeaders headers = getUpdatedHeadersIfPossible(request, dependencyForAlias);
            request.getHeaders().putAll(headers);
            return execution.execute(request, body);
        }

        private HttpHeaders getUpdatedHeadersIfPossible(HttpRequest request, ZookeeperDependency dependencyForAlias) {
            HttpHeaders httpHeaders = new HttpHeaders();
            if (dependencyForAlias != null) {
                Map<String, Collection<String>> updatedHeaders = dependencyForAlias.getUpdatedHeaders(convertHeadersFromListToCollection(request.getHeaders()));
                httpHeaders.putAll(convertHeadersFromCollectionToList(updatedHeaders));
                return httpHeaders;
            }
            httpHeaders.putAll(request.getHeaders());
            return httpHeaders;
        }

        private Map<String, Collection<String>> convertHeadersFromListToCollection(HttpHeaders headers) {
            Map<String, Collection<String>> transformedHeaders = new HashMap<>();
            for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
                transformedHeaders.put(entry.getKey(), entry.getValue());
            }
            return transformedHeaders;
        }

        private Map<String, List<String>> convertHeadersFromCollectionToList(Map<String, Collection<String>> headers) {
            Map<String, List<String>> transformedHeaders = new HashMap<>();
            for (Map.Entry<String, Collection<String>> entry : headers.entrySet()) {
                transformedHeaders.put(entry.getKey(), (List<String>) entry.getValue());
            }
            return transformedHeaders;
        }
    });
}

// subclassing hooks
/**
	 * Creates the {@link RestTemplate} used to communicate with the provider's OAuth 2 API.
	 * This implementation creates a RestTemplate with a minimal set of HTTP message converters ({@link FormHttpMessageConverter} and {@link MappingJackson2HttpMessageConverter}).
	 * May be overridden to customize how the RestTemplate is created.
	 * For example, if the provider returns data in some format other than JSON for form-encoded, you might override to register an appropriate message converter.
	 * @return a {@link RestTemplate} used to communicate with the provider's OAuth 2 API 
	 */
protected RestTemplate createRestTemplate() {
    ClientHttpRequestFactory requestFactory = ClientHttpRequestFactorySelector.getRequestFactory();
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    List<HttpMessageConverter<?>> converters = new ArrayList<HttpMessageConverter<?>>(2);
    converters.add(new FormHttpMessageConverter());
    converters.add(new FormMapHttpMessageConverter());
    converters.add(new MappingJackson2HttpMessageConverter());
    restTemplate.setMessageConverters(converters);
    restTemplate.setErrorHandler(new LoggingErrorHandler());
    if (!useParametersForClientAuthentication) {
        List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
        if (// defensively initialize list if it is null. (See SOCIAL-430)
        interceptors == null) {
            interceptors = new ArrayList<ClientHttpRequestInterceptor>();
            restTemplate.setInterceptors(interceptors);
        }
        interceptors.add(new PreemptiveBasicAuthClientHttpRequestInterceptor(clientId, clientSecret));
    }
    return restTemplate;
}

@Override
protected void configureRestTemplate(RestTemplate restTemplate) {
    List<HttpMessageConverter<?>> oldMessageConverters = restTemplate.getMessageConverters();
    for (HttpMessageConverter<?> converter : oldMessageConverters) {
        if (converter instanceof FormHttpMessageConverter) {
            // use LATIN1 character set for all form posts...?
            ((FormHttpMessageConverter) converter).setCharset(Charset.forName("LATIN1"));
        }
    }
    // replace the default OAuth1 interceptor with a custom one that uses a custom SigningSupport impl
    // doing some hokey stuff here to make the credentials available to the interceptor
    TumblrOAuth1RequestInterceptor interceptor = new TumblrOAuth1RequestInterceptor(this);
    List<ClientHttpRequestInterceptor> newInterceptors = new ArrayList<ClientHttpRequestInterceptor>();
    newInterceptors.add(interceptor);
    restTemplate.setInterceptors(newInterceptors);
}

/*
	 * Have to register custom interceptor to
	 * set  "x-li-format: "json" header as
	 * otherwise we appear to get error from xing
	 * which suggests its expecting xml rather than json.
	 * API appears to ignore Content-Type header
	 */
private void registerJsonFormatInterceptor() {
    RestTemplate restTemplate = getRestTemplate();
    if (interceptorsSupported) {
        List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
        interceptors.add(new JsonFormatInterceptor());
    } else {
        // for Spring 3.0.x where interceptors aren't supported
        ClientHttpRequestFactory originalRequestFactory = restTemplate.getRequestFactory();
        JsonFormatHeaderRequestFactory newRequestFactory = new JsonFormatHeaderRequestFactory(originalRequestFactory);
        restTemplate.setRequestFactory(newRequestFactory);
    }
}

@Bean
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setMessageConverters(Arrays.<HttpMessageConverter<?>>asList(messageConverter()));
    restTemplate.setInterceptors(new ClientHttpRequestInterceptor[] { new DebugClientHttpRequestInterceptor(getMediaType()) });
    return restTemplate;
}

@Before
public void initRestTemplate() {
    // 默认使用JDK Connection
    jdkTemplate = new RestTemplate();
    // (optional)设置20秒超时
    ((SimpleClientHttpRequestFactory) jdkTemplate.getRequestFactory()).setConnectTimeout(20000);
    ((SimpleClientHttpRequestFactory) jdkTemplate.getRequestFactory()).setReadTimeout(20000);
    // 设置使用HttpClient4.0
    httpClientRestTemplate = new RestTemplate();
    httpClientRequestFactory = new HttpComponentsClientHttpRequestFactory();
    // (optional)设置20秒超时
    httpClientRequestFactory.setConnectTimeout(20000);
    httpClientRestTemplate.setRequestFactory(httpClientRequestFactory);
    // 设置处�HttpBasic Header的Interceptor
    ClientHttpRequestInterceptor interceptor = new HttpBasicInterceptor("admin", "admin");
    httpClientRestTemplate.setInterceptors(Lists.newArrayList(interceptor));
}

@Test
@OAuth2ContextConfiguration(resource = AutoApproveImplicit.class, initialize = false)
public void testPostForAutomaticApprovalToken() throws Exception {
    final ImplicitAccessTokenProvider implicitProvider = new ImplicitAccessTokenProvider();
    implicitProvider.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(new ClientHttpRequestInterceptor() {

        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            ClientHttpResponse result = execution.execute(request, body);
            latestHeaders = result.getHeaders();
            return result;
        }
    }));
    context.setAccessTokenProvider(implicitProvider);
    context.getAccessTokenRequest().setCookie(cookie);
    assertNotNull(context.getAccessToken());
    assertTrue("Wrong location header: " + latestHeaders.getLocation().getFragment(), latestHeaders.getLocation().getFragment().contains("scope=read write trust"));
}

@Test
public void testInterceptor() throws Exception {
    final String url = "http://www.test.com/lrs?param1=val1¶m2=val2";
    final String data = "test";
    final String id = "test";
    final String realm = "realm";
    final String consumerKey = "consumerKey";
    final String secretKey = "secretKey";
    PropertyResolver resolver = mock(PropertyResolver.class);
    when(resolver.getProperty(eq("org.jasig.rest.interceptor.oauth." + id + ".realm"))).thenReturn(realm);
    when(resolver.getProperty(eq("org.jasig.rest.interceptor.oauth." + id + ".consumerKey"))).thenReturn(consumerKey);
    when(resolver.getProperty(eq("org.jasig.rest.interceptor.oauth." + id + ".secretKey"))).thenReturn(secretKey);
    // holder for the headers...
    HttpHeaders headers = new HttpHeaders();
    // Mock guts of RestTemplate so no need to actually hit the web...
    ClientHttpResponse resp = mock(ClientHttpResponse.class);
    when(resp.getStatusCode()).thenReturn(HttpStatus.ACCEPTED);
    when(resp.getHeaders()).thenReturn(new HttpHeaders());
    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
    ClientHttpRequest client = mock(ClientHttpRequest.class);
    when(client.getHeaders()).thenReturn(headers);
    when(client.getBody()).thenReturn(buffer);
    when(client.execute()).thenReturn(resp);
    ClientHttpRequestFactory factory = mock(ClientHttpRequestFactory.class);
    when(factory.createRequest(any(URI.class), any(HttpMethod.class))).thenReturn(client);
    // add the new interceptor...
    ZeroLeggedOAuthInterceptor interceptor = new ZeroLeggedOAuthInterceptor();
    interceptor.setPropertyResolver(resolver);
    interceptor.setId(id);
    List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>();
    interceptors.add(interceptor);
    RestTemplate rest = new RestTemplate(factory);
    rest.setInterceptors(interceptors);
    rest.postForLocation(url, data, Collections.emptyMap());
    // make sure auth header is correctly set...
    assertThat(headers, hasKey(Headers.Authorization.name()));
    String authHeader = headers.get(Headers.Authorization.name()).get(0);
    assertThat(authHeader, containsString("OAuth realm=\"" + realm + "\""));
    assertThat(authHeader, containsString("oauth_consumer_key=\"" + consumerKey + "\""));
    // for now, only supports HMAC-SHA1.  May have to fix later...
    assertThat(authHeader, containsString("oauth_signature_method=\"HMAC-SHA1\""));
    assertThat(authHeader, containsString("oauth_version=\"1.0\""));
    assertThat(authHeader, containsString("oauth_timestamp="));
    assertThat(authHeader, containsString("oauth_nonce="));
    assertThat(authHeader, containsString("oauth_signature="));
    // oauth lib will create 2 oauth_signature params if you call sign
    // multiple times.  Make sure only get 1.
    assertThat(StringUtils.countMatches(authHeader, "oauth_signature="), is(1));
}

private void addAuthentication(RestTemplate restTemplate, String username, String password) {
    if (username == null) {
        return;
    }
    List<ClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
    if (interceptors == null) {
        interceptors = Collections.emptyList();
    }
    interceptors = new ArrayList<>(interceptors);
    Iterator<ClientHttpRequestInterceptor> iterator = interceptors.iterator();
    while (iterator.hasNext()) {
        if (iterator.next() instanceof BasicAuthorizationInterceptor) {
            iterator.remove();
        }
    }
    interceptors.add(new BasicAuthorizationInterceptor(username, password));
    restTemplate.setInterceptors(interceptors);
}

private RestTemplate getSecureRestTemplate(ConfigClientProperties client) {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    //TODO 3m5s, make configurable?
    requestFactory.setReadTimeout((60 * 1000 * 3) + 5000);
    RestTemplate template = new RestTemplate(requestFactory);
    String username = client.getUsername();
    String password = client.getPassword();
    String authorization = client.getAuthorization();
    Map<String, String> headers = new HashMap<>(client.getHeaders());
    if (password != null && authorization != null) {
        throw new IllegalStateException("You must set either 'password' or 'authorization'");
    }
    if (password != null) {
        byte[] token = Base64Utils.encode((username + ":" + password).getBytes());
        headers.put("Authorization", "Basic " + new String(token));
    } else if (authorization != null) {
        headers.put("Authorization", authorization);
    }
    if (!headers.isEmpty()) {
        template.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(new GenericRequestHeaderInterceptor(headers)));
    }
    return template;
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof RestTemplate) {
        if (this.interceptor == null) {
            this.interceptor = this.context.getBean(MetricsClientHttpRequestInterceptor.class);
        }
        RestTemplate restTemplate = (RestTemplate) bean;
        // create a new list as the old one may be unmodifiable (ie Arrays.asList())
        ArrayList<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
        interceptors.add(interceptor);
        interceptors.addAll(restTemplate.getInterceptors());
        restTemplate.setInterceptors(interceptors);
    }
    return bean;
}

private void configureRestTemplate() {
    restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
    restTemplate.setErrorHandler(errorHandler);
    final List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>(restTemplate.getInterceptors());
    interceptors.add(new UriAwareResponseInterceptor());
    interceptors.add(new HeaderRequestInterceptor(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE));
    restTemplate.setInterceptors(interceptors);
}

//private PaymillContext paymentContext;
@PostConstruct
public void init() {
    jsonMapper.enable(SerializationFeature.WRAP_ROOT_VALUE);
    template.getInterceptors().add(new ClientHttpRequestInterceptor() {

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            request.getHeaders().add("Accept", "application/json");
            request.getHeaders().add("Content-Type", "application/json");
            request.getHeaders().add("User-Agent", "");
            return execution.execute(request, body);
        }
    });
//paymentContext = new PaymillContext(secret);
}

private void setRestTemplateParams(Map<String, Object> clientParams) {
    int maxConnPerRoute = DEFAULT_MAX_CONN_PER_ROUTE;
    int maxConnTotal = DEFAULT_MAX_CONN_TOTAL;
    int connectTimeoutInMs = DEFAULT_CONNECT_TIMEOUT_IN_MS;
    if (clientParams.containsKey(DEFAULT_URI_VARIABLES.value)) {
        restTemplate.setDefaultUriVariables((Map<String, ?>) clientParams.get(DEFAULT_URI_VARIABLES.value));
    }
    if (clientParams.containsKey(ERROR_HANDLER.value)) {
        restTemplate.setErrorHandler((ResponseErrorHandler) clientParams.get(ERROR_HANDLER.value));
    }
    if (clientParams.containsKey(MESSAGE_CONVERTERS.value)) {
        restTemplate.setMessageConverters((List<HttpMessageConverter<?>>) clientParams.get(MESSAGE_CONVERTERS.value));
    }
    if (clientParams.containsKey(URI_TEMPLATE_HANDLER.value)) {
        restTemplate.setUriTemplateHandler((UriTemplateHandler) clientParams.get(URI_TEMPLATE_HANDLER.value));
    }
    if (clientParams.containsKey(INTERCEPTORS.value)) {
        restTemplate.setInterceptors((List<ClientHttpRequestInterceptor>) clientParams.get(INTERCEPTORS.value));
    }
    if (clientParams.containsKey(MAX_CONN_PER_ROUTE.value)) {
        Object value = clientParams.get(MAX_CONN_PER_ROUTE.value);
        if (value instanceof String)
            maxConnPerRoute = Integer.parseInt((String) value);
        else
            maxConnPerRoute = (int) value;
    }
    if (clientParams.containsKey(MAX_CONN_TOTAL.value)) {
        Object value = clientParams.get(MAX_CONN_TOTAL.value);
        if (value instanceof String)
            maxConnTotal = Integer.parseInt((String) value);
        else
            maxConnTotal = (int) value;
    }
    if (clientParams.containsKey(CONNECT_TIMEOUT_IN_MS.value)) {
        Object value = clientParams.get(CONNECT_TIMEOUT_IN_MS.value);
        if (value instanceof String)
            connectTimeoutInMs = Integer.parseInt((String) value);
        else
            connectTimeoutInMs = (int) value;
    }
    if (clientParams.containsKey(REQUEST_FACTORY.value)) {
        restTemplate.setRequestFactory((ClientHttpRequestFactory) clientParams.get(REQUEST_FACTORY.value));
    }
    if (!clientParams.containsKey(REQUEST_FACTORY.value) && containsAnyRequestFactoryParam(clientParams)) {
        restTemplate.setRequestFactory(getRequestFactory(maxConnPerRoute, maxConnTotal, connectTimeoutInMs));
    } else if (clientParams.containsKey(REQUEST_FACTORY.value) && containsAnyRequestFactoryParam(clientParams)) {
        throw new IllegalArgumentException("Parameters max_conn_total, max_conn_per_route and connect_timeout cannot be set if " + "request_factory parameter presents. You must configure these parameters in your request_factory entity.");
    }
}

/**
	 * @see #201, #203
	 */
@Test
public void allowsCustomizingRestTemplate() {
    CountingInterceptor interceptor = new CountingInterceptor();
    RestTemplate restTemplate = new RestTemplate();
    restTemplate.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(interceptor));
    this.traverson = new Traverson(baseUri, MediaTypes.HAL_JSON);
    this.traverson.setRestOperations(restTemplate);
    traverson.follow("movies", "movie", "actor").<String>toObject("$.name");
    assertThat(interceptor.intercepted, is(4));
}

/**
	 * 
	 * INIT AUTHENTIFICATION
	 * 
	 */
protected void initAuth() {
    // This should of course be extracted into a separate class
    ClientHttpRequestInterceptor authInterceptor = new ClientHttpRequestInterceptor() {

        @Override
        public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
            HttpHeaders headers = request.getHeaders();
            String username = "valentin";
            String key = "valentin";
            headers.set("Authorization", "ApiKey " + username + ":" + key);
            return execution.execute(request, body);
        }
    };
    RestTemplate rt = restClient.getRestTemplate();
    ClientHttpRequestInterceptor[] interceptors = { authInterceptor };
    rt.setInterceptors(interceptors);
}

@Bean
ClientHttpRequestInterceptor tracingInterceptor(HttpTracing httpTracing) {
    return TracingClientHttpRequestInterceptor.create(httpTracing);
}

/**
     * Adds an interceptor to the rest template, in order to preserve cookies over requests.
     */
private void preserveCookiesOverRequests() {
    List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>(1);
    interceptors.add(CookiePreserveHttpRequestInterceptor.getInstance());
    restTemplate.setInterceptors(interceptors);
}

/**
	 * Sets the request interceptors that this accessor should use.
	 */
public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors) {
    this.interceptors = interceptors;
}

@PostConstruct
public void init() {
    restTemplate = new RestTemplate();
    final List<ClientHttpRequestInterceptor> interceptors = new ArrayList<ClientHttpRequestInterceptor>();
    interceptors.add(new BasicAuthInterceptor(monitorUsername, monitorPassoword));
    restTemplate.setInterceptors(interceptors);
}

@Override
protected RestTemplate createRestTemplate() {
    RestTemplate template = super.createRestTemplate();
    template.setInterceptors(new ArrayList<ClientHttpRequestInterceptor>());
    return template;
}

protected void registerSlideShareInterceptor(String apiKey, String sharedSecret) {
    List<ClientHttpRequestInterceptor> interceptors = this.restTemplate.getInterceptors();
    interceptors.add(new SlideShareApiValidationParameterRequestInterceptor(apiKey, sharedSecret));
    this.restTemplate.setInterceptors(interceptors);
}

protected List<ClientHttpRequestInterceptor> getInterceptors() {
    return Collections.emptyList();
}