java Http 工具

项目开发过程中，会经常用到http抓取，整理了个工具类

package com.suger.utils.http;

import com.alibaba.fastjson.JSONObject;
import com.suger.utils.Json;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;

import javax.net.ssl.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;

/**
 * http工具
 */
@Slf4j
public class HttpUtil {
    /**
     * 默认超时时间：10分钟
     */
    private static final int DefaultTimeOut = 1000 * 60 * 10;

    private final static HostnameVerifier DO_NOT_VERIFY = (hostname, session) -> true;

    /**
     * 支持https
     */
    private static SSLSocketFactory getSSLSocketFactory() throws NoSuchAlgorithmException, KeyManagementException {
        TrustManager[] tm = {new MyTrustManager()};
        SSLContext sslContext = SSLContext.getInstance("TLS");

        sslContext.init(null, tm, new java.security.SecureRandom());
        return sslContext.getSocketFactory();
    }

    /**
     * 仅创建Http连接
     */
    public static HttpURLConnection createHttpConn(String requestUrl, String requestMethod, String requestData, String contentType, int timeoutMills) throws IOException, KeyManagementException, NoSuchAlgorithmException {
        log.info("url: " + requestUrl);

        URL url = new URL(requestUrl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        if (conn instanceof HttpsURLConnection) {
            HttpsURLConnection tmpConn = ((HttpsURLConnection) conn);
            tmpConn.setSSLSocketFactory(getSSLSocketFactory());
            tmpConn.setHostnameVerifier(DO_NOT_VERIFY);
        }

        conn.setDoOutput(true);
        conn.setDoInput(true);
        conn.setUseCaches(false);
        conn.setConnectTimeout(timeoutMills);
        conn.setReadTimeout(timeoutMills);
        conn.setRequestMethod(requestMethod.toUpperCase());

        if (!StringUtils.isEmpty(contentType)) {
            conn.addRequestProperty("Content-Type", contentType);
        }

        if (null != requestData) {
            writeRequestData(conn.getOutputStream(), requestData);
        }

        return conn;
    }

    /**
     * 响应输出流处理，发送请求，获得文本
     */
    private static StringBuffer request(HttpURLConnection conn) throws IOException {
        StringBuffer buffer = new StringBuffer();
        try (
                InputStream inputStream = conn.getResponseCode() >= 400 ? conn.getErrorStream() : conn.getInputStream();
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
        ) {
            String str;
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
        }

        return buffer;
    }

    /**
     * post写入流处理
     */
    private static void writeRequestData(OutputStream outputStream, String requestData) throws IOException {
        try (
                OutputStreamWriter outputStreamWriter =
                        new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
                BufferedWriter bufferedWriter = new BufferedWriter(outputStreamWriter)
        ) {
            bufferedWriter.write(requestData);
        }
    }

    /**
     * http[s]请求，返回JSON，若请求或转json失败，则返回null
     */
    public static Object requestOfJson(String requestUrl, String requestMethod, String requestData, String contentType) {
        HttpURLConnection conn = null;
        try {
            conn = createHttpConn(requestUrl, requestMethod, requestData, contentType, DefaultTimeOut);
            StringBuffer buffer = request(conn);

            return Json.parse(buffer.toString());
        } catch (Throwable e) {
            e.printStackTrace();
            return null;
        } finally {
            if (conn != null) {
                try {
                    conn.disconnect();
                } catch (Throwable e2) {
                    log.error("conn.disconnect:" + e2.getMessage());
                }
            }
        }
    }

    /**
     * http[s]请求，返回JSON，若请求或转json失败，返回JSONObject.put error = 1
     * conn.disconnect 失败时抛出异常
     */
    public static Object requestOfJsonNotNull(String requestUrl, String requestMethod, String requestData, String contentType, int timeout) {
        HttpURLConnection conn = null;
        StringBuffer resultStr = null;
        try {
            conn = createHttpConn(requestUrl, requestMethod, requestData, contentType, timeout);
            StringBuffer buffer = request(conn);
            resultStr = buffer;

            return Json.parse(buffer.toString());
        } catch (Throwable e) {
            e.printStackTrace();
            StringBuffer finalResultStr = resultStr;
            return new JSONObject() {{
                put("error", "1");
                put("msg", e.getClass().getSimpleName() + "," + e.getMessage() + "," + "result=" + finalResultStr);
            }};
        } finally {
            if (conn != null) {
                try {
                    conn.disconnect();
                } catch (Throwable e2) {
                    log.error("conn.disconnect:" + e2.getMessage());
                }
            }
        }
    }

    /**
     * 获取响应流，失败返回null
     */
    public static InputStream requestOfInputStream(String requestUrl, String requestMethod, String contentType, int timeout) {
        try {
            HttpURLConnection conn = createHttpConn(requestUrl, requestMethod, null, contentType, timeout);
            return conn.getInputStream();
        } catch (SocketTimeoutException e) {
            log.warn("获取http流超时：" + e.getMessage() + " " + requestUrl);
        } catch (Throwable ex) {
            log.warn(ex.getMessage() + " " + requestUrl);
        }

        return null;
    }
}