自從Android5.x時代google將Apache拋棄之後,HttpURLConnection變成了Android系統預設的請求方式.兩者的區別在於：
1、標準Java介面(java.net) —-HttpURLConnection，可以實現簡單的基於URL請求、響應功能；
2、Apache介面(org.appache.http)—-HttpClient，使用起來更方面更強大。一般來說，用這種介面。不過本文還是把第一種介面過一下。
任何一種介面，無外乎四個基本功能:訪問網頁、下載圖片或檔案、上傳檔案，訪問介面獲取資料，根據URL請求的類別: 分為二類,GET與POST請求。
二者的區別在於：
a:) get請求可以獲取靜態頁面，也可以把引數放在URL字串後面，傳遞給servlet，
據此，寫了一個小小的工具類

/**
 * Created by xuenan on 2016/9/22 0022.
 */

import android.util.Log;

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import
 
 java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;

/**
 * 建立的HttpURLConection的工具類
 */
public class HttpUtil2 {
    //把Cookie定義為靜態變數，第一次獲取之後儲存起來，以後每一次請求都設定給請求頭即可
    public static String COOKIE = "";
    //GET請求實現
    public static String RequetstGet(String baseUrl, HashMap<String, String> paramsMap) {
        try
 
 {
            StringBuilder tempParams = new StringBuilder();
            int pos = 0;
            for (String key : paramsMap.keySet()) {
                if (pos > 0) {
                    tempParams.append("&");
                }
                tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
                pos++;
            }
            String requestUrl = baseUrl + tempParams.toString();
            // 新建一個URL物件
            URL url = new URL(requestUrl);
            // 開啟一個HttpURLConnection連線
            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
            // 設定連線主機超時時間
            urlConn.setConnectTimeout(5 * 1000);
            //設定從主機讀取資料超時
            urlConn.setReadTimeout(5 * 1000);
            // 設定是否使用快取  預設是true
            urlConn.setUseCaches(true);
            // 設定為Post請求
            urlConn.setRequestMethod("GET");
            //urlConn設定請求頭資訊
            //設定請求中的媒體型別資訊。
            urlConn.setRequestProperty("Content-Type", "application/json");
            //設定客戶端與服務連線型別
            urlConn.addRequestProperty("Connection", "Keep-Alive");
            // 開始連線
            urlConn.connect();
            // 判斷請求是否成功
            if (urlConn.getResponseCode() == 200) {
                // 獲取返回的資料 可以選擇流 位元組 字串三種
                String result = streamToString(urlConn.getInputStream());
                return result;
            } else {
                Log.e("TAG", "Get方式請求失敗");
            }
            // 關閉連線
            urlConn.disconnect();
        } catch (Exception e) {
            Log.e("TAG", e.toString());
        }
        return null;
    }

    //POST請求實現
    private String requestPost(String baseUrl, HashMap<String, String> paramsMap) {
        try {
            //合成引數
            StringBuilder tempParams = new StringBuilder();
            int pos = 0;
            for (String key : paramsMap.keySet()) {
                if (pos > 0) {
                    tempParams.append("&");
                }
                tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
                pos++;
            }
            String params = tempParams.toString();
            // 請求的引數轉換為byte陣列
            byte[] postData = params.getBytes();
            // 新建一個URL物件
            URL url = new URL(baseUrl);
            // 開啟一個HttpURLConnection連線
            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
            // 設定連線超時時間
            urlConn.setConnectTimeout(5 * 1000);
            //設定從主機讀取資料超時
            urlConn.setReadTimeout(5 * 1000);
            // Post請求必須設定允許輸出 預設false
            urlConn.setDoOutput(true);
            //設定請求允許輸入 預設是true
            urlConn.setDoInput(true);
            // Post請求不能使用快取
            urlConn.setUseCaches(false);
            // 設定為Post請求
            urlConn.setRequestMethod("POST");
            //將獲取的Cookie存入請求頭中發給伺服器,如果伺服器需要Cookie請求頭的話
            //urlConn.setRequestProperty("Cookie", COOKIE);
            //設定本次連線是否自動處理重定向
            urlConn.setInstanceFollowRedirects(true);
            //獲取返回的cookie的map集合
            //Map<String,List<String>> cookieMap = urlConn.getHeaderFields();
            //獲取後臺返回的特定的cookie 這個cookie也可以由後臺作為返回值返給前臺，然後前臺儲存呼叫
            //獲取Cookie：從返回的訊息頭裡的Set-Cookie的相應的值
            //COOKIE = urlConn.getHeaderField("Set-Cookie");
            // 配置請求Content-Type
            urlConn.setRequestProperty("Content-Type", "application/json");
            // 開始連線
            urlConn.connect();
            // 傳送請求引數
            DataOutputStream dos = new DataOutputStream(urlConn.getOutputStream());
            dos.write(postData);
            dos.flush();
            dos.close();
            // 判斷請求是否成功
            if (urlConn.getResponseCode() == 200) {
                // 獲取返回的資料
                String result = streamToString(urlConn.getInputStream());
                return result;
            } else {
                Log.e("TAG", "Post方式請求失敗");
            }
            // 關閉連線
            urlConn.disconnect();
        } catch (Exception e) {
            Log.e("TAG", e.toString());
        }
        return null;
    }

