Android网络编程（二）--Http协议详解

关于HTTP的介绍这篇博客写的不错，我借用了里面的图，http://blog.csdn.net/itachi85/article/details/50982995

在上一篇中我们讨论了计算机网络的体系结构和各层次的作用，在我们编程中TCP或UDP都提供了socket接口进行实现，实现的例子在上一篇中，这一篇我们主要讨论一下Http协议，以及如何实现Http协议。
讨论的问题：

1. Http协议的定义和内容。
2. Http协议的实现。

一、Http协议的定义和内容

HTTP的英文是（HyperText Transfer Protocol），即超文本传输协议，那么什么是超文本呢，超文本就是使用超文本标记语言HTML的文本。

首先互联网上每一个资源都用一个URL所标记，URL的格式为：

http://<主机>:<端口>/<路径>

它是应用层协议，规定了数据交互的格式内容。在运输层，它采用了TCP协议保证了可靠运输。而且HTTP协议是无状态的，不过在HTTP/1.1中，添加了持续连接的功能。
下面就来看看HTTP报文的格式：
首先它有两种报文：

 - 请求报文（客户端发送给服务器的报文）
 - 响应报文（服务器返回给客户端的报文）

而且HTTP是面向文本的，所以在报文中的每一个字段都是一些ASCII码。

请求报文：

请求报文包括 请求行、请求头部、请求数据

这里面第一行是请求行，举一个例子：

