一.HTTP协议：

   1.HTTP协议用于定义客户端与web服务器进行交互的格式
   2.HTTP是hypertext transfer protocol(超文本传输协议),是基于TCP/IP协议的应用层协议
   3.HTTP协议基于请求响应模型,一次请求对于一次响应,请求只能由客户端发出,服务器只能被动的
   等待请求作出响应
   4.HTTP/1.0 HTTP/1.1--(客户端与服务端的通信底层也是通过流来工作  )
      HTTP1.0中一次请求响应结束后服务器与浏览器的连接就会断开,每次请求响应都会新建一个流,响应结束后流就拆除
      HTTP1.1中响应后流不会立即拆除,等待一段时间,允许客户端与服务器建立连接后,在一个连接上获取多个web资源
  
   5.(真假不确定)客户端和服务端建立连接时，会进行tcp三次握手，服务器会响应给客户端具体协议信息，
     客户端再次发出请求，携带着刚才服务器响应回来的协议版本信息

         
二.HTTP请求和HTTP响应
  1.Http请求:
      请求行:请求行用于描述客户端的请求方式，请求的资源名称,以及使用的HTTP协议版本号
           GET /books/java.html HTTP/1.1
           请求方式:真正使用的就是GET和POST请求
                    GET:请求参数附加在请求URL的后面,作为请求URL的一部分带到服务器,特点是传输的数据大小不能超过1kb                    
                    POST:请求参数将会在请求的实体内容中向服务器发生数据,特点是传输的数据数量无限制
                     
           请求的资源名称:
           Http协议版本号:HTTP/1.0,HTTP/1.1...
                      
                       
      请求头:
              Accept: text/html,image/*    客户端可以接受的数据类型
              Accept-Charset: ISO-8859-1    客户端接受数据需要使用的字符集编码
              Accept-Encoding: gzip,compress 客户端可以接受的数据压缩格式
              Accept-Language: en-us,zh-cn  可接受的语言环境
              Host: www.:80 想要访问的虚拟主机名
              If-Modified-Since: Tue, 11 Jul 2000 18:23:51 GMT 这是和缓存相关的一个头，带着缓存资源的最后获取时间
              Referer: http://www./index.jsp 这个头表示当前的请求来自哪个链接，这个头和防盗链的功能相关
              User-Agent: Mozilla/4.0 (compatible; MSIE 5.5; Windows NT 5.0) 客户端的一些基本信息
              Cookie:         缓存在客户端的缓存信息
              Connection: close/Keep-Alive 指定是否继续保持连接
              Date: Tue, 11 Jul 2000 18:23:51 GMT 当前时间
             Cache-Control:no-cache  Cache-Control,Date和Connection为普通报头,请求头和响应头中都存在
              请求时的缓存指令包括：no-cache（用于指示请求或响应消息不能缓存）、no-store、max-age、max-stale、min-fresh、
                                    only-if-cached;
              响应时的缓存指令包括：public、private、no-cache、no-store、no-transform、must-revalidate、proxy-revalidate、
                                    max-age、s-maxage 
                
      实体内容: 
           username=liu&password=123
          
  2.Http响应:
     状态行：
        HTTP/1.1 200 OK
             HTTP/1.1:协议版本
             200:状态码--用来表示本次请求的处理结果的代码
                    200：请求成功
                    302：要实现一个请求重定向的功能,浏览器自动访问新的地址
                    304/307：使用缓存资源
                    404：找不到资源
                    500：服务器端错误
           OK:状态描述
           
     若干响应头：
             Location: http://www./index.jsp   配合302实现请求重定向
             Server:apache  tomcat服务器的基本信息
             Content-Encoding: gzip 服务器发送数据时使用的压缩格式
             Content-Length: 80  发送数据的大小
             Content-Language: zh-cn  发送的数据使用的语言环境
             Content-Type: text/html; charset=GB2312 当前所发送的数据的基本信息，（数据的类型，所使用的编码）
             Last-Modified: Tue, 11 Jul 2000 18:23:51 GMT  缓存相关的头(配合http请求头的If-Modified-Since和304,307实现缓存功能)
             Refresh: 1;url=http://www. 通知浏览器进行定时刷新，此值可以是一个数字指定多长时间以后刷新当前页面，这个数   字之后也可以接一个分号后跟一个URL地址指定多长时间后刷新到哪个URL
             Content-Disposition: attachment;filename=aaa.zip 与下载相关的头
             Transfer-Encoding: chunked 传输类型，如果是此值是一个chunked说明当前的数据是一块一块传输的
             Set-Cookie:SS=Q0=5Lb_nQ; path=/search 和cookie相关的头，后面课程单讲
             ETag: W/"83794-1208174400000" 和缓存机制相关的头
             Expires: -1 指定资源缓存的时间，如果取值为0或-1浏览就不缓存资源
             Cache-Control: no-cache  缓存相关的头，如果为no-cache则通知浏览器不缓存
             Pragma: no-cache   缓存相关的头，如果为no-cache则不缓存
             以上三个头都是用来控制缓存的，是因为历史原因造成的，不同的浏览器认识不同的头，我们通常三个一起使用保证通用性。
             Connection: close/Keep-Alive   是否保持连接
             Date: Tue, 11 Jul 2000 18:23:51 GMT 当前时间
       
     实体内容：
            
   
三.Http协议之文件上传

     文件上传是我们项目中经常使用的功能，一般我们的服务器可能都是web服务器，当我们使用非浏览器客户端上传文件时，比如手机（Android）等上传，可能就需要对传输的数据进行规范化的拼接，说白了，就是我们得自己完成浏览器帮我们做的事。 我们先来看文件上传对应的Http请求头信息，

       

         这幅图是上次在一个Android群一个大神整理的，写的很不错，秉着拿来主义就拿来用了

         好了，下面开始实现上传，模拟浏览器的操作。

   1、使用HttpUrlConnection

    

[html] view plain copy

1. private static final String BOUNDARY = "----WebKitFormBoundaryT1HoybnYeFOGFlBR";    
2.     
3.     /**   
4.      *    
5.      * @param params   
6.      *            传递的普通参数   
7.      * @param uploadFile   
8.      *            需要上传的文件名   
9.      * @param fileFormName   
10.      *            需要上传文件表单中的名字   
11.      * @param newFileName   
12.      *            上传的文件名称，不填写将为uploadFile的名称   
13.      * @param urlStr   
14.      *            上传的服务器的路径   
15.      * @throws IOException   
16.      */    
17.     public void uploadForm(Map<String, String> params, String fileFormName,    
18.             File uploadFile, String newFileName, String urlStr)    
19.             throws IOException {    
20.         if (newFileName == null || newFileName.trim().equals("")) {    
21.             newFileName = uploadFile.getName();    
22.         }    
23.     
24.         StringBuilder sb = new StringBuilder();    
25.         /**   
26.          * 普通的表单数据   
27.          */    
28.         for (String key : params.keySet()) {    
29.             sb.append("--" + BOUNDARY + "\r\n");    
30.             sb.append("Content-Disposition: form-data; name=\"" + key + "\""    
31.                     + "\r\n");    
32.             sb.append("\r\n");    
33.             sb.append(params.get(key) + "\r\n");    
34.         }    
35.         /**   
36.          * 上传文件的头   
37.          */    
38.         sb.append("--" + BOUNDARY + "\r\n");    
39.         sb.append("Content-Disposition: form-data; name=\"" + fileFormName    
40.                 + "\"; filename=\"" + newFileName + "\"" + "\r\n");    
41.         sb.append("Content-Type: image/jpeg" + "\r\n");// 如果服务器端有文件类型的校验，必须明确指定ContentType    
42.         sb.append("\r\n");    
43.     
44.         byte[] headerInfo = sb.toString().getBytes("UTF-8");    
45.         byte[] endInfo = ("\r\n--" + BOUNDARY + "--\r\n").getBytes("UTF-8");    
46.         System.out.println(sb.toString());    
47.         URL url = new URL(urlStr);    
48.         HttpURLConnection conn = (HttpURLConnection) url.openConnection();    
49.         conn.setRequestMethod("POST");    
50.         conn.setRequestProperty("Content-Type",    
51.                 "multipart/form-data; boundary=" + BOUNDARY);    
52.         conn.setRequestProperty("Content-Length", String    
53.                 .valueOf(headerInfo.length + uploadFile.length()    
54.                         + endInfo.length));    
55.         conn.setDoOutput(true);    
56.     
57.         OutputStream out = conn.getOutputStream();    
58.         InputStream in = new FileInputStream(uploadFile);    
59.         out.write(headerInfo);    
60.     
61.         byte[] buf = new byte[1024];    
62.         int len;    
63.         while ((len = in.read(buf)) != -1)    
64.             out.write(buf, 0, len);    
65.     
66.         out.write(endInfo);    
67.         in.close();    
68.         out.close();    
69.         if (conn.getResponseCode() == 200) {    
70.             System.out.println("上传成功");    
71.         }    
72.     
73.     }    

