Android HttpURLConnection

发表于 2019-05-29 更新于 2020-09-18 分类于 Android 知识点 Waline：阅读次数：本文字数： 16k 阅读时长 ≈ 14 分钟

对于 HTTP，它的工作原理特别简单，就是客户端向服务器发出一条 HTTP 请求，服务器收到请求之后会返回一些数据给客户端，然后客户端再对这些数据进行解析和处理就可以了。

在过去，Android 上发送 HTTP 请求一般有两种方式：HttpURLConnection 和 HttpClient。

但在 Android 6.0 后不再支持 HttpClient，因为它的 API 数量过多，很难在不破坏兼容性的情况下对它进行升级和扩展，要使用的话需要添加 Apache 的 jar 才行。所以，还是主要关注 HttpURLConnection。

网络请求常用的参数：

url地址：请求地址
请求方式：常用的还是GET和POST
加密规则：可有可无
header：请求头
参数：需要传递的参数
文件：可能需要上传文件

HttpURLConnection：

一种多用途，轻量级的HTTP客户端。
它的API提供的比较简单，更容易使用和扩展。
继承自URLConnection（抽象类，无法直接实例化对象）
通过调用url.openConnection()方法获得对象实例
默认是带gzip压缩的

HttpURLConnection使用步骤：

创建一个URL对象，并传入目标的网络地址。

URL url = new URL("https://www.baidu.com/");

// Kotlin 写法
val url = URL("https://www.baidu.com/")

调用 URL 对象的 openConnection() 来获取 HttpURLConnection 对象实例

HttpURLConnection connection = (HttpURLConnection) url.openConnection();

// Kotlin 写法
val connection = url.openConnection() as HttpURLConnection

设置 Http 请求使用的方法：GET/POST/其他

connection.setRequestMethod("GET");

// Kotlin 写法
connection.requestMethod = "GET"

设置连接超时，读取超时的毫秒数，以及服务器希望得到的一些消息头等。

connection.setConnectTimeout(6*1000);
connection.setReadTimeout(6*1000);

//Kotlin 写法
connection.connectTimeout = 8000
connection.readTimeout = 8000

调用 getInputStream() 方法获得服务器返回的输入流，然后读取输入流。

if (connection.getResponseCode() != 200 ){
   // 读取之前先判断
   return;
}
InputStream inputStream = connection.getInputStream();

// Kotlin 写法
val input = connection.inputStream

调用 disconnect() 将 HTTP 连接关掉

connection.disconnect();

// Kotlin 写法
connection.disconnect()

示例（Java）：

/**
 * 网络封装类
 */
public class NetUtil {

    public enum Method {
        GET,
        POST
    }

    private static final String END = "\r\n";
    public static int connectionTimeOut = 30000;
    public static int readSocketTimeOut = 30000;