    //處理網路流：將輸入流轉換成字串

    /**
     * 將輸入流轉換成字串
     *
     * @param is 從網路獲取的輸入流
     * @return
     */
    public static String streamToString(InputStream is) {
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = is.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            baos.close();
            is.close();
            byte[] byteArray = baos.toByteArray();
            return new String(byteArray);
        } catch (Exception e) {
            Log.e("TAG", e.toString());
            return null;
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
                if (baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //檔案下載
    public static void downloadFile(String fileUrl) {
        FileOutputStream fos = null;
        InputStream inputStream = null;
        try {
            // 新建一個URL物件
            URL url = new URL(fileUrl);
            // 開啟一個HttpURLConnection連線
            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
            // 設定連線主機超時時間
            urlConn.setConnectTimeout(5 * 1000);
            //設定從主機讀取資料超時
            urlConn.setReadTimeout(5 * 1000);
            // 設定是否使用快取  預設是true
            urlConn.setUseCaches(true);
            // 設定為Post請求
            urlConn.setRequestMethod("GET");
            //urlConn設定請求頭資訊
            //設定請求中的媒體型別資訊。
            urlConn.setRequestProperty("Content-Type", "application/json");
            //設定客戶端與服務連線型別
            urlConn.addRequestProperty("Connection", "Keep-Alive");
            // 開始連線
            urlConn.connect();
            // 判斷請求是否成功
            if (urlConn.getResponseCode() == 200) {
                String filePath = "";
                File descFile = new File(filePath);
                fos = new FileOutputStream(descFile);
                byte[] buffer = new byte[1024];
                int len;
                inputStream = urlConn.getInputStream();
                while ((len = inputStream.read(buffer)) != -1) {
                    // 寫到本地
                    fos.write(buffer, 0, len);
                }
            } else {
                Log.e("TAG", "檔案下載失敗");
            }
            // 關閉連線
            urlConn.disconnect();
        } catch (Exception e) {
            Log.e("TAG", e.toString());
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //檔案上傳
    public static void upLoadFile(String filePath, HashMap<String, String> paramsMap) {
        DataInputStream in = null;
        FileInputStream fileInput = null;
        DataOutputStream requestStream = null;
        try {
            String baseUrl = "https://xxx.com/uploadFile";
            File file = new File(filePath);
            //新建url物件
            URL url = new URL(baseUrl);
            //通過HttpURLConnection物件,向網路地址傳送請求
            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
            //設定該連線允許讀取
            urlConn.setDoOutput(true);
            //設定該連線允許寫入
            urlConn.setDoInput(true);
            //設定不能適用快取
            urlConn.setUseCaches(false);
            //設定連線超時時間
            urlConn.setConnectTimeout(5 * 1000);   //設定連線超時時間
            //設定讀取超時時間
            urlConn.setReadTimeout(5 * 1000);   //讀取超時
            //設定連線方法post
            urlConn.setRequestMethod("POST");
            //設定維持長連線
            urlConn.setRequestProperty("connection", "Keep-Alive");
            //設定檔案字符集
            urlConn.setRequestProperty("Accept-Charset", "UTF-8");
            //設定檔案型別
            urlConn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + "*****");
            String name = file.getName();
            requestStream = new DataOutputStream(urlConn.getOutputStream());
            requestStream.writeBytes("--" + "*****" + "\r\n");
            //傳送檔案引數資訊
            StringBuilder tempParams = new StringBuilder();
            tempParams.append("Content-Disposition: form-data; name=\"" + name + "\"; filename=\"" + name + "\"; ");
            int pos = 0;
            int size = paramsMap.size();
            for (String key : paramsMap.keySet()) {
                tempParams.append(String.format("%s=\"%s\"", key, paramsMap.get(key), "utf-8"));
                if (pos < size - 1) {
                    tempParams.append("; ");
                }
                pos++;
            }
            tempParams.append("\r\n");
            tempParams.append("Content-Type: application/octet-stream\r\n");
            tempParams.append("\r\n");
            String params = tempParams.toString();
            requestStream.writeBytes(params);
            //傳送檔案資料
            fileInput = new FileInputStream(file);
            int bytesRead;
            byte[] buffer = new byte[1024];
            in = new DataInputStream(new FileInputStream(file));
            while ((bytesRead = in.read(buffer)) != -1) {
                requestStream.write(buffer, 0, bytesRead);
            }
            requestStream.writeBytes("\r\n");
            requestStream.flush();
            requestStream.writeBytes("--" + "*****" + "--" + "\r\n");
            requestStream.flush();
            fileInput.close();
            int statusCode = urlConn.getResponseCode();
            if (statusCode == 200) {
                // 獲取返回的資料
                String result = streamToString(urlConn.getInputStream());
            } else {
                Log.e("TAG", "上傳失敗");
            }
        } catch (IOException e) {
            Log.e("TAG", e.toString());
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (fileInput != null) {
                    fileInput.close();
                }
                if (requestStream != null) {
                    requestStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

再附一個json解析工具類

package com.xuenan.aaa;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * </br>
 * Created in 2016-11-26
 *
 * @author zhuangxuenan
 */
public class JsonUtil {
    /**
     * 用fastjson 將json字串解析為一個 JavaBean
     *
     * @param jsonString
     * @param cls
     * @return
     */
    public static <T> T parseJson(String jsonString, Class<T> cls) {
        T t = null;
        try {
            t = JSON.parseObject(jsonString, cls);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return t;
    }

    /**
     * 用fastjson 將json字串 解析成為一個 List<JavaBean> 及 List<String>
     *
     * @param jsonString
     * @param cls
     * @return
     */
    public static <T> List<T> parseJsonList(String jsonString, Class<T> cls) {
        List<T> list = new ArrayList<T>();
        try {
            List<T> tempList = JSON.parseArray(jsonString, cls);
            if (tempList != null)
                list.addAll(tempList);
        } catch (Exception e) {
        }
        return list;
    }

    /**
     * 用fastjson 將jsonString 解析成 List<Map<String,Object>>
     *
     * @param jsonString
     * @return
     */
    public static List<Map<String, Object>> parseJsonListMap(String jsonString) {
        List<Map<String, Object>> list = new ArrayList<>();
        try {
            // 兩種寫法
            // list = JSON.parseObject(jsonString, new
            // TypeReference<List<Map<String, Object>>>(){}.getType());
            List<Map<String, Object>> tempList = JSON.parseObject(jsonString, new TypeReference<List<Map<String, Object>>>() {
            });
            if (tempList != null)
                list.addAll(tempList);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 解析為Map
     */
    public static Map<String, Object> parseJsonMap(String jsonString) {
        Map<String, Object> map = new HashMap<>();
        try {
            // 兩種寫法
            // list = JSON.parseObject(jsonString, new
            // TypeReference<List<Map<String, Object>>>(){}.getType());
            Map<String, Object> tempMap = JSON.parseObject(jsonString, new TypeReference<Map<String, Object>>() {
            });
            if (tempMap != null)
                map.putAll(tempMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }
}