GET http://s2-im-notify.csdn.net/socket.io/1/xhr-polling/4-edxSXeVplQjhPcXY2V?t=1476099463098 HTTP/1.1
Host: s2-im-notify.csdn.net
Connection: keep-alive
Origin: http://blog.csdn.net
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.103 Safari/537.36
Accept: */*
Referer: http://blog.csdn.net/
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8

请求行：
在这个请求中我们看到这个请求行为第一行，下面的都是请求头了，这个并没有请求数据。这个请求中请求方法为GET，GET是我们常用的请求方法之一，除了GET，我们还常用POST进行请求。
下面列举出请求方法，不过最常用的还是GET和POST：

• OPTION：请求一些选项的信息
• GET：请求读取由URL所标志的信息
• HEAD：请求读取由URL所标志的信息的首部
• POST：给服务器发送信息
• PUT：在指明的URL下存储一个文档
• DELETE：删除指明的URL所标志的资源
• TRACE：用来进行环回测试的请求报文

• CONNECT：用于代理服务器
  请求报头：
  请求报头有许多种，下面说一些常见的请求头：

• Host域：指定请求的服务器地址，在HTTP/1.1中请求必须包含主机头域，否则系统会以400状态码返回。

• Connection域：指定与连接相关的属性，比如上面例子中Connection: keep-alive，代表保持连接。
• User-Agent域：发送请求的应用程序名称。
• Accept-Charset域：通知服务端可以发送的编码格式。
• Accept-Encoding域：通知服务端可以发送的数据压缩格式。
• Accept-Language域：通知服务器可以发送的语言。
• Accept域： 告诉WEB服务器自己接受什么介质类型，/ 表示任何类型，type/* 表示该类型下的所有子类型。
• Referer域：发送请求页面URL。浏览器向 WEB 服务器表明自己是从哪个 网页/URL 获得/点击 当前请求中的网址/URL。
• Pramga域：主要使用 Pramga: no-cache，相当于 Cache-Control： no-cache。
• Date域：表示消息发出的时间。
• Cookie域：设置Cookie相关的。
• Cache-Control域：使用的缓存机制（在请求时和响应时它的值不同，响应的下文会说到）。
  no-cache（不要缓存的实体，要求现在从服务器去取）
  max-age：（只接受 Age 值小于 max-age 值，并且没有过期的对象）
  max-stale：（可以接受过去的对象，但是过期时间必须小于 max-stale 值）
  min-fresh：（接受其新鲜生命期大于其当前 Age 跟 min-fresh 值之和的缓存对象）。

响应报文

类比请求报文，响应报文同样也包括 响应行、响应头、响应数据

下面也是用一个例子来看一下：

HTTP/1.1 200 OK
Server: openresty
Date: Mon, 10 Oct 2016 12:25:25 GMT
Content-Type: text/html; charset=utf-8
Transfer-Encoding: chunked
Connection: keep-alive
Keep-Alive: timeout=20
Vary: Accept-Encoding
Cache-Control: private
Access-Control-Allow-Origin: *
Content-Encoding: gzip

6b0
        X[  F~G ?  $ I  @  eiWb
j }Bc{ k ]{r F+A/Z} T   U/-  [ cJ   _ _ 
     6 g s wΜs Ç #g /  sa     
O [^

*** FIDDLER: RawDisplay truncated at 128 characters. Right-click to disable truncation. ***

响应行：
第一行为响应行，对于响应行，我们可以看出状态码（也成为响应码）为200。
关于状态码，都是由三位数字组成的，分为五大类：

• 1XX ：表示通知信息，如请求收到了或者正在进行处理。
• 2XX：表示成功，其中最常见的便是200，表示请求成功。
• 3XX：表示重定向，如要完成请求还必须采取进一步的行动。
• 4XX：表示客户端出错，最常见的就是404，表示未找到。
• 5XX：表示服务器出错，比如服务器失效无法完成请求。
  除了上面的还有一些常见的响应头，比如：
  HTTP/1.1 202 Accepted //表示接受
  HTTP/1.1 400 Bad Request //表示错误的请求
  HTTP/1.1 404 Not Found //表示未找到
  HTTP/1.1 301 Moved Permanently //永久性的转移了
  响应头：
  列举一下常用的头部，（PS：在百度时发现一篇写关于这个头部和状态码非常详细的文章，我有的头部也参考的他的博客，分享给大家：http://www.2cto.com/net/201607/528141.html）
• Age域：当代理服务器用自己缓存的实体去响应请求时，用该头部表明该实体从产生到现在经过多长时间了。
• Accept-Ranges域：WEB服务器表明自己是否接受获取其某个实体的一部分（比如文件的一部分）的请求。bytes：表示接受，none：表示不接受。
• Content-Type域：服务器通知客户端它响应的对象类型，如Content-Type：application/json。

• Content-Range域：服务器表明该响应包含的部分对象为整个对象的哪个部分。

• Content-Length：服务器通知响应包含对象的长度。

• Content-Language：服务器通知客户端响应的语言。
• Content-Encoding：服务器通知客户端响应数据的压缩格式，在上面的例子中可以看出压缩格式为gzip。
• Connection：代表是否需要持久连接。
• Expired：WEB服务器表明该实体将在什么时候过期，对于过期了的对象，只有在跟WEB服务器验证了其有效性后，才能用来响应客户请求。
• Last-Modified： 服务器认为对象的最后修改时间，比如文件的最后修改时间，动态页面的最后产生时间等等。
• Location：服务器告诉浏览器，试图访问的对象已经被移到别的位置了，到该头部指定的位置去取。
• Proxy-Authenticate：代理服务器响应浏览器，要求其提供代理身份验证信息。
• Server： 服务器表明自己是什么软件及版本等信息。
• Refresh：表示浏览器应该在多少时间之后刷新文档，以秒计。
  响应数据：
  一般来说响应数据也会有一定的格式，上面的例子中因为数据用gzip压缩了，所以显示的为乱码。现在用的最火的为json格式数据，下面的例子为一个请求的响应数据，为json格式：
  {“status”:true,”error”:”“,”data”:{“id”:010101,”url”:”http://blog.csdn.net/liushuaiq/article/details/52779689“}}

二、Http协议的实现

上一篇中我们使用了java提供的socket进行了数据的传输，socket是对tcp或udp的封装，对于应用层没有实现，这一篇就对上一篇进行进一步的拓展，实现Http协议。
我们只需要在socket传输数据的基础上，进行进一步的格式化数据就可以了。
首先我封装了一个请求实体。

package com.liushuai.model;

import java.util.List;

public class Request {
    private RequestLine requestLine;
    private List<RequestHeader> requestHeaders;
    private RequestBody requestBody;

    public Request() {
        super();
    }

    public Request(RequestLine requestLine, List<RequestHeader> requestHeaders, RequestBody requestBody) {
        super();
        this.requestLine = requestLine;
        this.requestHeaders = requestHeaders;
        this.requestBody = requestBody;
    }

    public RequestLine getRequestLine() {
        return requestLine;
    }

    public void setRequestLine(RequestLine requestLine) {
        this.requestLine = requestLine;
    }

    public List<RequestHeader> getRequestHeaders() {
        return requestHeaders;
    }

    public void setRequestHeaders(List<RequestHeader> requestHeaders) {
        this.requestHeaders = requestHeaders;
    }

    public RequestBody getRequestBody() {
        return requestBody;
    }

    public void setRequestBody(RequestBody requestBody) {
        this.requestBody = requestBody;
    }

}

其中里面还进行进一步封装了请求行和请求头和请求体，代码如下：

package com.liushuai.model;

/**
 * 请求行实体
 * 
 * @author LiuShuai
 *
 */
public class RequestLine {
    /**
     * 请求方法
     */
    private String method;
    /**
     * 请求的 URL
     */
    private String url;
    /**
     * 版本
     */
    private String version;

    public RequestLine() {
        super();
    }

    public RequestLine(String method, String url, String version) {
        super();
        this.method = method;
        this.url = url;
        this.version = version;
    }

    public String getMethod() {
        return method;
    }

