SpringBasedHttpClient.java

Go to the documentation of this file.

package com.griddynamics.jagger.invoker.v2;

import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.http.HttpMethod;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriTemplateHandler;

import java.net.URI;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


import static com.griddynamics.jagger.invoker.v2.SpringBasedHttpClient.JSpringBasedHttpClientParameters.DEFAULT_URI_VARIABLES;
import static com.griddynamics.jagger.invoker.v2.SpringBasedHttpClient.JSpringBasedHttpClientParameters.ERROR_HANDLER;
import static com.griddynamics.jagger.invoker.v2.SpringBasedHttpClient.JSpringBasedHttpClientParameters.INTERCEPTORS;
import static com.griddynamics.jagger.invoker.v2.SpringBasedHttpClient.JSpringBasedHttpClientParameters.MESSAGE_CONVERTERS;
import static com.griddynamics.jagger.invoker.v2.SpringBasedHttpClient.JSpringBasedHttpClientParameters.REQUEST_FACTORY;
import static com.griddynamics.jagger.invoker.v2.SpringBasedHttpClient.JSpringBasedHttpClientParameters.URI_TEMPLATE_HANDLER;
import static java.lang.String.format;

@SuppressWarnings({"unused", "unchecked"})
public class SpringBasedHttpClient implements JHttpClient {

    public enum JSpringBasedHttpClientParameters {
        DEFAULT_URI_VARIABLES("defaultUriVariables"),
        ERROR_HANDLER("errorHandler"),
        MESSAGE_CONVERTERS("messageConverters"),
        URI_TEMPLATE_HANDLER("uriTemplateHandler"),
        INTERCEPTORS("interceptors"),
        REQUEST_FACTORY("requestFactory");

        private String value;

        JSpringBasedHttpClientParameters(String value) {
            this.value = value;
        }

        public String getValue() {
            return value;
        }
    }

    private Map<String, Object> clientParams;

    private RestTemplate restTemplate;

    public SpringBasedHttpClient() {
        clientParams = new HashMap<>();
        restTemplate = new RestTemplate();
        restTemplate.setRequestFactory(getSslAllTrustRequestFactory());
    }

    public SpringBasedHttpClient(Map<String, Object> clientParams) {
        this();
        this.clientParams.putAll(clientParams);
        setRestTemplateParams(this.clientParams);
    }

    @Override
    public JHttpResponse execute(JHttpEndpoint endpoint, JHttpQuery query) {
        if (query == null)
            return execute(endpoint);

        URI endpointURI = endpoint.getURI(query.getPath(), query.getQueryParams());
        RequestEntity requestEntity = mapToRequestEntity(query, endpointURI);
        ResponseEntity responseEntity;
        if (query.getResponseBodyType() != null) {
            responseEntity = restTemplate.exchange(endpointURI, query.getMethod(), requestEntity, query.getResponseBodyType());
        } else {
            responseEntity = restTemplate.exchange(endpointURI, query.getMethod(), requestEntity, byte[].class);
        }
        return mapToJHttpResponse(responseEntity);
    }

    public JHttpResponse execute(JHttpEndpoint endpoint) {
        URI endpointURI = endpoint.getURI();
        RequestEntity requestEntity = mapToRequestEntity(endpointURI);
        ResponseEntity responseEntity = restTemplate.exchange(endpointURI, HttpMethod.GET, requestEntity, byte[].class);
        return mapToJHttpResponse(responseEntity);
    }

    private void setRestTemplateParams(Map<String, Object> clientParams) {
        clientParams.forEach((parameterKey, parameterVal) -> {
            if (parameterKey.equals(DEFAULT_URI_VARIABLES.value)) {
                restTemplate.setDefaultUriVariables((Map<String, ?>) parameterVal);
            } else if (parameterKey.equals(ERROR_HANDLER.value)) {
                restTemplate.setErrorHandler((ResponseErrorHandler) parameterVal);
            } else if (parameterKey.equals(MESSAGE_CONVERTERS.value)) {
                restTemplate.setMessageConverters((List<HttpMessageConverter<?>>) parameterVal);
            } else if (parameterKey.equals(URI_TEMPLATE_HANDLER.value)) {
                restTemplate.setUriTemplateHandler((UriTemplateHandler) parameterVal);
            } else if (parameterKey.equals(INTERCEPTORS.value)) {
                restTemplate.setInterceptors((List<ClientHttpRequestInterceptor>) parameterVal);
            } else if (parameterKey.equals(REQUEST_FACTORY.value)) {
                restTemplate.setRequestFactory((ClientHttpRequestFactory) parameterVal);
            } else {
                throw new IllegalArgumentException(format("Unknown parameter name '%s'!", parameterKey));
            }
        });
    }

    private HttpComponentsClientHttpRequestFactory getSslAllTrustRequestFactory() {
        HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
        CloseableHttpClient httpClient = HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
        requestFactory.setHttpClient(httpClient);
        return requestFactory;
    }

    private <T> RequestEntity<T> mapToRequestEntity(JHttpQuery<T> query, URI endpointURI) {
        return new RequestEntity<>(query.getBody(), query.getHeaders(), query.getMethod(), endpointURI);
    }

    private <T> RequestEntity<T> mapToRequestEntity(URI endpointURI) {
        return new RequestEntity<>(HttpMethod.GET, endpointURI);
    }

    private <T> JHttpResponse<T> mapToJHttpResponse(ResponseEntity<T> responseEntity) {
        return new JHttpResponse<>(responseEntity.getStatusCode(), responseEntity.getBody(), responseEntity.getHeaders());
    }

    public Map<String, Object> getClientParams() {
        return clientParams;
    }

    public void setClientParams(Map<String, Object> clientParams) {
        this.clientParams = clientParams;
    }
}