callWebService

import java.io.IOException;


import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpRequest;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.web.client.RestTemplate;

@Component
@Slf4j
public class CallWebService {


    public List<HashMap> callWebService(String url, String token) {

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON);
        headers.add("Authorization", token);
        RestTemplate restTemplate = getRestTemplateInstance();
        HttpEntity entity = new HttpEntity(headers);
        ResponseEntity<List> result = restTemplate.exchange(url, HttpMethod.GET, entity, List.class);
        List<HdePluginVo> listOfHdeData = new ArrayList<>();
        List<HashMap> listOfHashMapData = result.getBody();
        if (listOfHashMapData == null) {
            return null;
        }

        return listOfHashMapData;
    }


    private RestTemplate getRestTemplateInstance() {

        RestTemplate restRequest = new RestTemplate(clientHttpRequestFactory());

            List<ClientHttpRequestInterceptor> interceptors = restRequest.getInterceptors();
        if (CollectionUtils.isEmpty(interceptors)) {
            interceptors = new ArrayList<>();
        }
        interceptors.add(new LoggingClientHttpRequestInterceptor());
        restRequest.setInterceptors(interceptors);
            return restRequest;
    }


    private static ClientHttpRequestFactory clientHttpRequestFactory() {
         TrustManager[] UNQUESTIONING_TRUST_MANAGER = new TrustManager[]{
            new X509TrustManager() {
                public java.security.cert.X509Certificate[] getAcceptedIssuers(){
                    return null;
                }
                public void checkClientTrusted( X509Certificate[] certs, String authType ){}
                public void checkServerTrusted( X509Certificate[] certs, String authType ){}
            }
         };
        try {

            SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init( null, UNQUESTIONING_TRUST_MANAGER, null );
            HttpsURLConnection.setDefaultSSLSocketFactory(
                    sslContext.getSocketFactory());
            SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(
                    sslContext,
                    SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            CloseableHttpClient httpClient = HttpClients.custom()
              .setSSLSocketFactory(csf)
              .build();
            HttpComponentsClientHttpRequestFactory requestFactory =
                    new HttpComponentsClientHttpRequestFactory();
            requestFactory.setHttpClient(httpClient);
            requestFactory.setReadTimeout(15000);
            requestFactory.setConnectTimeout(3000);
            return requestFactory;
        } catch (Exception e) {
            e.printStackTrace();
            log.error(e + "");
            return null;
        }

    }

}


@Slf4j
class LoggingClientHttpRequestInterceptor implements ClientHttpRequestInterceptor {
    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        logRequest(request, body);
        ClientHttpResponse response = execution.execute(request, body);
        return response;
    }

    protected void logRequest(HttpRequest request, byte[] body) throws IOException {
        log.trace("URI         : {}", request.getURI());
        log.trace("Method      : {}", request.getMethod());
        log.trace("Headers     : {}", request.getHeaders() );
        log.trace("Request body: {}", new String(body, "UTF-8"));
    }
}