    /**
     * GET 请求方式
     */
    public static String get(IRequest request) {
        InputStream inputStream = null;
        HttpURLConnection httpURLConnection = null;
        try {
            // 1. 创建一个URL对象
            // buildGetUrl ，根据参数拼接 url 。
            URL url = new URL(buildGetUrl(request.getBaseUrl(), request.getParam(), request.getEncrypt()));
            // 打开链接
            //  2. 调用URL对象的openConnection()来获取HttpURLConnection对象实例
            openUrlConnection(url,httpURLConnection);
            // 通用配置
            // 3. 设置Http请求使用的方法：GET/POST/其他
            // 4. 设置连接超时，读取超时的毫秒数，以及服务器希望得到的一些消息头。
            normalSetting(httpURLConnection, Method.GET, request.getHeaders());
            if (httpURLConnection == null) {
                return null;
            }
            // 响应码
            int responseCode = httpURLConnection.getResponseCode();
            // 为200时是标志请求成功了
            // 如果返回301，或者是302，是由于链接重定向的问题造成的，
            // 可通过String location =httpURLConnection.getHeaderField("Location");获取重定向的网址进行重新请求。
            if (responseCode == HttpURLConnection.HTTP_OK) {
                // 5. 调用getInputStream()方法获得服务器返回的输入流，然后读取输入流。
                inputStream = httpURLConnection.getInputStream();
                String contentEncoding = httpURLConnection.getContentEncoding();
                InputStream stream = null;
                try {
                    stream = wrapStream(contentEncoding, inputStream);
                    String data = convertStreamToString(stream);
                    return data;
                } catch (IOException e) {
                    return "";
                } finally {
                    closeQuietly(stream);
                }

            }
            return null;
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * POST 请求方式
     */
    public static String post(IRequest request) {
        String boundary = UUID.randomUUID().toString();
        HttpURLConnection httpURLConnection = null;
        OutputStream outputStream = null;
        InputStream inputStream = null;
        URL url = null;
        try {
            url = new URL(request.getBaseUrl());
            openUrlConnection(url,httpURLConnection);
            normalSetting(httpURLConnection, Method.POST,request.getHeaders());
//            if (req.mMimeType != null) {// stats cache log request
//                String data = (String) bodyPair.get("data");
//                httpURLConnection.setRequestProperty("Content-Type", req.mMimeType.toString());
//                outputStream = httpURLConnection.getOutputStream();
//                outputStream.write(data.getBytes());
//            } else
            if (request.getParam() != null && request.getParam().size() > 0) {
//                multipart/form-data，使用表单上传文件时，必须让 form 的 enctyped 等于这个值
                httpURLConnection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
                outputStream = httpURLConnection.getOutputStream();
                addBodyParams(request.getParam(),request.getFilePair(), outputStream, boundary);
            } else {
////              Content-Type 被指定为 application/x-www-form-urlencoded
//                httpURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
//                Uri.Builder builder = new Uri.Builder();
////              提交的数据按照 key1=val1&key2=val2 的方式进行编码，并且key 和 val 都进行了 URL 转码。
//                builder.appendQueryParameter("content", message);
//                String query = builder.build().getEncodedQuery();
//                outputStream = new DataOutputStream(httpURLConnection.getOutputStream());
//                outputStream.write(query.getBytes());
            }
            outputStream.flush();
            int responseCode = httpURLConnection.getResponseCode();

            if (responseCode == HttpURLConnection.HTTP_OK) {
                inputStream = httpURLConnection.getInputStream();
                String contentEncoding = httpURLConnection.getContentEncoding();
                InputStream stream = wrapStream(contentEncoding, inputStream);
                String data = convertStreamToString(stream);
                return data;

            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    private static void openUrlConnection(URL url, HttpURLConnection httpURLConnection) throws IOException {
        String scheme = url.getProtocol();
        boolean isHttpsRequest = false;
        if ("https".equals(scheme)) {
            isHttpsRequest = true;
        }
        if (isHttpsRequest) {
            httpURLConnection = (HttpsURLConnection) (url).openConnection();
            // TODO 处理https证书 1,需要测试https请求;2如需设置证书，需验证是否会对其它https请求有影响
            //trustHosts((HttpsURLConnection) urlConnection);
        } else {
            httpURLConnection = (HttpURLConnection) (url).openConnection();
        }

    }

    /**
     *  通用配置设置
     */
    private static void normalSetting(HttpURLConnection urlConnection, Method method, Map<String, String> mHeaders) throws ProtocolException {
        // 设置连接主机超时（单位：毫秒）
        urlConnection.setConnectTimeout(connectionTimeOut);
        // 设置从主机读取数据超时（单位：毫秒）
        urlConnection.setReadTimeout(readSocketTimeOut);
        urlConnection.setRequestMethod(method.toString());
        if (method == Method.GET) {
            // Accept-Encoding是浏览器发给服务器,声明浏览器支持的编码类型
            urlConnection.setRequestProperty("Accept-Encoding", "gzip");
            if (mHeaders != null && mHeaders.size() > 0) {
                Set<String> stringKeys = mHeaders.keySet();
                for (String key : stringKeys) {
                    urlConnection.setRequestProperty(key, mHeaders.get(key));
                }
            }
        } else if (method == Method.POST) {
            // URL 连接可用于输入和/或输出。
            // 如果打算使用 URL 连接进行输出，则将 DoOutput 标志设置为 true；
            // 如果不打算使用，则设置为 false。默认值为 false。
            // setDoOutput(true);以后就可以使用 httpURLConnection.getOutputStream().write()
            urlConnection.setDoOutput(true);
            // URL 连接可用于输入和/或输出。
            // 如果打算使用 URL 连接进行输入，则将 DoInput 标志设置为 true；
            // 如果不打算使用，则设置为 false。默认值为 true。
            // setDoInput(true);以后就可以使用 httpURLConnection.getInputStream().read();
            urlConnection.setDoInput(true);
        }
    }

    /**
     * 写入数据
     */
    private static void addBodyParams(HashMap<String, Object> map, Map<String, FilePair> filePair, OutputStream outputStream, String boundary) throws IOException {
        boolean didWriteData = false;
        StringBuilder stringBuilder = new StringBuilder();
        Map<String, Object> bodyPair =map;
        Set<String> keys = bodyPair.keySet();
        for (String key : keys) {
            if (bodyPair.get(key) != null) {
                addFormField(stringBuilder, key, bodyPair.get(key).toString(), boundary);
            }
        }

        if (stringBuilder.length() > 0) {
            didWriteData = true;
            outputStream = new DataOutputStream(outputStream);
            outputStream.write(stringBuilder.toString().getBytes());
        }

        // upload files like POST files to server
        if (filePair != null && filePair.size() > 0) {
            Set<String> fileKeys = filePair.keySet();
            for (String key : fileKeys) {
                FilePair pair = filePair.get(key);
                byte[] data = pair.mBinaryData;
                if (data == null || data.length < 1) {
                    continue;
                } else {
                    didWriteData = true;
                    addFilePart(pair.mFileName, data, boundary, outputStream);
                }
            }
        }

        if (didWriteData) {
            finishWrite(outputStream, boundary);
        }
    }
   
    private static void addFormField(StringBuilder writer, final String name, final String value, String boundary) {
        writer.append("--").append(boundary).append(END)
                .append("Content-Disposition: form-data; name=\"").append(name)
                .append("\"").append(END)
                .append("Content-Type: text/plain; charset=").append("UTF-8")
                .append(END).append(END).append(value).append(END);
    }

    private static void addFilePart(final String fieldName, byte[] data, String boundary, OutputStream outputStream)
            throws IOException {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("--").append(boundary).append(END)
                .append("Content-Disposition: form-data; name=\"")
                .append("pic").append("\"; filename=\"").append(fieldName)
                .append("\"").append(END).append("Content-Type: ")
                .append("application/octet-stream").append(END)
                .append("Content-Transfer-Encoding: binary").append(END)
                .append(END);
        outputStream.write(stringBuilder.toString().getBytes());
        outputStream.write(data);
        outputStream.write(END.getBytes());
    }

    private static void finishWrite(OutputStream outputStream, String boundary) throws IOException {
        outputStream.write(END.getBytes());
        outputStream.write(("--" + boundary + "--").getBytes());
        outputStream.write(END.getBytes());
        outputStream.flush();
        outputStream.close();
    }
    
    private static InputStream wrapStream(String contentEncoding, InputStream inputStream)
            throws IOException {
        if (contentEncoding == null || "identity".equalsIgnoreCase(contentEncoding)) {
            return inputStream;
        }
        if ("gzip".equalsIgnoreCase(contentEncoding)) {
            return new GZIPInputStream(inputStream);
        }
        if ("deflate".equalsIgnoreCase(contentEncoding)) {
            return new InflaterInputStream(inputStream, new Inflater(false), 512);
        }
        throw new RuntimeException("unsupported content-encoding: " + contentEncoding);
    }

    /**
     * 根据参数拼接URL
     */
    private static String buildGetUrl(String urlPath, Map<String, Object> params, IEncrypt encrypt) {
        if (TextUtils.isEmpty(urlPath) || params == null || params.size() == 0) {
            return urlPath;
        }

        if (!urlPath.endsWith("?")) {
            urlPath += "?";
        }

        String paramsStr = buildGetParams(params);
        if (encrypt != null) {
            // 加密
            // 如果不需要加密，可将这个参数设置为空，或者直接实现，返回原字符串即可。
            paramsStr = encrypt.encrypt(urlPath, params);

        }

        StringBuilder sbUrl = new StringBuilder(urlPath);
        sbUrl.append(paramsStr);
        return sbUrl.toString();
    }

    private static String buildGetParams(Map<String, Object> params) {
        StringBuilder sb = new StringBuilder();
        Set<String> keys = params.keySet();
        for (String key : keys) {
            if (params.get(key) == null) {
                continue;
            }
            sb = sb.append(key + "=" + URLEncoder.encode(params.get(key).toString()) + "&");
        }

        String paramsStr = sb.substring(0, sb.length() - 1).toString();
        return paramsStr;
    }
    
    private static String convertStreamToString(InputStream is) {
        InputStreamReader inputStreamReader = new InputStreamReader(is);
        BufferedReader reader = new BufferedReader(inputStreamReader, 512);
        StringBuilder stringBuilder = new StringBuilder();
        try {
            String line;
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line + "\n");
            }
        } catch (IOException e) {
            return null;
        } finally {
            closeQuietly(inputStreamReader);
            closeQuietly(reader);
        }
        return stringBuilder.toString();
    }

    private static void closeQuietly(Closeable io) {
        try {
            if (io != null) {
                io.close();
            }
        } catch (IOException e) {
        }
    }
    
}

示例（Kotlin）：

class NetworkActivity : BaseActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_network)

        initView()
    }

