UDP通信模型

4. Demo

首先添加權限：

<!--允許應用程序改變網絡狀態--> <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/> <!--允許應用程序改變WIFI連接狀態--> <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/> <!--允許應用程序訪問有關的網絡信息--> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/><!--允許應用程序訪問WIFI網卡的網絡信息--> <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/> <!--允許應用程序完全使用網絡--> <uses-permission android:name="android.permission.INTERNET"/> 

(1) 使用TCP協議通信

客戶端實現：

protected void connectServerWithTCPSocket() { Socket socket; try {// 創建一個Socket對象，并指定服務端的IP及端口號 socket = new Socket("192.168.1.32", 1989); // 創建一個InputStream用戶讀取要發送的文件。 InputStream inputStream = new FileInputStream("e://a.txt"); // 獲取Socket的OutputStream對象用于發送數據。 OutputStream outputStream = socket.getOutputStream(); // 創建一個byte類型的buffer字節數組，用于存放讀取的本地文件 byte buffer[] = new byte[4 * 1024]; int temp = 0; // 循環讀取文件 while ((temp = inputStream.read(buffer)) != -1) { // 把數據寫入到OuputStream對象中 outputStream.write(buffer, 0, temp); } // 發送讀取的數據到服務端 outputStream.flush(); /** 或創建一個報文，使用BufferedWriter寫入**/ //String socketData = "[2143213;21343fjks;213]"; //BufferedWriter writer = new BufferedWriter(new OutputStreamWriter( //socket.getOutputStream())); //writer.write(socketData.replace("\n", " ") + "\n"); //writer.flush(); } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } 

服務端實現：

public void serverReceviedByTcp() { // 聲明一個ServerSocket對象 ServerSocket serverSocket = null; try { // 創建一個ServerSocket對象，并讓這個Socket在1989端口監聽 serverSocket = new ServerSocket(1989); // 調用ServerSocket的accept()方法，接受客戶端所發送的請求， // 如果客戶端沒有發送數據，那么該線程就阻塞，等到收到數據，繼續執行。 Socket socket = serverSocket.accept(); // 從Socket當中得到InputStream對象，讀取客戶端發送的數據 InputStream inputStream = socket.getInputStream(); byte buffer[] = new byte[1024 * 4]; int temp = 0; // 從InputStream當中讀取客戶端所發送的數據 while ((temp = inputStream.read(buffer)) != -1) { System.out.println(new String(buffer, 0, temp)); } serverSocket.close(); } catch (IOException e) { e.printStackTrace(); } } 

5. 方法

(1) ServerSocket

監聽來自于客戶端的Socket連接，如果沒有連接，它將一直處于等待狀態

• ServerSocket(int port, int backlog, InetAddress bindAddr)在機器存在多IP的情況下，允許通過bindAddr來指定綁定到哪個IP；backlog是隊列中能接受的最大socket客戶端連接數（accept()之后將被取出）
• ServerSocket() 創建非綁定服務器套接字
• ServerSocket(int port) 創建綁定到特定端口的服務器套接字，等價于ServerSocket(port, 50, null)
• accept() Socket 如果接收到一個客戶端Socket的連接請求，返回一個與客戶端Socket相對應的Socket
• close()

(2) Socket

• Socket() 創建未連接套接字
• Socket(String host, int port)
• Socket(InetAddress address, int port)創建一個流套接字并將其連接到指定 IP 地址的指定端口號，默認使用本地主機默認的IP和系統動態分配的端口
• Socket(InetAddress address, int port, InetAddress localAddr, int localPort)創建一個套接字并將其連接到指定遠程地址上的指定遠程端口，多IP時
• getOutputStream() OutputStream 返回此套接字的輸出流
• getInputStream() inputStream 返回此套接字的輸入流
• connect(SocketAddress endpoint, int timeout) 將此套接字連接到服務器，并指定一個超時值
• close()

6.3.3HttpURLConnection

1. URL

1）對象代表統一資源定位器，是指向互聯網“資源”的指針
2）通常由協議名、主機、端口、資源路徑組成
3）URL包含一個可打開到達該資源的輸入流，可以將URL理解成為URI的特例

• URL(String spec)
• openConnection() URLConnection
• getProtocol() String
• getHost() String
• getPort() int
• getPath() String 獲取路徑部分，/search.html
• getFile() String 獲取資源名稱，/search.html?keyword='你好'
• getQuery() String 獲取查詢字符串，keyword='你好'
• openStream() InputStream

2. URLConnection

抽象類，表示應用程序和URL之間的通信連接，可以向URL發送請求，讀取URL指向的資源

• setDoInput(boolean doinput) 發送POST請求，必須設置，設置為true
• setDoOutput(boolean dooutput) 發送POST請求，必須設置，設置為true
• setUseCaches(boolean usecaches)是否使用緩存
• setRequestProperty(String key, String value) 設置普通的請求屬性
• setConnectTimeout(int timeout)設置連接超時的時間
• setReadTimeout(int timeoutMillis) 讀取輸入流的超時時間
• connect() 抽象方法，建立實際的連接
• getHeaderField(String key) String
• getHeaderFields() Map<String,List<String>> 獲取所有的響應頭；getHeaderField(String name)獲取指定的響應頭
• getOutputStream() OutputStream
• getInputStream() InputStream
• getContentLength() int

3. HttpURLConnection

(1) 簡介

抽象類，是URLConnection的子類，增加了操作Http資源的便捷方法

• 對象不能直接構造，需要通過URL類中的openConnection()方法來獲得。
• connect()函數，實際上只是建立了一個與服務器的TCP連接，并沒有實際發送HTTP請求。HTTP請求實際上直到我們獲取服務器響應數據（如調用getInputStream()、getResponseCode()等方法）時才正式發送出去。
• 對HttpURLConnection對象的配置都需要在connect()方法執行之前完成。
• HttpURLConnection是基于HTTP協議的，其底層通過socket通信實現。如果不設置超時（timeout），在網絡異常的情況下，可能會導致程序僵死而不繼續往下執行。
• HTTP正文的內容是通過OutputStream流寫入的， 向流中寫入的數據不會立即發送到網絡，而是存在于內存緩沖區中，待流關閉時，根據寫入的內容生成HTTP正文。
• 調用getInputStream()方法時，返回一個輸入流，用于從中讀取服務器對于HTTP請求的返回信息。
• 我們可以使用connect()方法手動的發送一個HTTP請求，但是如果要獲取HTTP響應的時候，請求就會自動的發起，比如我們使用getInputStream()方法的時候，所以完全沒有必要調用connect()方法。

(2) 方法

• setRequestMethod(String method)
• setInstanceFollowRedirects(boolean followRedirects)
• getResponseCode() int 獲取服務器的響應碼
• getResponseMessage() String 獲取響應消息
• getRequestMethod() String 獲取發送請求的方法，GET或POST
• disconnect() 抽象方法

(3) 實現多線程下載

步驟：
①：創建URL對象
②：獲取URL對象指向資源的大小（getContentLength()方法）
③：在本地創建一個與網路資源相同大小的空文件
④：計算每條線程應該下載網絡資源的哪個部分（從哪個字節開始，到哪個字節結束）
⑤：依次創建，啟動多條線程來下載網絡資源的指定部分

(4) 實例

使用GET方式訪問HTTP

public static void main(String[] args) { try { // 1. 得到訪問地址的URL URL url = new URL( "http://localhost:8080/Servlet/do_login.do?username=test&password=123456"); // 2. 得到網絡訪問對象java.net.HttpURLConnection HttpURLConnection connection = (HttpURLConnection) url .openConnection(); /* 3. 設置請求參數（過期時間，輸入、輸出流、訪問方式），以流的形式進行連接 */ // 設置是否向HttpURLConnection輸出 connection.setDoOutput(false); // 設置是否從httpUrlConnection讀入 connection.setDoInput(true); // 設置請求方式 connection.setRequestMethod("GET"); // 設置是否使用緩存 connection.setUseCaches(true); // 設置此 HttpURLConnection 實例是否應該自動執行 HTTP 重定向 connection.setInstanceFollowRedirects(true); // 設置超時時間 connection.setConnectTimeout(3000); // 連接 connection.connect(); // 4. 得到響應狀態碼的返回值 responseCode int code = connection.getResponseCode(); // 5. 如果返回值正常，數據在網絡中是以流的形式得到服務端返回的數據 String msg = ""; if (code == 200) { // 正常響應 // 從流中讀取響應信息 BufferedReader reader = new BufferedReader( new InputStreamReader(connection.getInputStream())); String line = null;while ((line = reader.readLine()) != null) { // 循環從流中讀取 msg += line + "\n"; } reader.close(); // 關閉流 } // 6. 斷開連接，釋放資源 connection.disconnect(); // 顯示響應結果 System.out.println(msg); } catch (IOException e) { e.printStackTrace(); } } 

使用POST方式訪問HTTP

public static void main(String[] args) { try { // 1. 獲取訪問地址URL URL url = new URL("http://localhost:8080/Servlet/do_login.do"); // 2. 創建HttpURLConnection對象 HttpURLConnection connection = (HttpURLConnection) url .openConnection(); /* 3. 設置請求參數等 */ // 請求方式 connection.setRequestMethod("POST"); // 超時時間 connection.setConnectTimeout(3000); // 設置是否輸出 connection.setDoOutput(true); // 設置是否讀入 connection.setDoInput(true); // 設置是否使用緩存 connection.setUseCaches(false); // 設置此 HttpURLConnection 實例是否應該自動執行 HTTP 重定向 connection.setInstanceFollowRedirects(true); // 設置使用標準編碼格式編碼參數的名-值對 connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded"); // 連接 connection.connect(); /* 4. 處理輸入輸出 */ // 寫入參數到請求中 String params = "username=test&password=123456"; OutputStream out = connection.getOutputStream(); out.write(params.getBytes()); out.flush(); out.close(); // 從連接中讀取響應信息 String msg = ""; int code = connection.getResponseCode(); if (code == 200) { BufferedReader reader = new BufferedReader( new InputStreamReader(connection.getInputStream())); String line;while ((line = reader.readLine()) != null) { msg += line + "\n"; } reader.close(); } // 5. 斷開連接 connection.disconnect();// 處理結果 System.out.println(msg); } catch (MalformedURLException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } 

4. HttpClient

（Android6.0之后的SDK中移除了對于HttpClient的支持，僅作了解）
在一般情況下，如果只是需要向Web站點的某個簡單頁面提交請求并獲取服務器響應，HttpURLConnection完全可以勝任。但在絕大部分情況下，Web站點的網頁可能沒這么簡單，這些頁面并不是通過一個簡單的URL就可訪問的，可能需要用戶登錄而且具有相應的權限才可訪問該頁面。在這種情況下，就需要涉及Session、Cookie的處理了，如果打算使用HttpURLConnection來處理這些細節，當然也是可能實現的，只是處理起來難度就大了。

為了更好地處理向Web站點請求，包括處理Session、Cookie等細節問題，Apache開源組織提供了一個HttpClient項目。HttpClient就是一個增強版的HttpURLConnection，HttpURLConnection可以做的事情HttpClient全部可以做；HttpURLConnection沒有提供的有些功能，HttpClient也提供了，但它只是關注于如何發送請求、接收響應，以及管理HTTP連接。

(1) HttpClient的使用

步驟：
①：創建HttpClient對象
②：需要GET請求，創建HttpCet對象；需要POST請求，創建HttpPost對象
③：需要發送請求參數，調用HttpGet、HttpPost共同的setParams(HttpParams params)，HttpPost對象還可以使用setEntity(HttpEntity entity)方法來設置請求參數。
④：調用HttpClient對象的execute(HttpUriRequest request) HttpResponse發送請求，執行該方法返回一個HttpResponse。
⑤：調用HttpResponse的getAllHeaders()，getHeader(String name)獲取響應頭；調用HttpResponse的getEntity()獲取HttpEntity對象（包裝了服務器的響應內容）

(2) 使用GET方式訪問HTTP

public static void main(String[] args) { // 1. 創建HttpClient對象 CloseableHttpClient httpClient = HttpClientBuilder.create().build(); // 2. 創建HttpGet對象 HttpGet httpGet = new HttpGet( "http://localhost:8080/Servlet/do_login.do?username=test&password=123456"); CloseableHttpResponse response = null; try { // 3. 執行GET請求 response = httpClient.execute(httpGet); System.out.println(response.getStatusLine()); // 4. 獲取響應實體 HttpEntity entity = response.getEntity(); // 5. 處理響應實體 if (entity != null) { System.out.println("長度：" + entity.getContentLength()); System.out.println("內容：" + EntityUtils.toString(entity)); } } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { // 6. 釋放資源 try { response.close(); httpClient.close(); } catch (IOException e) { e.printStackTrace(); } } } 

(3) 使用POST方式訪問HTTP

public static void main(String[] args) { // 1. 創建HttpClient對象 CloseableHttpClient httpClient = HttpClientBuilder.create().build(); // 2. 創建HttpPost對象 HttpPost post = new HttpPost( "http://localhost:8080/Servlet/do_login.do"); // 3. 設置POST請求傳遞參數 List<NameValuePair> params = new ArrayList<NameValuePair>(); params.add(new BasicNameValuePair("username", "test")); params.add(new BasicNameValuePair("password", "12356")); try { UrlEncodedFormEntity entity = new UrlEncodedFormEntity(params); post.setEntity(entity); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } // 4. 執行請求并處理響應 try { CloseableHttpResponse response = httpClient.execute(post); HttpEntity entity = response.getEntity(); if (entity != null) { System.out.println("響應內容："); System.out.println(EntityUtils.toString(entity)); } response.close(); } catch (ClientProtocolException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } finally { // 釋放資源 try { httpClient.close(); } catch (IOException e) { e.printStackTrace(); } } } 

6.4 OkHttp

6.4.1 簡介

HttpClient是Apache基金會的一個開源網絡庫，功能十分強大，API數量眾多，但正是由于龐大的API數量使得我們很難在不破壞兼容性的情況下對它進行升級和擴展，所以Android團隊在提升和優化HttpClient方面的工作態度并不積極。官方在Android 2.3以后就不建議用了，并且在Android 5.0以后廢棄了HttpClient，在Android 6.0更是刪除了HttpClient。

HttpURLConnection是一種多用途、輕量極的HTTP客戶端，提供的API比較簡單，可以容易地去使用和擴展。不過在Android 2.2版本之前，HttpURLConnection一直存在著一些令人厭煩的bug。比如說對一個可讀的InputStream調用close()方法時，就有可能會導致連接池失效了。那么我們通常的解決辦法就是直接禁用掉連接池的功能。因此一般推薦是在2.2之前使用HttpClient，因為其bug較少。在2.2之后推薦使用HttpURLConnection，因為API簡單、體積小、有壓縮和緩存機制，并且Android團隊后續會繼續優化HttpURLConnection。

自從Android4.4開始，google已經開始將源碼中的HttpURLConnection替換為OkHttp，而市面上流行的Retrofit同樣是使用OkHttp進行再次封裝而來的。

OkHttp是一個快速、高效的網絡請求庫，它的設計和實現的首要目標便是高效，有如下特性：

• 支持HTTP/2, HTTP/2通過使用多路復用技術在一個單獨的TCP連接上支持并發, 通過在一個連接上一次性發送多個請求來發送或接收數據；
• 如果HTTP/2不可用, 連接池復用技術也可以極大減少延時；
• 支持Gzip壓縮響應體，降低傳輸內容的大??；
• 支持Http緩存，避免重復請求；
• 如果您的服務器配置了多個IP地址, 當第一個IP連接失敗的時候, OkHttp會自動嘗試下一個IP；
• 使用Okio來簡化數據的訪問與存儲，提高性能；
• OkHttp還處理了代理服務器問題和SSL握手失敗問題；

6.4.2 OkHttp類與Http請求響應的映射

1. Http請求

http請求包含：請求方法, 請求地址, 請求協議, 請求頭, 請求體這五部分。這些都在okhttp3.Request的類中有體現, 這個類正是代表http請求的類。

public final class Request { final HttpUrl url;//請求地址 final String method;//請求方法 final Headers headers;//請求頭 final RequestBody body;//請求體 final Object tag; ... } 

2. Http響應

Http響應由訪問協議, 響應碼, 描述信息, 響應頭, 響應體來組成。

public final class Response implements Closeable { final Request request;//持有的請求 final Protocol protocol;//訪問協議 final int code;//響應碼 final String message;//描述信息 final Handshake handshake;//SSL/TLS握手協議驗證時的信息, final Headers headers;//響應頭 final ResponseBody body;//響應體 ... } 

6.4.3 相關方法

1. OkHttpClient

• OkHttpClient()
• OkHttpClient(OkHttpClient.Builder builder)
• newCall(Request request) Call

OkHttpClient.Builder

• connectTimeout(long timeout, TimeUnit unit)
• readTimeout(long timeout, TimeUnit unit)
• writeTimeout(long timeout, TimeUnit unit)
• pingInterval(long interval, TimeUnit unit)
• cache(Cache cache) 入參如：new Cache(File directory, long maxSize)
• cookieJar(CookieJar cookieJar) CookieJar是一個接口
• hostnameVerifier(HostnameVerifier hostnameVerifier) HostnameVerifier是一個接口，只有boolean verify(String hostname, SSLSession session)
• sslSocketFactory(SSLSocketFactory sslSocketFactory, X509TrustManager trustManager)

2. Request

• Request(Request.Builder builder)

Request.Builder

• addHeader(String name, String value) 添加鍵值對，不會覆蓋
• header(String name, String value) 添加鍵值對，會覆蓋
• url(String url)
• method(String method, RequestBody body)
• post(RequestBody body) 本質：method("POST", body)
• build() Request

RequestBody

• create(MediaType contentType, final File file) RequestBody
• create(MediaType contentType, String content) RequestBody
• create(MediaType contentType, byte[] content) RequestBody

FormBody

RequestBody的子類

FormBody.Builder

• add(String name, String value) FormBody.Builder
• build() FormBody

MultipartBody

RequestBody的子類

MultipartBody.Builder

• Builder()
• Builder(String boundary)
• setType(MediaType type)
• addPart(Headers headers, RequestBody body)
• addFormDataPart(String name, String filename, RequestBody body)
• build() MultipartBody

3. Call

Call負責發送請求和讀取響應

• enqueue(Callback responseCallback)加入調度隊列，異步執行
• execute() Response 同步執行
• cancel()

4. Response

• body() ResponseBody
• code() int http請求的狀態碼
• isSuccessful() code為2XX時，返回true，否則false
• headers() Headers

ResponseBody

• string() String
• bytes() byte[]
• byteStream() InputStream
• charStream() Reader
• contentLength() long

5. MediaType

RequestBody的數據格式都要指定Content-Type，就是指定MIME，常見的有三種：

• application/x-www-form-urlencoded 數據是個普通表單（默認）
• multipart/form-data 數據里有文件
• application/json 數據是個json

方法：

• parse(String string) MediaType

參數	說明
text/html	HTML格式
text/plain	純文本格式
image/gif	gif圖片格式
image/jpeg	jpg圖片格式
image/png	png圖片格式
application/json	JSON數據格式
application/pdf	pdf格式
application/msword	Word文檔格式
application/octet-stream	二進制流數據
application/x-www-form-urlencoded	普通表單數據
multipart/form-data	表單數據里有文件

6. 自動管理Cookie

Request經常都要攜帶Cookie，request創建時可以通過header設置參數，Cookie也是參數之一。就像下面這樣：

Request request = new Request.Builder() .url(url) .header("Cookie", "xxx") .build(); 

然后可以從返回的response里得到新的Cookie，你可能得想辦法把Cookie保存起來。
但是OkHttp可以不用我們管理Cookie，自動攜帶，保存和更新Cookie。
方法是在創建OkHttpClient設置管理Cookie的CookieJar：

private final HashMap<String, List<Cookie>> cookieStore = new HashMap<>(); OkHttpClient okHttpClient = new OkHttpClient.Builder() .cookieJar(new CookieJar() { @Override public void saveFromResponse(HttpUrl httpUrl, List<Cookie> list) { cookieStore.put(httpUrl.host(), list); }@Override public List<Cookie> loadForRequest(HttpUrl httpUrl) { List<Cookie> cookies = cookieStore.get(httpUrl.host()); return cookies != null ? cookies : new ArrayList<Cookie>(); } }) .build(); 

這樣以后發送Request都不用管Cookie這個參數也不用去response獲取新Cookie什么的了。還能通過cookieStore獲取當前保存的Cookie。
最后，new OkHttpClient()只是一種快速創建OkHttpClient的方式，更標準的是使用OkHttpClient.Builder()。后者可以設置一堆參數，例如超時時間什么的。

6.4.4 get請求

1. 異步的get請求

//step 1: 創建 OkHttpClient 對象 OkHttpClient okHttpClient = new OkHttpClient(); //step 2： 創建一個請求，不指定請求方法時默認是GET。 Request.Builder requestBuilder = new Request.Builder().url("http://www.baidu.com"); //可以省略，默認是GET請求 requestBuilder.method("GET", null); //step 3：創建 Call 對象 Call call = okHttpClient.newCall(requestBuilder.build()); //step 4: 開始異步請求 call.enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { }@Override public void onResponse(Call call, Response response) throws IOException { //獲得返回體 ResponseBody body = response.body(); } }); 

首先要將OkHttpClient的對象與Request的對象建立起來聯系，使用okHttpClient的newCall()方法得到一個Call對象，這個Call對象的作用就是相當于將請求封裝成了一個任務，既然是任務，自然就會有execute()和cancel()等方法。

最后，我們希望以異步的方式去執行請求，所以我們調用的是call.enqueue，將call加入調度隊列，然后等待任務執行完成，我們在Callback中即可得到結果。但要注意的是，call的回調是子線程，所以是不能直接操作界面的。當請求成功時就會回調onResponse()方法，我們可以看到返回的結果是Response對象，在此我們比較關注的是請求中的返回體body（ResponseBody類型），大多數的情況下我們希望獲得字符串從而進行json解析獲得數據，所以可以通過body.string()的方式獲得字符串。如果希望獲得返回的二進制字節數組，則調用response.body().bytes()；如果你想拿到返回的inputStream，則調用response.body().byteStream()。

2. 同步的get請求

調用Call#execute()方法，在主線程運行

6.4.5 post請求

1. Post上傳表單（鍵值對）

//step1: 同樣的需要創建一個OkHttpClick對象 OkHttpClient okHttpClient = new OkHttpClient(); //step2: 創建 FormBody.Builder FormBody formBody = new FormBody.Builder() .add("name", "dsd") //添加鍵值對 .build(); //step3: 創建請求 Request request = new Request.Builder().url("http://www.baidu.com") .post(formBody) .build() //step4： 建立聯系 創建Call對象 okHttpClient.newCall(request).enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { }@Override public void onResponse(Call call, Response response) throws IOException { } }); 

2. Post異步上傳文件

// step 1: 創建 OkHttpClient 對象 OkHttpClient okHttpClient = new OkHttpClient(); //step 2:創建 RequestBody 以及所需的參數 //2.1 獲取文件 File file = new File(Environment.getExternalStorageDirectory() + "test.txt"); //2.2 創建 MediaType 設置上傳文件類型 MediaType MEDIATYPE = MediaType.parse("text/plain; charset=utf-8"); //2.3 獲取請求體 RequestBody requestBody = RequestBody.create(MEDIATYPE, file); //step 3：創建請求 Request request = new Request.Builder().url("http://www.baidu.com") .post(requestBody) .build(); //step 4 建立聯系 okHttpClient.newCall(request).enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { }@Override public void onResponse(Call call, Response response) throws IOException { } }); 

3. Post方式提交流

以流的方式POST提交請求體. 請求體的內容由流寫入產生. 這個例子是流直接寫入Okio的BufferedSink. 你的程序可能會使用OutputStream, 你可以使用BufferedSink.outputStream()來獲取. OkHttp的底層對流和字節的操作都是基于Okio庫, Okio庫也是Square開發的另一個IO庫, 填補I/O和NIO的空缺, 目的是提供簡單便于使用的接口來操作IO.

public static final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8"); private final OkHttpClient client = new OkHttpClient();public void run() throws Exception { RequestBody requestBody = new RequestBody() { @Override public MediaType contentType() { return MEDIA_TYPE_MARKDOWN; }@Override public void writeTo(BufferedSink sink) throws IOException { sink.writeUtf8("Numbers\n"); sink.writeUtf8("-------\n"); for (int i = 2; i <= 997; i++) { sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i))); } }private String factor(int n) { for (int i = 2; i < n; i++) { int x = n / i; if (x * i == n) return factor(x) + " × " + i; } return Integer.toString(n); } };Request request = new Request.Builder() .url("https://api.github.com/markdown/raw") .post(requestBody) .build();Response response = client.newCall(request).execute(); if (!response.isSuccessful()) throw new IOException("Unexpected code " + response); System.out.println(response.body().string()); } 

4. Post方式提交String

下面是使用HTTP POST提交請求到服務. 這個例子提交了一個markdown文檔到web服務, 以HTML方式渲染markdown. 因為整個請求體都在內存中, 因此避免使用此api提交大文檔（大于1MB）.

public static final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8");private final OkHttpClient client = new OkHttpClient();public void run() throws Exception { String postBody = "" + "Releases\n" + "--------\n" + "\n" + " * _1.0_ May 6, 2013\n" + " * _1.1_ June 15, 2013\n" + " * _1.2_ August 11, 2013\n";Request request = new Request.Builder() .url("https://api.github.com/markdown/raw") .post(RequestBody.create(MEDIA_TYPE_MARKDOWN, postBody)) .build();Response response = client.newCall(request).execute(); if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);System.out.println(response.body().string()); } 

5、Post方式提交分塊請求

MultipartBody.Builder可以構建復雜的請求體, 與HTML文件上傳形式兼容. 多塊請求體中每塊請求都是一個請求體, 可以定義自己的請求頭. 這些請求頭可以用來描述這塊請求, 例如它的Content-Disposition. 如果Content-Length和Content-Type可用的話, 他們會被自動添加到請求頭中.

private static final String IMGUR_CLIENT_ID = "..."; private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");private final OkHttpClient client = new OkHttpClient();public void run() throws Exception { // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image RequestBody requestBody = new MultipartBody.Builder() .setType(MultipartBody.FORM) .addFormDataPart("title", "Square Logo") .addFormDataPart("image", "logo-square.png", RequestBody.create(MEDIA_TYPE_PNG, new File("website/static/logo-square.png"))) .build();Request request = new Request.Builder() .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID) .url("https://api.imgur.com/3/image") .post(requestBody) .build();Response response = client.newCall(request).execute(); if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);System.out.println(response.body().string()); } 

六、其他用法

1、提取響應頭

典型的HTTP頭是一個Map<String, String> : 每個字段都有一個或沒有值. 但是一些頭允許多個值。
當寫請求頭的時候, 使用header(name, value)可以設置唯一的name、value. 如果已經有值, 舊的將被移除, 然后添加新的. 使用addHeader(name, value)可以添加多值（添加, 不移除已有的）.
當讀取響應頭時, 使用header(name)返回最后出現的name、value. 通常情況這也是唯一的name、value. 如果沒有值, 那么header(name)將返回null. 如果想讀取字段對應的所有值, 使用headers(name)`會返回一個list.
為了獲取所有的Header, Headers類支持按index訪問.

private final OkHttpClient client = new OkHttpClient(); public void run() throws Exception { Request request = new Request.Builder() .url("https://api.github.com/repos/square/okhttp/issues") .header("User-Agent", "OkHttp Headers.java") .addHeader("Accept", "application/json; q=0.5") .addHeader("Accept", "application/vnd.github.v3+json") .build(); Response response = client.newCall(request).execute(); if (!response.isSuccessful()) throw new IOException("Unexpected code " + response); System.out.println("Server: " + response.header("Server")); System.out.println("Date: " + response.header("Date")); System.out.println("Vary: " + response.headers("Vary")); } 

2、使用Gson來解析JSON響應

Gson是一個在JSON和Java對象之間轉換非常方便的api庫. 這里我們用Gson來解析Github API的JSON響應.
注意: ResponseBody.charStream()使用響應頭Content-Type指定的字符集來解析響應體. 默認是UTF-8.

private final OkHttpClient client = new OkHttpClient(); private final Gson gson = new Gson();public void run() throws Exception { Request request = new Request.Builder() .url("https://api.github.com/gists/c2a7c39532239ff261be") .build(); Response response = client.newCall(request).execute(); if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);Gist gist = gson.fromJson(response.body().charStream(), Gist.class); for (Map.Entry<String, GistFile> entry : gist.files.entrySet()) { System.out.println(entry.getKey()); System.out.println(entry.getValue().content); } }static class Gist { Map<String, GistFile> files; }static class GistFile { String content; } 

3、響應緩存

OKHTTP如果要設置緩存，首要的條件就是設置一個緩存文件夾，在Android中為了安全起見，一般設置為私密數據空間。通過getExternalCacheDir()獲取。
如然后通過調用OKHttpClient.Builder中的cache()方法。如下面代碼所示：

//緩存文件夾 File cacheFile = new File(getExternalCacheDir().toString(),"cache"); //緩存大小為10M int cacheSize = 10 * 1024 * 1024; //創建緩存對象 Cache cache = new Cache(cacheFile,cacheSize);OkHttpClient client = new OkHttpClient.Builder() .cache(cache) .build(); 

設置好Cache我們就可以正常訪問了。我們可以通過獲取到的Response對象拿到它正常的消息和緩存的消息。

Response的消息有兩種類型，CacheResponse和NetworkResponse。CacheResponse代表從緩存取到的消息，NetworkResponse代表直接從服務端返回的消息。
示例代碼如下：

private void testCache(){ //緩存文件夾 File cacheFile = new File(getExternalCacheDir().toString(),"cache"); //緩存大小為10M int cacheSize = 10 * 1024 * 1024; //創建緩存對象 final Cache cache = new Cache(cacheFile,cacheSize);new Thread(new Runnable() { @Override public void run() { OkHttpClient client = new OkHttpClient.Builder() .cache(cache) .build(); //官方的一個示例的url String url = "http://publicobject.com/helloworld.txt";Request request = new Request.Builder() .url(url) .build(); Call call1 = client.newCall(request); Response response1 = null; try { //第一次網絡請求 response1 = call1.execute(); Log.i(TAG, "testCache: response1 :"+response1.body().string()); Log.i(TAG, "testCache: response1 cache :"+response1.cacheResponse()); Log.i(TAG, "testCache: response1 network :"+response1.networkResponse()); response1.body().close(); } catch (IOException e) { e.printStackTrace(); }Call call12 = client.newCall(request);try { //第二次網絡請求 Response response2 = call12.execute(); Log.i(TAG, "testCache: response2 :"+response2.body().string()); Log.i(TAG, "testCache: response2 cache :"+response2.cacheResponse()); Log.i(TAG, "testCache: response2 network :"+response2.networkResponse()); Log.i(TAG, "testCache: response1 equals response2:"+response2.equals(response1)); response2.body().close(); } catch (IOException e) { e.printStackTrace(); } } }).start();} 

我們在上面的代碼中，用同一個url地址分別進行了兩次網絡訪問，然后分別用Log打印它們的信息。打印的結果主要說明了一個現象，第一次訪問的時候，Response的消息是NetworkResponse消息，此時CacheResponse的值為Null.而第二次訪問的時候Response是CahceResponse，而此時NetworkResponse為空。也就說明了上面的示例代碼能夠進行網絡請求的緩存。

其實控制緩存的消息頭往往是服務端返回的信息中添加的如”Cache-Control:max-age=60”。所以，會有兩種情況。

1. 客戶端和服務端開發能夠很好溝通，按照達成一致的協議，服務端按照規定添加緩存相關的消息頭。
2. 客戶端與服務端的開發根本就不是同一家公司，沒有辦法也不可能要求服務端按照客戶端的意愿進行開發。

第一種辦法當然很好，只要服務器在返回消息的時候添加好Cache-Control相關的消息便好。

第二種情況，就很麻煩，你真的無法左右別人的行為。怎么辦呢？好在OKHTTP能夠很輕易地處理這種情況。那就是定義一個攔截器，
人為地添加Response中的消息頭，然后再傳遞給用戶，這樣用戶拿到的Response就有了我們理想當中的消息頭Headers，從而達到控制緩存的意圖，正所謂移花接木。

緩存之攔截器

因為攔截器可以拿到Request和Response，所以可以輕而易舉地加工這些東西。在這里我們人為地添加Cache-Control消息頭。

class CacheInterceptor implements Interceptor{@Override public Response intercept(Chain chain) throws IOException {Response originResponse = chain.proceed(chain.request());//設置緩存時間為60秒，并移除了pragma消息頭，移除它的原因是因為pragma也是控制緩存的一個消息頭屬性 return originResponse.newBuilder().removeHeader("pragma") .header("Cache-Control","max-age=60").build(); } } 

定義好攔截器中后，我們可以添加到OKHttpClient中了。

private void testCacheInterceptor(){ //緩存文件夾 File cacheFile = new File(getExternalCacheDir().toString(),"cache"); //緩存大小為10M int cacheSize = 10 * 1024 * 1024; //創建緩存對象 final Cache cache = new Cache(cacheFile,cacheSize);OkHttpClient client = new OkHttpClient.Builder() .addNetworkInterceptor(new CacheInterceptor()) .cache(cache) .build(); ....... } 

代碼后面部分有省略。主要通過在OkHttpClient.Builder()中addNetworkInterceptor()中添加。而這樣也挺簡單的，就幾步完成了緩存代碼。

攔截器進行緩存的缺點

1. 網絡訪問請求的資源是文本信息，如新聞列表，這類信息經常變動，一天更新好幾次，它們用的緩存時間應該就很短。
2. 網絡訪問請求的資源是圖片或者視頻，它們變動很少，或者是長期不變動，那么它們用的緩存時間就應該很長。

那么，問題來了。
因為OKHTTP開發建議是同一個APP，用同一個OKHTTPCLIENT對象這是為了只有一個緩存文件訪問入口。這個很容易理解，單例模式嘛。但是問題攔截器是在OKHttpClient.Builder當中添加的。如果在攔截器中定義緩存的方法會導致圖片的緩存和新聞列表的緩存時間是一樣的，這顯然是不合理的，真實的情況不應該是圖片請求有它的緩存時間，新聞列表請求有它的緩存時間，應該是每一個Request有它的緩存時間。 那么，有解決的方案嗎？ 有的，okhttp官方有建議的方法。

okhttp官方文檔建議緩存方法

okhttp中建議用CacheControl這個類來進行緩存策略的制定。
它內部有兩個很重要的靜態實例。

/**強制使用網絡請求*/ public static final CacheControl FORCE_NETWORK = new Builder().noCache().build();/*** 強制性使用本地緩存，如果本地緩存不滿足條件，則會返回code為504*/ public static final CacheControl FORCE_CACHE = new Builder() .onlyIfCached() .maxStale(Integer.MAX_VALUE, TimeUnit.SECONDS) .build(); 

我們看到FORCE_NETWORK常量用來強制使用網絡請求。FORCE_CACHE只取本地的緩存。它們本身都是CacheControl對象，由內部的Buidler對象構造。下面我們來看看CacheControl.Builder

CacheControl.Builder

它有如下方法：

• noCache()//不使用緩存，用網絡請求
• noStore()//不使用緩存，也不存儲緩存
• onlyIfCached()//只使用緩存
• noTransform()//禁止轉碼
• maxAge(10, TimeUnit.MILLISECONDS)//設置超時時間為10ms。
• maxStale(10, TimeUnit.SECONDS)//超時之外的超時時間為10s
• minFresh(10, TimeUnit.SECONDS)//超時時間為當前時間加上10秒鐘。

知道了CacheControl的相關信息，那么它怎么使用呢？不同于攔截器設置緩存，CacheControl是針對Request的，所以它可以針對每個請求設置不同的緩存策略。比如圖片和新聞列表。下面代碼展示如何用CacheControl設置一個60秒的超時時間。

private void testCacheControl(){ //緩存文件夾 File cacheFile = new File(getExternalCacheDir().toString(),"cache"); //緩存大小為10M int cacheSize = 10 * 1024 * 1024; //創建緩存對象 final Cache cache = new Cache(cacheFile,cacheSize);new Thread(new Runnable() { @Override public void run() { OkHttpClient client = new OkHttpClient.Builder() .cache(cache) .build(); //設置緩存時間為60秒 CacheControl cacheControl = new CacheControl.Builder() .maxAge(60, TimeUnit.SECONDS) .build(); Request request = new Request.Builder() .url("http://blog.csdn.net/briblue") .cacheControl(cacheControl) .build(); try { Response response = client.newCall(request).execute(); response.body().close(); } catch (IOException e) { e.printStackTrace(); } } }).start();} 

強制使用緩存

前面有講CacheControl.FORCE_CACHE這個常量。

public static final CacheControl FORCE_CACHE = new Builder() .onlyIfCached() .maxStale(Integer.MAX_VALUE, TimeUnit.SECONDS) 

它內部其實就是調用onlyIfCached()和maxStale方法。
它的使用方法為

Request request = new Request.Builder() .url("http://blog.csdn.net/briblue") .cacheControl(Cache.FORCE_CACHE) .build(); 

但是如前面后提到的，如果緩存不符合條件會返回504.這個時候我們要根據情況再進行編碼，如緩存不行就再進行一次網絡請求。

Response forceCacheResponse = client.newCall(request).execute();if (forceCacheResponse.code() != 504) {// 資源已經緩存了，可以直接使用} else {// 資源沒有緩存，或者是緩存不符合條件了。}

不使用緩存

前面也有講CacheControl.FORCE_NETWORK這個常量。

public static final CacheControl FORCE_NETWORK = new Builder().noCache().build(); 

它的內部其實是調用noCache()方法，也就是不緩存的意思。
它的使用方法為

Request request = new Request.Builder() .url("http://blog.csdn.net/briblue") .cacheControl(Cache.FORCE_NETWORK) .build(); 

還有一種情況將maxAge設置為0，也不會取緩存，直接走網絡。

Request request = new Request.Builder() .url("http://blog.csdn.net/briblue") .cacheControl(new CacheControl.Builder() .maxAge(0, TimeUnit.SECONDS)) .build(); 

4、取消一個Call

使用Call.cancel()可以立即停止掉一個正在執行的call. 如果一個線程正在寫請求或者讀響應, 將會引發IOException. 當call沒有必要的時候, 使用這個api可以節約網絡資源. 例如當用戶離開一個應用時, 不管同步還是異步的call都可以取消.
你可以通過tags來同時取消多個請求. 當你構建一請求時, 使用RequestBuilder.tag(tag)來分配一個標簽, 之后你就可以用OkHttpClient.cancel(tag)來取消所有帶有這個tag的call.

 private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);private final OkHttpClient client = new OkHttpClient();public void run() throws Exception { Request request = new Request.Builder() .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay. .build();final long startNanos = System.nanoTime(); final Call call = client.newCall(request);// Schedule a job to cancel the call in 1 second. executor.schedule(new Runnable() { @Override public void run() { System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f); call.cancel(); System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f); } }, 1, TimeUnit.SECONDS);try { System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f); Response response = call.execute(); System.out.printf("%.2f Call was expected to fail, but completed: %s%n", (System.nanoTime() - startNanos) / 1e9f, response); } catch (IOException e) { System.out.printf("%.2f Call failed as expected: %s%n", (System.nanoTime() - startNanos) / 1e9f, e); } } 

5、超時

沒有響應時使用超時結束call. 沒有響應的原因可能是客戶點鏈接問題、服務器可用性問題或者這之間的其他東西. OkHttp支持連接超時, 讀取超時和寫入超時.

private final OkHttpClient client;public ConfigureTimeouts() throws Exception { client = new OkHttpClient.Builder() .connectTimeout(10, TimeUnit.SECONDS) .writeTimeout(10, TimeUnit.SECONDS) .readTimeout(30, TimeUnit.SECONDS) .build(); }public void run() throws Exception { Request request = new Request.Builder() .url("http://httpbin.org/delay/2") // This URL is served with a 2 second delay. .build();Response response = client.newCall(request).execute(); System.out.println("Response completed: " + response); } 

6、每個call的配置

使用OkHttpClient, 所有的HTTP Client配置包括代理設置、超時設置、緩存設置. 當你需要為單個call改變配置的時候, 調用OkHttpClient.newBuilder(). 這個api將會返回一個builder, 這個builder和原始的client共享相同的連接池, 分發器和配置.
下面的例子中，我們讓一個請求是500ms的超時、另一個是3000ms的超時。

private final OkHttpClient client = new OkHttpClient();public void run() throws Exception { Request request = new Request.Builder() .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay. .build();try { // Copy to customize OkHttp for this request. OkHttpClient copy = client.newBuilder() .readTimeout(500, TimeUnit.MILLISECONDS) .build();Response response = copy.newCall(request).execute(); System.out.println("Response 1 succeeded: " + response); } catch (IOException e) { System.out.println("Response 1 failed: " + e); }try { // Copy to customize OkHttp for this request. OkHttpClient copy = client.newBuilder() .readTimeout(3000, TimeUnit.MILLISECONDS) .build();Response response = copy.newCall(request).execute(); System.out.println("Response 2 succeeded: " + response); } catch (IOException e) { System.out.println("Response 2 failed: " + e); } } 

七、處理驗證

這部分和HTTP AUTH有關.

1、HTTP AUTH

使用HTTP AUTH需要在server端配置http auth信息, 其過程如下:

• 客戶端發送http請求（沒有Authorization header）
• 服務器發現配置了http auth, 于是檢查request里面有沒有"Authorization"的http header
  如果有, 則判斷Authorization里面的內容是否在用戶列表里面, Authorization header的典型數據為"Authorization: Basic jdhaHY0=", 其中Basic表示基礎認證, jdhaHY0=是base64編碼的"user:passwd"字符串. 如果沒有，或者用戶密碼不對，則返回http code 401頁面給客戶端.
• 標準的http瀏覽器在收到401頁面之后, 應該彈出一個對話框讓用戶輸入帳號密碼; 并在用戶點確認的時候再次發出請求, 這次請求里面將帶上Authorization header.
• 服務器端認證通過，并返回頁面
• 瀏覽器顯示頁面
  一次典型的訪問場景是：

2、OkHttp認證

OkHttp會自動重試未驗證的請求. 當響應是401 Not Authorized時，Authenticator會被要求提供證書. Authenticator的實現中需要建立一個新的包含證書的請求. 如果沒有證書可用, 返回null來跳過嘗試.
使用Response.challenges()來獲得任何authentication challenges的 schemes 和 realms. 當完成一個Basic challenge, 使用Credentials.basic(username, password)來解碼請求頭.

private final OkHttpClient client;public Authenticate() { client = new OkHttpClient.Builder() .authenticator(new Authenticator() { @Override public Request authenticate(Route route, Response response) throws IOException { System.out.println("Authenticating for response: " + response); System.out.println("Challenges: " + response.challenges()); String credential = Credentials.basic("jesse", "password1"); return response.request().newBuilder() .header("Authorization", credential) .build(); } }) .build(); }public void run() throws Exception { Request request = new Request.Builder() .url("http://publicobject.com/secrets/hellosecret.txt") .build();Response response = client.newCall(request).execute(); if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);System.out.println(response.body().string()); } 

當認證無法工作時, 為了避免多次重試, 你可以返回空來放棄認證. 例如, 當exact credentials已經嘗試過, 你可能會直接想跳過認證, 可以這樣做:

if (credential.equals(response.request().header("Authorization"))) { return null; // If we already failed with these credentials, don't retry.} 

當重試次數超過定義的次數, 你若想跳過認證, 可以這樣做:

if (responseCount(response) >= 3) { return null; // If we've failed 3 times, give up. }private int responseCount(Response response) { int result = 1; while ((response = response.priorResponse()) != null) { result++; } return result; } 

參考文獻

OkHttp使用完全教程

本頁內容由塔燈網絡科技有限公司通過網絡收集編輯所得，所有資料僅供用戶學習參考，本站不擁有所有權，如您認為本網頁中由涉嫌抄襲的內容，請及時與我們聯系，并提供相關證據，工作人員會在5工作日內聯系您，一經查實，本站立刻刪除侵權內容。本文鏈接:http://www.webpost.com.cn/20440.html