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工作日内联系您，一经查实，本站立刻删除侵权内容。本文链接:https://dengtar.com/20440.html