RestClient

一个http客户端，使用OkHttp实现

依赖：

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
    <version>4.4</version>
</dependency>

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>3.14.9</version>
</dependency>

实现：

import java.security.cert.X509Certificate;
import java.util.Map;
import java.util.concurrent.TimeUnit;

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

import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.StringUtils;

import okhttp3.*;

@SuppressWarnings("ALL")
public class RestClient {

    public static final MediaType JSON_TYPE = MediaType.get("application/json; charset=utf-8");
    public static final String HTTPS = "https";
    public static final String HTTP = "http://";

    public static String post(String url, String queryBody, Map<String, String> headerMap) {
        return doExecute(RequestType.POST, url, queryBody, headerMap);
    }

    public static byte[] postFile(String url, String queryBody, Map<String, String> headerMap) {
        OkHttpClient httpsClient = getHttpClient(url);
        Request.Builder requestBuilder = getRequestBuilder(url, headerMap);
        requestBuilder.post(RequestBody.create(JSON_TYPE, queryBody == null ? "" : queryBody));
        return executeAndGetBytes(httpsClient, requestBuilder);
    }

    public static String delete(String url, Map<String, String> headerMap) {
        return doExecute(RequestType.DELETE, url, null, headerMap);
    }

    public static String put(String url, String queryBody, Map<String, String> headerMap) {
        return doExecute(RequestType.PUT, url, queryBody, headerMap);
    }

    public static String get(String url, Map<String, String> paramMap, Map<String, String> headerMap) {
        OkHttpClient okHttpClient = getHttpClient(url);
        Request.Builder requestBuilder = new Request.Builder();
        buildHeader(requestBuilder, headerMap);
        buildParam(requestBuilder, url, paramMap);
        return executeAndGetResult(okHttpClient, requestBuilder);
    }

    private static String doExecute(RequestType requestType, String url, String queryBody,
        Map<String, String> headerMap) {
        OkHttpClient okHttpClient = getHttpClient(url);
        Request.Builder requestBuilder = getRequestBuilder(url, headerMap);
        RequestBody requestBody = RequestBody.create(JSON_TYPE, queryBody == null ? "" : queryBody);
        switch (requestType) {
            case POST:
                requestBuilder.post(requestBody);
                break;
            case PUT:
                requestBuilder.put(requestBody);
                break;
            case DELETE:
                requestBuilder.delete(requestBody);
                break;
            case GET:
                break;
            default:
                return null;
        }
        return executeAndGetResult(okHttpClient, requestBuilder);
    }

    private static Request.Builder getRequestBuilder(String url, Map<String, String> headerMap) {
        Request.Builder requestBuilder = new Request.Builder();
        requestBuilder.url(url);
        buildHeader(requestBuilder, headerMap);
        return requestBuilder;
    }

    private static String executeAndGetResult(OkHttpClient okHttpClient, Request.Builder requestBuilder) {
        Request request = requestBuilder.build();
        try (Response response = okHttpClient.newCall(request).execute(); ResponseBody responseBody = response.body()) {
            if (responseBody != null) {
                return responseBody.string();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private static byte[] executeAndGetBytes(OkHttpClient okHttpClient, Request.Builder requestBuilder) {
        Request request = requestBuilder.build();
        try (Response response = okHttpClient.newCall(request).execute(); ResponseBody responseBody = response.body()) {
            if (responseBody != null) {
                return responseBody.bytes();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private static OkHttpClient getHttpClient(String url) {
        if (StringUtils.isBlank(url)) {
            return null;
        }
        OkHttpClient.Builder clientBuilder = new OkHttpClient().newBuilder();
        buildTimeOut(clientBuilder);
        if (StringUtils.startsWith(url, HTTP)) {
            return clientBuilder.build();
        }

        try {
            TrustManager[] trustManagers = buildTrustManagers();
            SSLContext sslContext = SSLContext.getInstance("SSL");
            sslContext.init(null, trustManagers, new java.security.SecureRandom());
            SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

            clientBuilder.sslSocketFactory(sslSocketFactory, (X509TrustManager)trustManagers[0]);
            clientBuilder.hostnameVerifier((hostname, session) -> true);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return clientBuilder.build();
    }

    private static void buildTimeOut(OkHttpClient.Builder clientBuilder) {
        clientBuilder.connectTimeout(600L, TimeUnit.SECONDS);
        clientBuilder.readTimeout(600L, TimeUnit.SECONDS);
    }

    private static void buildParam(Request.Builder requestBuilder, String url, Map<String, String> paramMap) {
        if (MapUtils.isEmpty(paramMap)) {
            requestBuilder.url(url);
            return;
        }
        int size = paramMap.size();
        int count = 1;
        StringBuilder paramBuilder = new StringBuilder(url);
        paramBuilder.append("?");
        for (Map.Entry<String, String> entry : paramMap.entrySet()) {
            paramBuilder.append(entry.getKey()).append("=").append(entry.getValue());
            if (count < size) {
                paramBuilder.append("&");
            }
            count++;
        }
        requestBuilder.url(paramBuilder.toString());
    }

    private static void buildHeader(Request.Builder builder, Map<String, String> headerMap) {
        if (MapUtils.isEmpty(headerMap)) {
            return;
        }
        headerMap.forEach(builder::addHeader);
    }

    private static TrustManager[] buildTrustManagers() {
        return new TrustManager[] {new X509TrustManager() {
            @Override
            public void checkClientTrusted(X509Certificate[] chain, String authType) {

            }

            @Override
            public void checkServerTrusted(X509Certificate[] chain, String authType) {

            }

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

    enum RequestType {
        POST("post"), DELETE("delete"), PUT("put"), GET("get");

        String name;

        RequestType(String name) {
            this.name = name;
        }
    }

}