详细解释一下，首先我拼接了需要发送的数据，其实就是咱们在图三中看到的数据，然后使用HttpUrlConnetion设置了一系列属性其实就是在设置图二中看到的请求头信息。

于是，我们完成了请求头的设置，以及需要上传数据的拼接，所以我们完成了浏览器的工作，自然就实现文件上传了。

2、使用Socket实现文件上传，参数基本一致，使用HttpUrlConnection上传有一个很致命的问题就是，当上传文件很大时，会发生内存溢出，手机分配给我们app的内存更小，所以就更需要解决这个问题，于是我们可以使用Socket模拟POST进行HTTP文件上传。

[java] view plain copy

1. /**  
2.  *   
3.  * @param params  
4.  *            传递的普通参数  
5.  * @param uploadFile  
6.  *            需要上传的文件名  
7.  * @param fileFormName  
8.  *            需要上传文件表单中的名字  
9.  * @param newFileName  
10.  *            上传的文件名称，不填写将为uploadFile的名称  
11.  * @param urlStr  
12.  *            上传的服务器的路径  
13.  * @throws IOException  
14.  */    
15. public void uploadFromBySocket(Map<String, String> params,    
16.         String fileFormName, File uploadFile, String newFileName,    
17.         String urlStr) throws IOException {    
18.     if (newFileName == null || newFileName.trim().equals("")) {    
19.         newFileName = uploadFile.getName();    
20.     }    
21.     
22.     StringBuilder sb = new StringBuilder();    
23.     /**  
24.      * 普通的表单数据  
25.      */    
26.     
27.     if (params != null)    
28.         for (String key : params.keySet()) {    
29.             sb.append("--" + BOUNDARY + "\r\n");    
30.             sb.append("Content-Disposition: form-data; name=\"" + key    
31.                     + "\"" + "\r\n");    
32.             sb.append("\r\n");    
33.             sb.append(params.get(key) + "\r\n");    
34.         }                                                                                                                                                  else{ab.append("\r\n");}    
35.     /**  
36.      * 上传文件的头  
37.      */    
38.     sb.append("--" + BOUNDARY + "\r\n");    
39.     sb.append("Content-Disposition: form-data; name=\"" + fileFormName    
40.             + "\"; filename=\"" + newFileName + "\"" + "\r\n");    
41.     sb.append("Content-Type: image/jpeg" + "\r\n");// 如果服务器端有文件类型的校验，必须明确指定ContentType    
42.     sb.append("\r\n");    
43.     
44.     byte[] headerInfo = sb.toString().getBytes("UTF-8");    
45.     byte[] endInfo = ("\r\n--" + BOUNDARY + "--\r\n").getBytes("UTF-8");    
46.     
47.     System.out.println(sb.toString());    
48.     
49.     URL url = new URL(urlStr);    
50.     Socket socket = new Socket(url.getHost(), url.getPort());    
51.     OutputStream os = socket.getOutputStream();    
52.     PrintStream ps = new PrintStream(os, true, "UTF-8");    
53.     
54.     // 写出请求头    
55.     ps.println("POST " + urlStr + " HTTP/1.1");    
56.     ps.println("Content-Type: multipart/form-data; boundary=" + BOUNDARY);    
57.     ps.println("Content-Length: "    
58.             + String.valueOf(headerInfo.length + uploadFile.length()    
59.                     + endInfo.length));    
60.     ps.println("Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");    
61.     
62.     InputStream in = new FileInputStream(uploadFile);    
63.     // 写出数据    
64.     os.write(headerInfo);    
65.     
66.     byte[] buf = new byte[1024];    
67.     int len;    
68.     while ((len = in.read(buf)) != -1)    
69.         os.write(buf, 0, len);    
70.     
71.     os.write(endInfo);    
72.     
73.     in.close();    
74.     os.close();    
75. }    

   这里因为我们使用的是Socket，所以自然对于请求头，我们也需要自己拼接了，没有什么属性设置了。我们使用PrintStream完成了请求头的拼接，接下来就是数据的拼接，这和使用HttpUrlConnection的方式一致。我们也完成了数据的上传。