HttpHelper.java

package com.yanzuoguang.util.helper;


import com.yanzuoguang.util.exception.HttpCodeException;
import com.yanzuoguang.util.thread.ProcessData;
import com.yanzuoguang.util.thread.RunProcess;
import com.yanzuoguang.util.vo.MapRow;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.util.Map;

/**
 * HTTP请求工具类
 *
 * @author 颜佐光
 */
public class HttpHelper {

    /**
     * 链接超时
     */
    public static int HTTP_CONNECT_TIMEOUT = 3 * 1000;
    /**
     * 读取超时
     */
    public static int HTTP_READ_TIMEOUT = 12 * 1000;
    /**
     * 字符编码
     */
    public static final String CHARSET_DEFAULT = "UTF-8";

    /**
     * 获取请求参数
     *
     * @param obj 对象
     * @return
     */
    public static String getUrlParameter(Object obj) {
        return getUrlParameter(obj, "UTF-8");
    }

    /**
     * 获取请求参数
     *
     * @param obj 对象
     * @return 请求参数字符串
     */
    public static String getUrlParameter(Object obj, String charset) {
        MapRow to = JsonHelper.to(obj, MapRow.class);
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, Object> kvp : to.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            sb.append(UrlHelper.encoding(kvp.getKey(), charset));
            sb.append("=");
            sb.append(UrlHelper.encoding(StringHelper.toString(kvp.getValue()), charset));
        }
        return sb.toString();
    }

    /**
     * 获取连接
     *
     * @param url 请求地址
     * @return 链接
     * @throws IOException 抛出的异常信息
     */
    public static HttpURLConnection getConn(String url) throws IOException {
        return getConn(url, null, false);
    }

    /**
     * 获取连接
     *
     * @param url    请求地址
     * @param header 请求头
     * @return 链接
     * @throws IOException 抛出的异常信息
     */
    public static HttpURLConnection getConn(String url, Map<String, String> header) throws IOException {
        return getConn(url, header, false);
    }

    /**
     * 获取连接
     *
     * @param url               请求地址
     * @param isApplicationJson 是否请求json
     * @return 链接
     * @throws IOException 抛出的异常信息
     */
    public static HttpURLConnection getConn(String url, boolean isApplicationJson) throws IOException {
        return getConn(url, null, isApplicationJson);
    }

    /**
     * 获取连接
     *
     * @param url               请求地址
     * @param header            请求头
     * @param isApplicationJson 是否请求json
     * @return 链接
     * @throws IOException 抛出的异常信息
     */
    public static HttpURLConnection getConn(String url, Map<String, String> header, boolean isApplicationJson) throws IOException {
        // 创建URL对象
        java.net.URL connURL = new java.net.URL(url);
        // 打开URL连接
        java.net.HttpURLConnection httpConn = (java.net.HttpURLConnection) connURL.openConnection();
        // 设置通用属性
        httpConn.setRequestProperty("Accept", "*/*");
        httpConn.setRequestProperty("Connection", "Keep-Alive");
        httpConn.setRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1)");
        if (isApplicationJson) {
            httpConn.setRequestProperty("Content-Type", "application/json");
        }
        // 处理自定义头
        if (header != null) {
            for (Map.Entry<String, String> item : header.entrySet()) {
                httpConn.setRequestProperty(item.getKey(), item.getValue());
            }
        }
        // 设置POST方式
        httpConn.setDoInput(true);
        httpConn.setDoOutput(true);
        httpConn.setConnectTimeout(HTTP_CONNECT_TIMEOUT);
        httpConn.setReadTimeout(HTTP_READ_TIMEOUT);
        return httpConn;
    }

    /**
     * 发送POST请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param url        目的地址
     * @param jsonString 请求参数，json字符串。
     * @return 远程响应结果
     */
    public static String post(String url, String jsonString) {
        try {
            // 打开URL连接
            java.net.HttpURLConnection httpConn = getConn(url);
            return post(httpConn, jsonString, CHARSET_DEFAULT);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 发送POST请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param url 目的地址
     * @return 远程响应结果
     */
    public static String get(String url) {
        return get(url, "UTF-8");
    }

    /**
     * 发送POST请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param url 目的地址
     * @return 远程响应结果
     */
    public static String get(String url, String charset) {
        try {
            // 打开URL连接
            java.net.HttpURLConnection httpConn = getConn(url);
            httpConn.setRequestMethod("GET");
            return get(httpConn, charset);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 发送POST请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param url        目的地址
     * @param jsonString 请求参数，json字符串。
     * @return 远程响应结果
     */
    public static String postApplicationJSON(String url, String jsonString) {
        try {
            // 打开URL连接
            java.net.HttpURLConnection httpConn = getConn(url, true);
            return post(httpConn, jsonString, "UTF-8");
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
    }

    /**
     * 发送POST请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param httpConn   链接信息
     * @param jsonString 请求参数，json字符串。
     * @return 远程响应结果
     */
    public static String post(HttpURLConnection httpConn, String jsonString) throws IOException {
        return post(httpConn, jsonString, CHARSET_DEFAULT);
    }

    /**
     * 发送POST请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param httpConn   链接信息
     * @param jsonString 请求参数，json字符串。
     * @param charset    输出编码
     * @return 远程响应结果
     */
    public static String post(HttpURLConnection httpConn, String jsonString, String charset) throws IOException {
        // 返回的结果
        StringBuilder result = new StringBuilder();
        // 读取响应输入流
        BufferedReader in = null;
        PrintWriter out = null;
        // 处理请求参数
        String params = "";
        try {
            params = jsonString;
            // 获取HttpURLConnection对象对应的输出流
            out = new PrintWriter(httpConn.getOutputStream());
            // 发送请求参数
            out.write(params);
            // flush输出流的缓冲
            out.flush();

            int returnCode = httpConn.getResponseCode();
            if (returnCode == HttpURLConnection.HTTP_OK) {
                in = readStream(httpConn.getInputStream(), result, charset);
            } else {
                throw new HttpCodeException(StringHelper.toString(returnCode), httpConn.getResponseMessage());
            }
        } catch (HttpCodeException ex) {
            throw ex;
        } catch (Exception ex) {
            in = readStream(httpConn.getErrorStream(), result, charset);
            throw new HttpCodeException(StringHelper.toString(httpConn.getResponseCode()), ex.getMessage(), result.toString(), ex);
        } finally {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                in.close();
            }
        }
        return result.toString();
    }

    /**
     * 发送GET请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param httpConn 链接信息
     * @return 远程响应结果
     */
    public static String get(HttpURLConnection httpConn) throws IOException {
        return get(httpConn, CHARSET_DEFAULT);
    }

    /**
     * 发送GET请求，当请求失败时，抛出异常或返回空字符串
     *
     * @param httpConn 链接信息
     * @return 远程响应结果
     */
    public static String get(HttpURLConnection httpConn, String charset) throws IOException {
        // 返回的结果
        StringBuilder result = new StringBuilder();
        // 读取响应输入流
        BufferedReader in = null;
        try {
            // 获取HttpURLConnection对象对应的输出流
            in = readStream(httpConn.getInputStream(), result, charset);
        } catch (Exception ex) {
            in = readStream(httpConn.getErrorStream(), result, charset);
            throw new HttpCodeException(StringHelper.toString(httpConn.getResponseCode()), ex.getMessage(), result.toString(), ex);
        } finally {
            if (in != null) {
                in.close();
            }
        }
        return result.toString();
    }

    /**
     * 读取数据流
     *
     * @param stream  流
     * @param result  结果字符串
     * @param charset 编码方式
     * @return 读取的缓存流
     * @throws IOException IO异常
     */
    private static BufferedReader readStream(InputStream stream, StringBuilder result, String charset) throws IOException {
        if (stream == null) {
            return null;
        }
        // 定义BufferedReader输入流来读取URL的响应，设置编码方式
        BufferedReader in = new BufferedReader(new InputStreamReader(stream, charset));
        String line;
        // 读取返回的内容
        while ((line = in.readLine()) != null) {
            result.append(line);
        }
        return in;
    }

    /**
     * 下载文件
     *
     * @param serverFileName 下载的服务器文件路径
     * @param localFileName  保存的文件路径
     * @throws IOException
     */
    public static void downToLocal(String serverFileName, String localFileName) throws IOException {
        downToLocal(serverFileName, localFileName, null);
    }

    /**
     * 下载文件
     *
     * @param serverFileName 下载的服务器文件路径
     * @param localFileName  保存的文件路径
     * @param runProcess     进度处理
     * @throws IOException
     */
    public static void downToLocal(String serverFileName, String localFileName, RunProcess runProcess) throws IOException {
        int byteRead;
        URL url = new URL(serverFileName);
        URLConnection conn = url.openConnection();
        conn.setConnectTimeout(HTTP_CONNECT_TIMEOUT);
        conn.setReadTimeout(HTTP_READ_TIMEOUT);
        InputStream inStream = conn.getInputStream();
        try {
            ProcessData data = new ProcessData(serverFileName, conn.getContentLengthLong());
            FileOutputStream outputStream = new FileOutputStream(localFileName);
            try {
                byte[] buffer = new byte[1204];
                while ((byteRead = inStream.read(buffer)) != -1) {
                    data.processAdd(runProcess, byteRead);
                    outputStream.write(buffer, 0, byteRead);
                }
            } finally {
                outputStream.close();
            }
        } finally {
            inStream.close();
        }
    }


}