    private fun sendRequestWithHttpUrlConnection(){
        // 开启线程发起网络请求
        thread {
            var connection:HttpURLConnection?=null
            try {
                val response = StringBuilder()
                val url = URL("https://www.baidu.com")
                connection = url.openConnection() as HttpURLConnection
                // 如果想要提交数据给服务器，主需要将 HTTP 的请求方法改成 POST，并在获取输入流之前把要提交的数据写出即可。
                // 注意，每条数据都要以键值对的形式存在，数据与数据之间用"&"符号隔开。
//                connection.requestMethod = "POST"
//                val output = DataOutputStream(connection.outputStream)
//                output.writeBytes("username=admin&password=123456")
                connection.connectTimeout = 8000
                connection.readTimeout = 8000
                val input = connection.inputStream
                // 下面对获取到的输入流进行读取
                val reader = BufferedReader(InputStreamReader(input))
                reader.use {
                    reader.forEachLine {
                        response.append(it)
                    }
                }
                showResponse(response.toString())
            }catch (e:Exception){
                e.printStackTrace()
            }finally {
                connection?.disconnect()
            }
        }
    }

    private fun showResponse(response: String) {
        // runOnUiThread() 其实就是对异步消息处理机制进行了一层封装，内部通过 Handler 实现。
        runOnUiThread{
            // 在这里进行 UI 操作，将结果显示到界面上。
            tvRequest.text = response
        }
    }

