七、创建UcRESTTemplate请求管理器

一、创建UcRESTTemplate管理器封装

import com.alibaba.fastjson.JSON;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.HttpStatusCodeException;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.cert.X509Certificate;
import java.util.Map;

public class UcRESTTemplate {

    private static final int default_connectionTimeout = 30 * 1000;
    private static final int default_socketTimeout = 30 * 1000;
    private int connectionTimeout = 30 * 1000;
    private int socketTimeout = 30 * 1000;
    private int minsTimeoutTime = 1000;

    private static final Logger logger = LoggerFactory.getLogger(UcRESTTemplate.class);

    public UcRESTTemplate() {
        this.connectionTimeout = UcRESTTemplate.default_connectionTimeout;
        this.socketTimeout = UcRESTTemplate.default_socketTimeout;
    }

    public UcRESTTemplate(int connectionTimeout, int socketTimeout) {
        this.connectionTimeout = connectionTimeout < this.minsTimeoutTime ? UcRESTTemplate.default_connectionTimeout
                : connectionTimeout;
        this.socketTimeout = socketTimeout < this.minsTimeoutTime ? UcRESTTemplate.default_socketTimeout
                : socketTimeout;
    }

    private CloseableHttpClient buildHttpClient() {
        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(this.connectionTimeout)
        .setSocketTimeout(this.socketTimeout).build();
        HttpClientBuilder cb = HttpClients
                .custom()
                .disableAutomaticRetries()
                .setSSLHostnameVerifier(new NoopHostnameVerifier())
                .setDefaultRequestConfig(requestConfig);

        try {
            // set ssl context
            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(null, new TrustManager[] { new X509TrustManager() {

                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return new X509Certificate[0];
                }

                @Override
                public void checkServerTrusted(X509Certificate[] arg0, String arg1) {
                }

                @Override
                public void checkClientTrusted(X509Certificate[] arg0, String arg1) {
                }
            } }, null);

            cb.setSslcontext(ctx);
        } catch (GeneralSecurityException ex) {
            throw new RuntimeException(ex);
        }
        return cb.build();
    }

    private static RestTemplate buildTemplate(CloseableHttpClient client) {
        ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(
                client);
        return new RestTemplate(requestFactory);
    }

    /**
     * @param request
     * @param url
     * @param params maybe null
     * @return
     */
    public ResponseEntity<String> getEntity(String url, HttpEntity<?> request, Map<String, ?> params) {
        if (null == params){
            return getEntity(url, request, String.class);
        }else {
            try {
                try (CloseableHttpClient client = this.buildHttpClient();) {
                    return UcRESTTemplate.buildTemplate(client).exchange(url, HttpMethod.GET, request, String.class, params);
                } catch (HttpStatusCodeException ex) {
                    this.handleServerException(url, ex);
                    return null;
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

    
    public ResponseEntity<String> getEntity(String url, HttpEntity<?> request) {
        return getEntity(url, request, String.class);
    }
    
    public <T> ResponseEntity<T> getEntity(String url, HttpEntity<?> request, Class<T> responseType) {
        try {
            try (CloseableHttpClient client = this.buildHttpClient();) {
                return UcRESTTemplate.buildTemplate(client).exchange(url, HttpMethod.GET, request, responseType);
            } catch (HttpStatusCodeException ex) {
                this.handleServerException(url, ex);
                return null;
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }


    public ResponseEntity<String> postEntity(String url, HttpEntity<?> request) {
        try {
            try (CloseableHttpClient client = this.buildHttpClient();) {
                return UcRESTTemplate.buildTemplate(client).postForEntity(url, request,
                        String.class);
            } catch (HttpStatusCodeException ex) {
                return this.handleServerException(url, ex);
            }
        } catch (IOException e) {
            UcRESTTemplate.logger.error("exception is " + e);
            throw new RuntimeException(e);
        }
    }

    protected ResponseEntity<String> handleServerException(String url,
            HttpStatusCodeException ex) {
        HttpStatus statusCode = ex.getStatusCode();
        String respString = ex.getResponseBodyAsString();
        logger.error("url:" + url+",statusCode:"+statusCode, ex);
        switch (statusCode) {
        case CONFLICT:
            return new ResponseEntity<>(respString, statusCode);
        case NOT_FOUND:
            throw new RuntimeException("URL not found: " + url);
        default:
            logger.error("Response string:\n" + respString);
            @SuppressWarnings("unchecked")
            Map<String, Object> map = (Map<String, Object>) JSON.parse(respString);
            if (map.containsKey("stackTrace")) {
                Exception ori = JSON.parseObject(respString, Exception.class);
                throw new RuntimeException("Exception thrown from server", ori);
            } else {
                throw new RuntimeException(respString);
            }
        }
    }

    /**
     * 发送get请求，获取返回结果
     * 
     * @param <T>
     * @param url
     * @param cls
     * @return
     */
    public <T> T sendHttpsGet(String url, Class<T> cls) {
        CloseableHttpClient client = this.buildHttpClient();
        return buildTemplate(client).getForObject(url, cls);
    }

}