    public void setMethod(String method) {
        this.method = method;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getVersion() {
        return version;
    }

    public void setVersion(String version) {
        this.version = version;
    }

}

package com.liushuai.model;

/**
 * 请求头部实体
 * 
 * @author LiuShuai
 *
 */
public class RequestHeader {
    /**
     * 头部名称
     */
    private String name;
    /**
     * 头部域值
     */
    private String value;

    public RequestHeader() {
        super();
    }

    public RequestHeader(String name, String value) {
        super();
        this.name = name;
        this.value = value;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

}

package com.liushuai.model;

/**
 * 请求体
 * 
 * @author LiuShuai
 *
 */
public class RequestBody {

    private String requestBody;

    public RequestBody() {
        super();
    }

    public RequestBody(String requestBody) {
        super();
        this.requestBody = requestBody;
    }

    public String getRequestBody() {
        return requestBody;
    }

    public void setRequestBody(String requestBody) {
        this.requestBody = requestBody;
    }
    }

下面是在socket的基础上将数据进行封装，然后格式化为Http协议中要求的格式输出：

package com.liushuai.client;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;

import javax.management.relation.Relation;
import javax.sql.rowset.serial.SerialArray;

import com.liushuai.model.Request;
import com.liushuai.model.RequestHeader;
import com.liushuai.model.RequestLine;
import com.liushuai.server.MyServer;

public class MyClient {
    public static void main(String[] args) {
        InetAddress inet4Address;
        try {
            inet4Address = Inet4Address.getLocalHost();
            Socket socket = new Socket("123.126.51.32", 80);
            //请求行
            RequestLine rLine = new RequestLine("GET",
                    "http://download.pinyin.sogou.com/picface/interface/cellupdate.php?h=53B24101A353034C6F75D2DB4436AA80&v=8.0.0.8381&r=0000_sogou_pinyin_win10a&ver=1.0.0.1464&cellid=80|77|79|78|2|37|41|47|52|54&cellver=2|3|2|2|4|2|4|5|3|6",
                    "HTTP/1.1");
            //请求头
            RequestHeader rh1 = new RequestHeader("User-Agent", "SogouComponentAgent");
            RequestHeader rh2 = new RequestHeader("Host", "download.pinyin.sogou.com");
            RequestHeader rh3 = new RequestHeader("Pragma", "no-cache");
            RequestHeader rh4 = new RequestHeader("Cookie",
                    "YYID=53B24101A353034C6F75D2DB4436AA80; IMEVER=8.0.0.8381; IPLOC=CN3702");
            List<RequestHeader> rhs = new ArrayList<>();
            rhs.add(rh1);
            rhs.add(rh2);
            rhs.add(rh3);
            rhs.add(rh4);
            //构造请求，这里面让请求体为空了
            Request request = new Request(rLine, rhs, null);

            // 拼装一个Http请求
            StringBuffer requestString = new StringBuffer();
            // 拼装请求行
            RequestLine reqLine = request.getRequestLine();
            StringBuffer line = new StringBuffer();
            line.append(reqLine.getMethod()).append(" ").append(reqLine.getUrl()).append(" ")
                    .append(reqLine.getVersion()).append("\r\n");
            requestString.append(line);
            // 拼装请求头部
            List<RequestHeader> requestHeaders = request.getRequestHeaders();
            StringBuffer headers = new StringBuffer();
            for (RequestHeader h : requestHeaders) {
                headers.append(h.getName()).append(":").append(h.getValue()).append("\r\n");
            }
            requestString.append(headers).append("\r\n");
            if (request.getRequestBody()!= null) {
                requestString.append(request.getRequestBody().getRequestBody());
            }
            //向服务器发送请求的数据，数据已经拼装成了Http请求报文的格式
            PrintWriter printWriter = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
            printWriter.print(requestString.toString());
            printWriter.flush();

            BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            StringBuffer responseString = new StringBuffer(); 
            String servervInfo ;
            //读取服务器的响应，不过这地方会阻塞，因为Java I/O是线程阻塞的，优化一下代码应当使用Java NIO
            while((servervInfo = reader.readLine())!="\r\n"&&servervInfo!=null){
                System.out.println(servervInfo);
                responseString.append(servervInfo+"\n");
            }
            System.out.println("服务器端发送的数据为--->" + responseString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这就简单的模仿了一下Http的一次请求，我将返回结果进行了打印：

HTTP/1.1 200 OK
Server: nginx
Date: Tue, 11 Oct 2016 12:28:29 GMT
Content-Type: application/octet-stream
Content-Length: 0
Connection: keep-alive
X-Powered-By: PHP/7.0.8
Pragma: cache
Cache-Control: public, must-revalidate, max-age=0
Accept-Ranges: bytes
Content-Disposition: filename="SGPicFaceCellList.ini"

可以看出这次是请求成功了，返回的格式也符合Http中要求的格式。
这一篇就对HTTP协议进行了一次详细的介绍，下一篇中我准备分析一下当前最火的Android网络框架OkHttp源码中的实现。