package com.dgtly.common.utils.http;

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.text.ParseException;
import java.util.Map;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import com.alibaba.fastjson.JSONObject;
import com.dgtly.common.exception.BusinessException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpEntity;

/**
 * 通用http发送方法
 *
 * @author dgtly
 */
public class HttpUtils
{
    private static final Logger log = LoggerFactory.getLogger(HttpUtils.class);

    /**
     * 向指定 URL 发送GET方法的请求
     *
     * @param url 发送请求的 URL
     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendGet(String url, String param)
    {
        url = url+"?"+param;
        return sendGet(url);
    }

    public static String sendGet(String url)
    {
        StringBuilder result = new StringBuilder();
        BufferedReader in = null;
        try
        {
            String urlNameString = url;
            log.info("sendGet - {}", urlNameString);
            URL realUrl = new URL(urlNameString);

            URLConnection connection = realUrl.openConnection();
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            connection.setConnectTimeout(10000);
            connection.setReadTimeout(10000);
            connection.connect();
            in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            log.info("read success url- {}", realUrl);
            String line;
            while ((line = in.readLine()) != null)
            {
                result.append(line);
            }
            log.info("recv - {}", result);
        }
        catch(ConnectException e)
        {
            log.error("调用HttpUtils.sendGet ConnectException, url=" + url , e);
            throw new BusinessException("调用HttpUtils.sendGet ConnectException, url=" + url );
        }
        catch (SocketTimeoutException e)
        {
            log.error("调用HttpUtils.sendGet SocketTimeoutException, url=" + url , e);
            throw new BusinessException("调用HttpUtils.sendGet SocketTimeoutException, url=" + url );
        }
        catch (IOException e)
        {
            log.error("调用HttpUtils.sendGet IOException, url=" + url, e);
            throw new BusinessException("调用HttpUtils.sendGet IOException, url=" + url );
        }
        catch (Exception e)
        {
            log.error("调用HttpsUtil.sendGet Exception, url=" + url , e);
            throw new BusinessException("调用HttpUtils.sendGet Exception, url=" + url );
        }
        finally
        {
            try
            {
                if (in != null)
                {
                    in.close();
                }
            }
            catch (Exception ex)
            {
                log.error("调用in.close Exception, url=" + url , ex);
            }
        }
        return result.toString();
    }

    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url 发送请求的 URL
     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendPost(String url, String param)
    {
        PrintWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try
        {
            String urlNameString = url + "?" + param;
            log.info("sendPost - {}", urlNameString);
            URL realUrl = new URL(urlNameString);

            URLConnection conn = realUrl.openConnection();
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Accept-Charset", "utf-8");
            conn.setRequestProperty("contentType", "utf-8");
            conn.setDoOutput(true);
            conn.setDoInput(true);
            out = new PrintWriter(conn.getOutputStream());
            out.print(param);
            out.flush();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
            String line;
            while ((line = in.readLine()) != null)
            {
                result.append(line);
            }
            log.info("recv - {}", result);
        }
        catch (ConnectException e)
        {
            log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);

            throw new BusinessException("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param );
        }
        catch (SocketTimeoutException e)
        {
            log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param );

        }
        catch (IOException e)
        {
            log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param );
        }
        catch (Exception e)
        {
            log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost Exception, url=" + url + ",param=" + param );
        }
        finally
        {
            try
            {
                if (out != null)
                {
                    out.close();
                }
                if (in != null)
                {
                    in.close();
                }
            }
            catch (IOException ex)
            {
                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
            }
        }
        return result.toString();
    }


    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url 发送请求的 URL
     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendTmsPost(String url, String param,Long ts,String sign)
    {
        PrintWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try
        {
            String urlNameString = url + "?" + param;
            log.info("sendPost - {}", urlNameString);
            URL realUrl = new URL(urlNameString);

            URLConnection conn = realUrl.openConnection();
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Accept-Charset", "utf-8");
            conn.setRequestProperty("contentType", "utf-8");
            conn.setRequestProperty("ts", ts.toString());
            conn.setRequestProperty("sign", sign);
            conn.setDoOutput(true);
            conn.setDoInput(true);
            out = new PrintWriter(conn.getOutputStream());
            out.print(param);
            out.flush();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
            String line;
            while ((line = in.readLine()) != null)
            {
                result.append(line);
            }
            log.info("recv - {}", result);
        }
        catch (ConnectException e)
        {
            log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);

            throw new BusinessException("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param );
        }
        catch (SocketTimeoutException e)
        {
            log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param );

        }
        catch (IOException e)
        {
            log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param );
        }
        catch (Exception e)
        {
            log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost Exception, url=" + url + ",param=" + param );
        }
        finally
        {
            try
            {
                if (out != null)
                {
                    out.close();
                }
                if (in != null)
                {
                    in.close();
                }
            }
            catch (IOException ex)
            {
                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
            }
        }
        return result.toString();
    }
    /**
     * @description: 向指定 URL 发送GET方法的请求
     * @param: [url, headers, params]
     * @return: java.lang.String
     * @author: njs
     * @date: 2025/8/18 16:19
     */
    public static String get(String url, Map<String, String> headers, Map<String, Object> params) {
        StringBuilder result = new StringBuilder(1024); // 初始化容量
        try {
            // 构建带参数的URL
            StringBuilder paramBuilder = new StringBuilder();
            if (params != null && !params.isEmpty()) {
                for (Map.Entry<String, Object> entry : params.entrySet()) {
                    if(entry.getValue() != null){
                        if (paramBuilder.length() != 0) {
                            paramBuilder.append("&");
                        }
                        String key = entry.getKey();
                        String value = String.valueOf(entry.getValue());


                        try {
                            // 对键进行编码（键通常不需要预先编码）
                            String encodedKey = URLEncoder.encode(key, StandardCharsets.UTF_8.name());

                            // 检查值是否已经URL编码过
                            if (isUrlEncoded(value)) {
                                // 如果已经编码过，直接使用
                                paramBuilder.append(encodedKey).append("=").append(value);
                            } else {
                                // 如果未编码，进行编码
                                String encodedValue = URLEncoder.encode(value, StandardCharsets.UTF_8.name());
                                paramBuilder.append(encodedKey).append("=").append(encodedValue);
                            }
                        } catch (UnsupportedEncodingException e) {
                            throw new RuntimeException("UTF-8 encoding not supported", e);
                        }

                    }
                }
            }
            String urlNameString = url + "?" + paramBuilder.toString();
            log.info("sendGet - {}", urlNameString);
            URL realUrl = new URL(urlNameString);

            HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
            // 设置请求头
            if (headers != null && !headers.isEmpty()) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    connection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }

            // 默认请求头
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/5.0 (compatible; Java client)");
            connection.setConnectTimeout(10000);
            connection.setReadTimeout(10000);
            connection.connect();

            int responseCode = connection.getResponseCode();
            if (responseCode >= 200 && responseCode < 300) {
                try (BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                    log.info("read success url - {}", realUrl);
                    String line;
                    while ((line = in.readLine()) != null) {
                        result.append(line);
                    }
                    log.info("recv - {}", result);
                }
            } else {
                log.error("调用HttpUtils.sendGet失败，响应码：{}，url={}", responseCode, url);
                throw new BusinessException("调用HttpUtils.sendGet失败，响应码：" + responseCode + "，url=" + url);
            }

        } catch (ConnectException e) {
            log.error("调用HttpUtils.sendGet ConnectException, url={}", url, e);
            throw new BusinessException("调用HttpUtils.sendGet ConnectException, url=" + url);
        } catch (SocketTimeoutException e) {
            log.error("调用HttpUtils.sendGet SocketTimeoutException, url={}", url, e);
            throw new BusinessException("调用HttpUtils.sendGet SocketTimeoutException, url=" + url);
        } catch (IOException e) {
            log.error("调用HttpUtils.sendGet IOException, url={}", url, e);
            throw new BusinessException("调用HttpUtils.sendGet IOException, url=" + url);
        } catch (Exception e) {
            log.error("调用HttpUtils.sendGet Exception, url={}", url, e);
            throw new BusinessException("调用HttpUtils.sendGet Exception, url=" + url);
        }