    private fun initView() {
        btnRequest.setOnClickListener{
            sendRequestWithHttpUrlConnection()
        }
    }
}

示例（Kotlin）：网络请求工具类

object HttpUtil{
    /**
    * 网络操作属于耗时任务，这就有可能导致调用此方法时主线程被阻塞，
    * 但在此方法内部并没有开启一个线程，
    * 因为，如果开启一个线程来发起 HTTP 请求，服务器响应的数据是无法进行返回的。
    * 这是由于所有的耗时操作逻辑都是在子线程里进行的，
    * 此方法会在服务器还没来得及响应时就执行结束了，当然也就无法返回响应的数据了。
    */
    fun sendHttpRequest(address: String): String{
        var connection: HttpURLConnection? = null
        try {
            val response = StringBuilder()
            val url = URL(address)
            connection = url.openConnection() as HttpURLConnection
            connection.connectTimeout = 8000
            connection.readTimeout = 8000
            val input = connection.inputStream
            val reader = BufferedReader(InputStreamReader(input))
            reader.use {
                reader.forEachLine {
                    response.append(it)
                }
            }
            return response.toString()
        }catch (e:Exception){
            e.printStackTrace()
            return e.message.toString()
        }finally {
            connection?.disconnect()
        }
    }
}

解决的办法就是：使用编程语言的回调机制。

interface HttpCallbackListener {

    /**
     * 服务器成功响应请求时的回调
     * @param response 服务器返回的数据
     */
    fun onFinish(response:String)

    /**
     * 网络操作出现错误时调用
     * @param e 错误的详细信息
     */
    fun onError(e:Exception)

}

object HttpUtil{

    fun sendHttpRequest(address: String,listener:HttpCallbackListener){
        // 子线程中是无法通过 return 语句返回数据的
        thread {
            var connection: HttpURLConnection? = null
            try {
                val response = StringBuilder()
                val url = URL(address)
                connection = url.openConnection() as HttpURLConnection
                connection.connectTimeout = 8000
                connection.readTimeout = 8000
                val input = connection.inputStream
                val reader = BufferedReader(InputStreamReader(input))
                reader.use {
                    reader.forEachLine {
                        response.append(it)
                    }
                }
                // 回调 onFinish() 方法
                listener.onFinish(response.toString())
            }catch (e:Exception){
                e.printStackTrace()
                // 回调 onError() 方法
                listener.onError(e)
            }finally {
                connection?.disconnect()
            }
        }
    }
}

btnRequest.setOnClickListener{
    val address = "https://jianghouren.com/"
   // 回调接口在子线程中运行，不可以执行 UI 操作，除非借助 runOnUiThread()。 
    HttpUtil.sendHttpRequest(address, object : HttpCallbackListener{
        override fun onFinish(response: String) {
            // 得到服务器返回的具体内容
            showResponse(response)
        }

        override fun onError(e: Exception) {
            // 在这里对异常情况进行处理
        }
    })
}

备注

参考资料；
HttpURLConnection详解

第一行代码(第3版)

传送门：GitHub