七、創建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);
}

}