        return result.toString();
    }

    // 简单检查是否已编码
    // 改进的URL编码检测方法
    private static boolean isUrlEncoded(String value) {
        if (value == null || value.isEmpty()) {
            return false;
        }
        // 检查是否包含URL编码特征字符
        return value.contains("%") && value.matches(".*%[0-9A-Fa-f]{2}.*");
    }



    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url 发送请求的 URL
     * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
     * @return 所代表远程资源的响应结果
     */
    public static String sendPost(String url, Object param)
    {
        PrintWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try
        {
            log.info("sendPost - {}", url);
            URL realUrl = new URL(url);

            URLConnection conn = realUrl.openConnection();
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Accept-Charset", "utf-8");
            conn.setRequestProperty("contentType", "utf-8");
            conn.setDoOutput(true);
            conn.setDoInput(true);
            out = new PrintWriter(conn.getOutputStream());
            out.print(param);
            out.flush();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
            String line;
            while ((line = in.readLine()) != null)
            {
                result.append(line);
            }
            log.info("recv - {}", result);
        }
        catch (ConnectException e)
        {
            log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param );
        }
        catch (SocketTimeoutException e)
        {
            log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param );
        }
        catch (IOException e)
        {
            log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param );
        }
        catch (Exception e)
        {
            log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendPost Exception, url=" + url + ",param=" + param );
        }
        finally
        {
            try
            {
                if (out != null)
                {
                    out.close();
                }
                if (in != null)
                {
                    in.close();
                }
            }
            catch (IOException ex)
            {
                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
            }
        }
        return result.toString();
    }

    /**
     * 向指定 URL 发送HTTPS GET方法的请求（最多重试3次）
     *
     * @param url 发送请求的 URL
     * @return 所代表远程资源的响应结果
     */
    public static String sendSSLGet(String url)
    {
        int maxRetry = 3;
        Exception lastException = null;

        for (int attempt = 1; attempt <= maxRetry; attempt++)
        {
            StringBuilder result = new StringBuilder();
            BufferedReader in = null;
            try
            {
                log.info("sendSSLGet - {} (第{}次尝试)", url, attempt);
                SSLContext sc = SSLContext.getInstance("SSL");
                sc.init(null, new TrustManager[] { new TrustAnyTrustManager() }, new java.security.SecureRandom());
                URL realUrl = new URL(url);

                HttpsURLConnection connection = (HttpsURLConnection)realUrl.openConnection();
                connection.setRequestProperty("accept", "*/*");
                connection.setRequestProperty("connection", "Keep-Alive");
                connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");

                connection.setSSLSocketFactory(sc.getSocketFactory());
                connection.setHostnameVerifier(new TrustAnyHostnameVerifier());

                connection.connect();
                in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String line;
                while ((line = in.readLine()) != null)
                {
                    result.append(line);
                }
                log.info("sendSSLGet 成功 - url={}, 第{}次尝试", url, attempt);
                log.info("recv - {}", result);
                return result.toString();
            }
            catch (Exception e)
            {
                lastException = e;
                log.warn("sendSSLGet 第{}次尝试失败, url={}, 异常: {}", attempt, url, e.getMessage());
            }
            finally
            {
                try
                {
                    if (in != null)
                    {
                        in.close();
                    }
                }
                catch (Exception ex)
                {
                    log.error("调用in.close Exception, url=" + url, ex);
                }
            }
        }

        log.error("sendSSLGet 重试{}次后仍然失败, url={}", maxRetry, url, lastException);
        throw new BusinessException("调用HttpUtils.sendSSLGet失败，已重试" + maxRetry + "次, url=" + url);
    }


    public static String sendSSLPost(String url, String param)
    {
        StringBuilder result = new StringBuilder();
        String urlNameString = url + "?" + param;
        try
        {
            log.info("sendSSLPost - {}", urlNameString);
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, new TrustManager[] { new TrustAnyTrustManager() }, new java.security.SecureRandom());
            URL console = new URL(urlNameString);

            HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Accept-Charset", "utf-8");
            conn.setRequestProperty("contentType", "utf-8");
            conn.setDoOutput(true);
            conn.setDoInput(true);

            conn.setSSLSocketFactory(sc.getSocketFactory());
            conn.setHostnameVerifier(new TrustAnyHostnameVerifier());
            conn.connect();
            InputStream is = conn.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String ret = "";
            while ((ret = br.readLine()) != null)
            {
                if (ret != null && !ret.trim().equals(""))
                {
                    result.append(new String(ret.getBytes("ISO-8859-1"), "utf-8"));
                }
            }
            log.info("recv - {}", result);
            conn.disconnect();
            br.close();
        }
        catch (ConnectException e)
        {
            log.error("调用HttpUtils.sendSSLPost ConnectException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendSSLPost ConnectException, url=" + url + ",param=" + param );
        }
        catch (SocketTimeoutException e)
        {
            log.error("调用HttpUtils.sendSSLPost SocketTimeoutException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendSSLPost SocketTimeoutException, url=" + url + ",param=" + param );
        }
        catch (IOException e)
        {
            log.error("调用HttpUtils.sendSSLPost IOException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendSSLPost IOException, url=" + url + ",param=" + param );
        }
        catch (Exception e)
        {
            log.error("调用HttpsUtil.sendSSLPost Exception, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendSSLPost Exception, url=" + url + ",param=" + param );
        }
        return result.toString();
    }

    private static class TrustAnyTrustManager implements X509TrustManager
    {
        @Override
        public void checkClientTrusted(X509Certificate[] chain, String authType)
        {
        }

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

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

    private static class TrustAnyHostnameVerifier implements HostnameVerifier
    {
        @Override
        public boolean verify(String hostname, SSLSession session)
        {
            return true;
        }
    }

    /**
     * 向指定 URL 发送POST方法的请求
     *
     * @param url 发送请求的 URL
     * @param param 请求参数，
     * @return 所代表远程资源的响应结果
     */
    public static String sendJsonPost(String url, Object param)
    {
        String json = JSONObject.toJSONString(param);
        PrintWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try
        {
            log.info("sendPost - {}", url);
            URL realUrl = new URL(url);
            URLConnection conn = realUrl.openConnection();
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Accept-Charset", "utf-8");
            conn.setRequestProperty("contentType", "utf-8");
            conn.setUseCaches(false);//设置不要缓存
            conn.setDoOutput(true);
            conn.setDoInput(true);
            out = new PrintWriter(conn.getOutputStream());
            out.write(json);
            out.flush();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
            String line;
            while ((line = in.readLine()) != null)
            {
                result.append(line);
            }
            log.info("recv - {}", result);
        }
        catch (ConnectException e)
        {
            log.error("调用HttpUtils.sendJsonPost ConnectException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendJsonPost ConnectException, url=" + url + ",param=" + param );
        }
        catch (SocketTimeoutException e)
        {
            log.error("调用HttpUtils.sendJsonPost SocketTimeoutException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendJsonPost SocketTimeoutException, url=" + url + ",param=" + param );
        }
        catch (IOException e)
        {
            log.error("调用HttpUtils.sendJsonPost IOException, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendJsonPost IOException, url=" + url + ",param=" + param );
        }
        catch (Exception e)
        {
            log.error("调用HttpsUtil.sendJsonPost Exception, url=" + url + ",param=" + param, e);
            throw new BusinessException("调用HttpUtils.sendJsonPost Exception, url=" + url + ",param=" + param );
        }
        finally
        {
            try
            {
                if (out != null)
                {
                    out.close();
                }
                if (in != null)
                {
                    in.close();
                }
            }
            catch (IOException ex)
            {
                log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
            }
        }
        return result.toString();
    }

    /**
     * @description: 指定 URL 发送POST方法的请求（支持自定义请求头和JSON参数）
     * @param: [url, headers, param]
     * @return: java.lang.String
     * @author: njs
     * @date: 2025/9/18 15:28
     */
    public static String sendJsonPostWithHeaders(String url, Map<String, String> headers, Object param) {
        String json = JSONObject.toJSONString(param);
        PrintWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        try {
            log.info("sendJsonPostWithHeaders - url: {}, headers: {}, param: {}", url, headers, json);
            URL realUrl = new URL(url);
            URLConnection conn = realUrl.openConnection();

            // 设置默认请求头
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            conn.setRequestProperty("Accept-Charset", "utf-8");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("contentType", "utf-8");

            // 设置自定义请求头
            if (headers != null && !headers.isEmpty()) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    conn.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }

            conn.setUseCaches(false);
            conn.setDoOutput(true);
            conn.setDoInput(true);
            out = new PrintWriter(conn.getOutputStream());
            out.write(json);
            out.flush();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
            String line;
            while ((line = in.readLine()) != null) {
                result.append(line);
            }
            log.info("recv - {}", result);
        } catch (ConnectException e) {
            log.error("调用HttpUtils.sendJsonPostWithHeaders ConnectException, url=" + url + ",param=" + json, e);
            throw new BusinessException("调用HttpUtils.sendJsonPostWithHeaders ConnectException, url=" + url + ",param=" + json);
        } catch (SocketTimeoutException e) {
            log.error("调用HttpUtils.sendJsonPostWithHeaders SocketTimeoutException, url=" + url + ",param=" + json, e);
            throw new BusinessException("调用HttpUtils.sendJsonPostWithHeaders SocketTimeoutException, url=" + url + ",param=" + json);
        } catch (IOException e) {
            log.error("调用HttpUtils.sendJsonPostWithHeaders IOException, url=" + url + ",param=" + json, e);
            throw new BusinessException("调用HttpUtils.sendJsonPostWithHeaders IOException, url=" + url + ",param=" + json);
        } catch (Exception e) {
            log.error("调用HttpUtils.sendJsonPostWithHeaders Exception, url=" + url + ",param=" + json, e);
            throw new BusinessException("调用HttpUtils.sendJsonPostWithHeaders Exception, url=" + url + ",param=" + json);
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                log.error("调用in.close Exception, url=" + url + ",param=" + json, ex);
            }
        }
        return result.toString();
    }


}
